godot-cpp-utils/game_root.hpp

150 lines
5.5 KiB
C++

#ifndef UTILS_GAME_ROOT_HPP
#define UTILS_GAME_ROOT_HPP
#include "game_mode.hpp"
#include "game_state.hpp"
#include "level.hpp"
#include <godot_cpp/classes/node.hpp>
#include <godot_cpp/classes/packed_scene.hpp>
#include <godot_cpp/classes/random_number_generator.hpp>
#include <godot_cpp/templates/hash_map.hpp>
#include <godot_cpp/templates/hash_set.hpp>
#include <godot_cpp/templates/pair.hpp>
#include <godot_cpp/templates/pair.hpp>
#include <godot_cpp/templates/vector.hpp>
namespace gd = godot;
namespace utils {
class PlayerInput;
class IPlayer;
class SpawnPoint3D;
/*! The root of a game.
*
* A game root node that manages levels and input devices.
* Can be loaded at any point in a game's life, but suggested is setting this as the root of the boot scene.
*/
class GameRoot3D : public gd::Node {
GDCLASS(GameRoot3D, gd::Node);
static void _bind_methods();
public:
//! get the current active singleton instance of GameRoot
static GameRoot3D *get_singleton();
//! returns true if there is currently a singleton active for GameRoot
static bool has_singleton();
virtual void _enter_tree() override;
virtual void _ready() override;
virtual void _exit_tree() override;
/*! Instantiate a new PlayerInput.
*
* Does not automatically spawn a new player, but does notify game mode.
*/
void player_input_connected();
/*! Force-disconnect a player
*
* Calls queue_free on the IPlayer instance
*/
void remove_player(uint32_t player_id);
// calls remove_player for every used player input slot
void remove_all_players();
/*! Initialize and register a player instance.
*
* The player will be added to the tree and AFTER setup_player_input will be called.
* This way the player can initialize before setting up input
*/
bool initialize_player(IPlayer *player, uint32_t id);
/*! Un-set game mode.
* Shorthand for `set_game_mode(Ref<PackedScene>())`
*/
void reset_game_mode();
//! shorthand for load_level(level, Transform3D())
Level3D *load_level(gd::Ref<gd::PackedScene> level);
/*! Load a level, only works if 'level' is a valid scene where the root Node can cast to 'Level3D'.
*
* \param at Sets the root node's global transform.
*/
Level3D *load_level_at(gd::Ref<gd::PackedScene> level, gd::Transform3D at);
//! Unload all currently loaded levels.
void unload_all_levels();
/*! Replace all currently loaded levels with a new level.
*
* Shorthand for
* ```
* unload_all_levels();
* load_level(level);
* ```
*/
void replace_levels(gd::Ref<gd::PackedScene> level);
//! Register a spawnpoint for use when spawning players
void register_spawn_point(SpawnPoint3D *spawn_point);
// remove a spawnpoint so it can't be used to spawn players
void unregister_spawn_point(SpawnPoint3D *spawn_point);
void place_player_at_spawnpoint(IPlayer *player);
void player_despawned(uint32_t id);
/*! Override the current gamemode.
*
* Replaces game mode requires destroying and respawning all players
*/
void set_game_mode(gd::Ref<gd::PackedScene> prototype);
//! get the current active game mode.
GameMode *get_game_mode() const;
//! Get the current active game state.
GameState *get_game_state() const;
/*! Returns all currently active levels.
*
* Levels are identified by their packed scene path.
*/
gd::HashMap<gd::StringName, Level3D *> &get_levels();
//! Get the player instance associated with id.
IPlayer *get_player(uint32_t id);
//! Get all players in a list.
gd::Vector<IPlayer*> get_players();
void set_first_boot_level(gd::Ref<gd::PackedScene> level);
gd::Ref<gd::PackedScene> get_first_boot_level() const;
void set_game_state_prototype(gd::Ref<GameState> game_state);
gd::Ref<GameState> get_game_state_prototype() const;
protected:
//! Attempt to make 'this' the current singleton instance.
void grab_singleton();
/*! Attempt to stop being the active singleton instance.
*
* Only works if the current singleton is 'this'.
*/
void release_singleton();
//! Find a Player Input device not yet associated with a player.
uint32_t find_empty_player_slot() const;
//! Spawn a player to be associated with id.
IPlayer *spawn_player(uint32_t id);
//! Callback for a level exiting the tree.
void level_unloaded(gd::StringName scene_path);
//! Check if a scene is a valid level.
static bool is_valid_level(gd::Ref<gd::PackedScene> &level);
private:
static GameRoot3D *singleton_instance;
uint32_t next_player_id{1}; //!< Next available player ID. Default is 1 because 0 is the "invalid" player id.
gd::HashMap<uint32_t, gd::Pair<PlayerInput*, IPlayer*>> players{}; //!< all players by id by input device.
gd::RandomNumberGenerator rng{}; //!< Global random number generator.
gd::HashMap<gd::StringName, Level3D*> levels{}; //!< all currently active levels identified by their resource paths.
gd::Vector<SpawnPoint3D*> spawn_points{}; //!< all currently available spawn points.
GameMode *game_mode{}; //!< current active gamemode.
/*! Active game state.
*
* Will be assigned loaded save data, or game_state_prototype if no save data is found.
*/
gd::Ref<GameState> game_state{};
gd::Ref<gd::PackedScene> first_boot_level{}; //!< The level to boot into on startup.
gd::Ref<GameState> game_state_prototype{}; //!< The default game state data used for game_state if no save data is available.
};
}
#endif // !UTILS_GAME_ROOT_HPP