add documentation

This commit is contained in:
Chris Cromer 2022-04-13 00:59:23 -04:00
parent 219b277e5c
commit 1c24ba0cd1
Signed by: cromer
GPG Key ID: FA91071797BEEEC2
12 changed files with 529 additions and 30 deletions

View File

@ -8,18 +8,37 @@
/** /**
* @brief This is the godot namespace for all the code included in the library. * @brief This is the godot namespace for all the code included in the library.
*
* @details This namespace is used a prefix when the Godot engine looks for classes, methods, and properties. * @details This namespace is used a prefix when the Godot engine looks for classes, methods, and properties.
*/ */
namespace godot namespace godot
{ {
/**
* @brief This namespace houses some global variables and the main class.
*
*/
namespace main namespace main
{ {
/**
* @brief The default value for if the game should start in full screen.
*
*/
const bool full_screen = false; const bool full_screen = false;
/**
* @brief The default resolution for the game window.
*
*/
const Vector2 window_size = Vector2(1280, 720); const Vector2 window_size = Vector2(1280, 720);
/**
* @brief The default screen the the game should open on.
*
* @details -1 opens it on the currently active screen. And 0 and above are the screens to use.
*/
const int8_t launch_screen = -1; const int8_t launch_screen = -1;
/** /**
* @brief This class controls the Main node. * @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 controling the window and the game iteself is a child of it.
*/ */
class Main : public Node class Main : public Node
@ -29,57 +48,68 @@ namespace godot
private: private:
/** /**
* @brief OS singleton. * @brief OS singleton.
*
*/ */
OS *_os; OS *_os;
/** /**
* @brief Input singleton. * @brief Input singleton.
*
*/ */
Input *_input; Input *_input;
/** /**
* @brief If the window is full screen or not. * @brief If the window is full screen or not.
*
*/ */
bool full_screen; bool full_screen;
/** /**
* @brief The size of the window. * @brief The size of the window.
*
*/ */
Vector2 window_size; Vector2 window_size;
/** /**
* @brief The screen to launch the game on. * @brief The screen to launch the game on.
*
*/ */
int8_t launch_screen; int8_t launch_screen;
public: public:
/** /**
* @brief This method registers classes with Godot. * @brief This method registers classes with Godot.
*
* @details This method registers methods, properties, and signals with the Godot engine. * @details This method registers methods, properties, and signals with the Godot engine.
*/ */
static void _register_methods(); static void _register_methods();
/** /**
* @brief Construct a new Main object. * @brief Construct a new Main object.
*
*/ */
Main(); Main();
/** /**
* @brief Destroy the Main object. * @brief Destroy the Main object.
*
*/ */
~Main(); ~Main();
/** /**
* @brief Initialize the class from Godot. * @brief Initialize the class from Godot.
*
* @details This method is called just once when the Godot engine connects to the instance of the class. * @details This method is called just once when the Godot engine connects to the instance of the class.
*/ */
void _init(); void _init();
/** /**
* @brief Code to be run when ready. * @brief Code to be run when ready.
*
* @details This method is run when all the children of this node are ready. * @details This method is run when all the children of this node are ready.
*/ */
void _ready(); void _ready();
/** /**
* @brief This class handles the physics processing. * @brief This class handles the physics processing.
*
* @details Every delta time, this function is called to check for input and update positioning. * @details Every delta time, this function is called to check for input and update positioning.
* *
* @param[in] delta The difference in time that passed since the last call to this method. * @param[in] delta The difference in time that passed since the last call to this method.

View File

@ -11,11 +11,19 @@
using namespace godot; using namespace godot;
/**
* @brief This function connects the gdnative init function.
*
*/
extern "C" void GDN_EXPORT godot_gdnative_init(godot_gdnative_init_options *o) extern "C" void GDN_EXPORT godot_gdnative_init(godot_gdnative_init_options *o)
{ {
Godot::gdnative_init(o); Godot::gdnative_init(o);
} }
/**
* @brief This function connects the gdnative terminate function.
*
*/
extern "C" void GDN_EXPORT godot_gdnative_terminate(godot_gdnative_terminate_options *o) extern "C" void GDN_EXPORT godot_gdnative_terminate(godot_gdnative_terminate_options *o)
{ {
// This next line is a workaround to fix bug: // This next line is a workaround to fix bug:
@ -24,6 +32,10 @@ extern "C" void GDN_EXPORT godot_gdnative_terminate(godot_gdnative_terminate_opt
Godot::gdnative_terminate(o); Godot::gdnative_terminate(o);
} }
/**
* @brief This function connects the init methods in the classes to godot's gdnative.
*
*/
extern "C" void GDN_EXPORT godot_nativescript_init(void *handle) extern "C" void GDN_EXPORT godot_nativescript_init(void *handle)
{ {
Godot::nativescript_init(handle); Godot::nativescript_init(handle);

View File

@ -10,21 +10,51 @@
/** /**
* @brief This is the godot namespace for all the code included in the library. * @brief This is the godot namespace for all the code included in the library.
*
* @details This namespace is used a prefix when the Godot engine looks for classes, methods, and properties. * @details This namespace is used a prefix when the Godot engine looks for classes, methods, and properties.
*/ */
namespace godot namespace godot
{ {
/**
* @brief This namespace contains the global variables related to the player and its states.
*
*/
namespace player namespace player
{ {
/**
* @brief The default sprite resource of the player.
*
*/
const char player_sprite_frames[] = "res://characters/player/sprites/green.tres"; const char player_sprite_frames[] = "res://characters/player/sprites/green.tres";
/**
* @brief The default speed of the player.
*
*/
const float speed = 60.0; const float speed = 60.0;
/**
* @brief The default jump force applied when jumping.
*
*/
const float jump_force = 300.0; const float jump_force = 300.0;
/**
* @brief The default gravity applied to the player.
*
*/
const float gravity = 9.81; const float gravity = 9.81;
/**
* @brief The default run speed multiplier.
*
*/
const float run_speed = 2.0; const float run_speed = 2.0;
/**
* @brief The default double jump activation state.
*
*/
const bool double_jump = true; const bool double_jump = true;
/** /**
* @brief This class is used to control the player. * @brief This class is used to control the player.
*
* @details This class allows the player to move, run, and jump as well as controls the sprite displayed for those actions. * @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 KinematicBody2D
@ -34,75 +64,93 @@ namespace godot
private: private:
/** /**
* @brief ResourceLoader singleton. * @brief ResourceLoader singleton.
*
*/ */
ResourceLoader *_resource_loader; ResourceLoader *_resource_loader;
/** /**
* @brief The animated sprite connected to the KinematicBody2D. * @brief The animated sprite connected to the KinematicBody2D.
*
*/ */
AnimatedSprite *animated_sprite; AnimatedSprite *animated_sprite;
/** /**
* @brief The sprite frames used in the animated sprite. * @brief The sprite frames used in the animated sprite.
*
*/ */
Ref<SpriteFrames> sprite_frames; Ref<SpriteFrames> sprite_frames;
/** /**
* @brief The coins the player has collected. * @brief The coins the player has collected.
*
*/ */
uint8_t coins; uint8_t coins;
/** /**
* @brief The velocity at which moves the player moves. * @brief The velocity at which moves the player moves.
*
*/ */
Vector2 velocity; Vector2 velocity;
/** /**
* @brief The speed that the player moves in. * @brief The speed that the player moves in.
*
*/ */
float speed; float speed;
/** /**
* @brief The force applied to the player when jumping. * @brief The force applied to the player when jumping.
*
*/ */
float jump_force; float jump_force;
/** /**
* @brief The gravity applied to the player. * @brief The gravity applied to the player.
*
*/ */
float gravity; float gravity;
/** /**
* @brief The speed multiplier used to make the player move faster. * @brief The speed multiplier used to make the player move faster.
*
*/ */
float run_speed; float run_speed;
/**
* @brief If double jump is enabled or not.
*
*/
bool double_jump; bool double_jump;
public: public:
/** /**
* @brief This method registers classes with Godot. * @brief This method registers classes with Godot.
*
* @details This method registers methods, properties, and signals with the Godot engine. * @details This method registers methods, properties, and signals with the Godot engine.
*/ */
static void _register_methods(); static void _register_methods();
/** /**
* @brief Construct a new Player object. * @brief Construct a new Player object.
*
*/ */
Player(); Player();
/** /**
* @brief Destroy the Player object. * @brief Destroy the Player object.
*
*/ */
~Player(); ~Player();
/** /**
* @brief Initialize the class from Godot. * @brief Initialize the class from Godot.
*
* @details This method is called just once when the Godot engine connects to the instance of the class. * @details This method is called just once when the Godot engine connects to the instance of the class.
*/ */
void _init(); void _init();
/** /**
* @brief Code to be run when ready. * @brief Code to be run when ready.
*
* @details This method is run when all the children of this node are ready. * @details This method is run when all the children of this node are ready.
*/ */
void _ready(); void _ready();
/** /**
* @brief This class handles the physics processing. * @brief This class handles the physics processing.
*
* @details Every delta time, this function is called to check for input and update positioning. * @details Every delta time, this function is called to check for input and update positioning.
* *
* @param[in] delta The difference in time that passed since the last call to this method. * @param[in] delta The difference in time that passed since the last call to this method.
@ -179,10 +227,33 @@ namespace godot
*/ */
float get_run_speed(); float get_run_speed();
/**
* @brief Set the double jump object.
*
* @param[in] double_jump The new double dump value.
*/
void set_double_jump(bool double_jump); void set_double_jump(bool double_jump);
/**
* @brief Get the double jump object.
*
* @return true If double jump is enabled.
* @return false If double jump is disabled.
*/
bool get_double_jump(); bool get_double_jump();
/**
* @brief Set the velocity object.
*
* @param[in] velocity The new velocity of the player.
*/
void set_velocity(Vector2 velocity); void set_velocity(Vector2 velocity);
/**
* @brief Get the velocity object.
*
* @return Vector2 Returns the velocity of the player.
*/
Vector2 get_velocity(); Vector2 get_velocity();
}; };
} }

View File

@ -7,35 +7,80 @@
#include <Input.hpp> #include <Input.hpp>
#include <AnimatedSprite.hpp> #include <AnimatedSprite.hpp>
/**
* @brief This is the godot namespace for all the code included in the library.
*
* @details This namespace is used a prefix when the Godot engine looks for classes, methods, and properties.
*/
namespace godot namespace godot
{ {
namespace player namespace player
{ {
/**
* @brief This class controls what happens when the player is in a falling state.
*
*/
class PlayerFall : public State class PlayerFall : public State
{ {
GODOT_CLASS(PlayerFall, State) GODOT_CLASS(PlayerFall, State)
private: private:
/**
* @brief Input singleton.
*
*/
Input *_input; Input *_input;
/**
* @brief The animated sprite connected to the player.
*
*/
AnimatedSprite *animated_sprite; AnimatedSprite *animated_sprite;
public: public:
/**
* @brief This method registers classes with Godot.
*
* @details This method registers methods, properties, and signals with the Godot engine.
*/
static void _register_methods(); static void _register_methods();
/**
* @brief Construct a new Player Fall object.
*
*/
PlayerFall(); PlayerFall();
/**
* @brief Destroy the Player Fall object.
*
*/
~PlayerFall(); ~PlayerFall();
/** /**
* @brief Initialize the class from Godot. * @brief Initialize the class from Godot.
*
* @details This method is called just once when the Godot engine connects to the instance of the class. * @details This method is called just once when the Godot engine connects to the instance of the class.
*/ */
void _init(); void _init();
/**
* @brief Called when the fall state is entered.
*
*/
void _state_enter(); void _state_enter();
/**
* @brief Called when the fall state is exited.
*
*/
void _state_exit(); void _state_exit();
/**
* @brief The physics processed every delta time.
*
* @param[in] delta The time since the method was last run.
*/
void _physics_process(float delta); void _physics_process(float delta);
}; };
} }

View File

@ -12,31 +12,70 @@ namespace godot
{ {
namespace player namespace player
{ {
/**
* @brief This class controls what happens when the player is in the idle state.
*
*/
class PlayerIdle : public State class PlayerIdle : public State
{ {
GODOT_CLASS(PlayerIdle, State) GODOT_CLASS(PlayerIdle, State)
private: private:
/**
* @brief Input singleton.
*
*/
Input *_input; Input *_input;
/**
* @brief The animated sprite of the player.
*
*/
AnimatedSprite *animated_sprite; AnimatedSprite *animated_sprite;
public: public:
/**
* @brief This method registers classes with Godot.
*
* @details This method registers methods, properties, and signals with the Godot engine.
*/
static void _register_methods(); static void _register_methods();
/**
* @brief Construct a new Player Idle object.
*
*/
PlayerIdle(); PlayerIdle();
/**
* @brief Destroy the Player Idle object.
*
*/
~PlayerIdle(); ~PlayerIdle();
/** /**
* @brief Initialize the class from Godot. * @brief Initialize the class from Godot.
*
* @details This method is called just once when the Godot engine connects to the instance of the class. * @details This method is called just once when the Godot engine connects to the instance of the class.
*/ */
void _init(); void _init();
/**
* @brief Called when the idle state is entered.
*
*/
void _state_enter(); void _state_enter();
/**
* @brief Called when the idle state is exited.
*
*/
void _state_exit(); void _state_exit();
/**
* @brief The physics processed every delta time.
*
* @param[in] delta The time since the method was last run.
*/
void _physics_process(float delta); void _physics_process(float delta);
}; };
} }

View File

@ -11,32 +11,78 @@ namespace godot
{ {
namespace player namespace player
{ {
/**
* @brief This class control what happens when the player is in the jump state.
*
*/
class PlayerJump : public State class PlayerJump : public State
{ {
GODOT_CLASS(PlayerJump, State) GODOT_CLASS(PlayerJump, State)
private: private:
/**
* @brief Input singleton.
*
*/
Input *_input; Input *_input;
/**
* @brief The animated sprite connected to the player.
*
*/
AnimatedSprite *animated_sprite; AnimatedSprite *animated_sprite;
/**
* @brief If the player has already performed a double jump or not.
*
*/
bool double_jumped; bool double_jumped;
public: public:
/**
* @brief This method registers classes with Godot.
*
* @details This method registers methods, properties, and signals with the Godot engine.
*/
static void _register_methods(); static void _register_methods();
/**
* @brief Construct a new Player Jump object.
*
*/
PlayerJump(); PlayerJump();
/**
* @brief Destroy the Player Jump object.
*
*/
~PlayerJump(); ~PlayerJump();
/** /**
* @brief Initialize the class from Godot. * @brief Initialize the class from Godot.
*
* @details This method is called just once when the Godot engine connects to the instance of the class. * @details This method is called just once when the Godot engine connects to the instance of the class.
*/ */
void _init(); void _init();
/**
* @brief Called when the player enters the jump state.
*
* @details If the previous state was the jump state, a double jump was performed.
*
* @param[in] state The previous state before this one was entered.
*/
void _state_enter(const String state); void _state_enter(const String state);
/**
* @brief Called when the player exits the jump state.
*
*/
void _state_exit(); void _state_exit();
/**
* @brief The physics processed every delta time.
*
* @param[in] delta The time since the method was last run.
*/
void _physics_process(float delta); void _physics_process(float delta);
}; };
} }

View File

@ -24,7 +24,7 @@ void PlayerMove::_init()
_input = Input::get_singleton(); _input = Input::get_singleton();
} }
void PlayerMove::_state_enter(String state, Array args) void PlayerMove::_state_enter()
{ {
animated_sprite = get_parent()->get_node<AnimatedSprite>("AnimatedSprite"); animated_sprite = get_parent()->get_node<AnimatedSprite>("AnimatedSprite");
animated_sprite->set_animation("move"); animated_sprite->set_animation("move");

View File

@ -11,34 +11,71 @@ namespace godot
{ {
namespace player namespace player
{ {
/**
* @brief This class controls what happens when the player is in the move state.
*
*/
class PlayerMove : public State class PlayerMove : public State
{ {
GODOT_CLASS(PlayerMove, State) GODOT_CLASS(PlayerMove, State)
private: private:
/**
* @brief Input singleton.
*
*/
Input *_input; Input *_input;
/**
* @brief The animated sprite of the player.
*
*/
AnimatedSprite *animated_sprite; AnimatedSprite *animated_sprite;
public: public:
/**
* @brief This method registers classes with Godot.
*
* @details This method registers methods, properties, and signals with the Godot engine.
*/
static void _register_methods(); static void _register_methods();
/**
* @brief Construct a new Player Move object.
*
*/
PlayerMove(); PlayerMove();
/**
* @brief Destroy the Player Move object.
*
*/
~PlayerMove(); ~PlayerMove();
/** /**
* @brief Initialize the class from Godot. * @brief Initialize the class from Godot.
*
* @details This method is called just once when the Godot engine connects to the instance of the class. * @details This method is called just once when the Godot engine connects to the instance of the class.
*/ */
void _init(); void _init();
void _state_enter(String state, Array args); /**
* @brief Called when the player enters the move state.
*
*/
void _state_enter();
/**
* @brief Called when the player exists the move state.
*
*/
void _state_exit(); void _state_exit();
/**
* @brief The physics processed every delta time.
*
* @param[in] delta The time since the method was last run.
*/
void _physics_process(float delta); void _physics_process(float delta);
Vector2 move_player(Vector2 velocity);
}; };
} }
} }

View File

@ -1,4 +1,4 @@
#include "State.h" #include "state_machine/State.h"
using namespace godot; using namespace godot;

View File

@ -8,37 +8,95 @@
namespace godot namespace godot
{ {
/**
* @brief This class provides a virtual template state that real states should extend from and override.
*
*/
class State : public StateMachine class State : public StateMachine
{ {
GODOT_CLASS(State, Node) GODOT_CLASS(State, Node)
private: private:
/**
* @brief The state's parent, this is the node 1 level above the state machine.
*
*/
Node *parent;
/**
* @brief The state machine itself, used to handle all state related work.
*
*/
StateMachine *state_machine; StateMachine *state_machine;
public: public:
Node *parent; /**
* @brief This method registers classes with Godot.
*
* @details This method registers methods, properties, and signals with the Godot engine.
*/
static void _register_methods(); static void _register_methods();
/**
* @brief Construct a new State object.
*
*/
State(); State();
/**
* @brief Destroy the State object.
*
*/
~State(); ~State();
/** /**
* @brief Initialize the class from Godot. * @brief Initialize the class from Godot.
*
* @details This method is called just once when the Godot engine connects to the instance of the class. * @details This method is called just once when the Godot engine connects to the instance of the class.
*/ */
virtual void _init(); virtual void _init();
/**
* @brief This is called when a state is entered.
*
* @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 String state, const Array args = Array());
/**
* @brief This is called when a state is exited.
*
* @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 String state, const Array args = 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(Node *parent) final;
/**
* @brief Get the parent object.
*
* @return Node* The parent of the state.
*/
virtual Node *get_parent() final; virtual Node *get_parent() final;
/**
* @brief Set the state machine object.
*
* @param[in] state_machine The state machine.
*/
virtual void set_state_machine(StateMachine *state_machine) final; virtual void set_state_machine(StateMachine *state_machine) final;
/**
* @brief Get the state machine object.
*
* @return StateMachine* The state machine.
*/
virtual StateMachine *get_state_machine() final; virtual StateMachine *get_state_machine() final;
}; };
} }

View File

@ -1,5 +1,5 @@
#include "StateMachine.h" #include "state_machine/StateMachine.h"
#include "State.h" #include "state_machine/State.h"
using namespace godot; using namespace godot;

View File

@ -6,89 +6,250 @@
namespace godot namespace godot
{ {
/**
* @brief This class provides a finite state machine that can be used with any scene and node.
*
*/
class StateMachine : public Node class StateMachine : public Node
{ {
GODOT_CLASS(StateMachine, Node) GODOT_CLASS(StateMachine, Node)
private: private:
/**
* @brief The parent node which is one level above the state machine.
*
*/
Node *parent; 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; String default_state;
/**
* @brief If set to true the state machine will print a message showing when it enters or exits a state.
*
*/
bool debug; bool debug;
/**
* @brief The current state the machine is in.
*
*/
String current_state; String current_state;
/**
* @brief A list of the states in the state machine.
*
*/
Dictionary states; Dictionary states;
/**
* @brief This adds a state to the list of states in the state machine.
*
* @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 String state, Node *child);
public: public:
/**
* @brief This method registers classes with Godot.
*
* @details This method registers methods, properties, and signals with the Godot engine.
*/
static void _register_methods(); static void _register_methods();
/**
* @brief Construct a new State Machine object.
*/
StateMachine(); StateMachine();
/**
* @brief Destroy the State Machine object.
*/
~StateMachine(); ~StateMachine();
/** /**
* @brief Initialize the class from Godot. * @brief Initialize the class from Godot.
*
* @details This method is called just once when the Godot engine connects to the instance of the class. * @details This method is called just once when the Godot engine connects to the instance of the class.
*/ */
void _init(); void _init();
/** /**
* @brief Code to be run when ready. * @brief Code to be run when ready.
*
* @details This method is run when all the children of this node are ready. * @details This method is run when all the children of this node are ready.
*/ */
void _ready(); void _ready();
/**
* @brief This method will remove all no default states from the scene tree and start the default state.
*
*/
void setup(); void setup();
bool is_current(); /**
* @brief Check if the given state is the current running state.
*
* @param[in] state The state to compare with the running state.
* @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 String state);
/**
* @brief Check if the state machine has a given state.
*
* @param[in] state The state to check for.
* @return true If the state exists.
* @return false If the state doesn't exist.
*/
bool has(const String state); bool has(const String state);
/**
* @brief Restar the running state by calling its enter and exit methods.
*
* @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 String state, const Array& args = Array());
/**
* @brief Change to a different state.
*
* @details If the running state is the same as the state it will restart it.
*
* @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 String state, const Array &args = Array());
/**
* @brief Call a registered godot method in the class.
*
* @param[in] method The method name to call.
* @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()); Variant call(const String method, const Array &args = Array());
/**
* @brief This method is to link up a signal call back.
*
* @param[in] method The method to call for the signal.
* @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()); Variant _call(const String method, const Array &args = Array());
template <class ...Args> Variant restart(Args ...args) /**
* @brief Set the default state object.
*
* @param[in] default_state The new default state.
*/
void set_default_state(const String default_state);
/**
* @brief Get the default state object.
*
* @return String The default state.
*/
String get_default_state();
/**
* @brief Set the debug object.
*
* @param[in] debug Whether or not to debug.
*/
void set_debug(bool debug);
/**
* @brief Get the debug object.
*
* @return true If debugging is enabled.
* @return false If debugging is disabled.
*/
bool get_debug();
/**
* @brief Set the current state object.
*
* @param[in] current_state The current state that is running.
*/
void set_current_state(const String current_state);
/**
* @brief Get the current state object.
*
* @return String The current running state.
*/
String get_current_state();
/**
* @brief This method is called when the signal tree_entered is emitted.
*
* @details This will run the setup method to prepare the state machine for use.
*/
void _on_StateMachine_tree_entered();
/**
* @brief This method is called when the signal tree_exiting is emitted.
*
* @details If the tree is in the exiting state readd all the removed state nodes to the scene tree.
* This is important because the memory won't be freed if they are no longer in the scene tree.
*/
void _on_StateMachine_tree_exiting();
/**
* @brief Restarts the running state.
*
* @tparam 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 <class ...Args> void restart(const String state, Args ...args)
{ {
return restart(Array::make(args...)); return restart(state, Array::make(args...));
} }
template <class ...Args> Variant change(const String state, Args ...args) /**
* @brief Changes to a new state.
*
* @tparam Args Variable number of arguments to pass when chaning states.
* @param[in] state The state to change to.
* @param[in] args The arguments to pass to the new state.
*/
template <class ...Args> void change(const String state, Args ...args)
{ {
return change(state, Array::make(args...)); return change(state, Array::make(args...));
} }
/**
* @brief Call a registered godot method in the class.
*
* @tparam 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 <class ...Args> Variant call(const String method, Args ...args) template <class ...Args> Variant call(const String method, Args ...args)
{ {
return call(method, Array::make(args...)); return call(method, 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[in] method The method to call.
* @param[in] args The arguments to pass.
* @return Variant The Variant object returned by the method called.
*/
template <class ...Args> Variant _call(const String method, Args ...args) template <class ...Args> Variant _call(const String method, Args ...args)
{ {
return _call(method, Array::make(args...)); return _call(method, Array::make(args...));
} }
void set_default_state(const String default_state);
String get_default_state();
void set_debug(bool debug);
bool get_debug();
void set_current_state(const String current_state);
String get_current_state();
void _on_StateMachine_tree_entered();
void _on_StateMachine_tree_exiting();
}; };
} }