game_root.hpp

#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;
 
class GameRoot3D : public gd::Node {
    GDCLASS(GameRoot3D, gd::Node);
    static void _bind_methods();
public:
    static GameRoot3D *get_singleton();
    static bool has_singleton();
 
    virtual void _enter_tree() override;
    virtual void _ready() override;
    virtual void _exit_tree() override;
 
    void player_input_connected();
    void remove_player(uint32_t player_id);
    // calls remove_player for every used player input slot
    void remove_all_players();
    bool initialize_player(IPlayer *player, uint32_t id);
 
    void reset_game_mode();
 
    Level3D *load_level(gd::Ref<gd::PackedScene> level);
    Level3D *load_level_at(gd::Ref<gd::PackedScene> level, gd::Transform3D at);
    void unload_all_levels();
    void replace_levels(gd::Ref<gd::PackedScene> level);
    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);
 
    void set_game_mode(gd::Ref<gd::PackedScene> prototype);
    GameMode *get_game_mode() const;
    GameState *get_game_state() const;
    gd::HashMap<gd::StringName, Level3D *> &get_levels();
    IPlayer *get_player(uint32_t id);
    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:
    void grab_singleton();
    void release_singleton();
    uint32_t find_empty_player_slot() const;
    IPlayer *spawn_player(uint32_t id);
    void level_unloaded(gd::StringName scene_path);
    static bool is_valid_level(gd::Ref<gd::PackedScene> &level);
private:
    static GameRoot3D *singleton_instance;
 
    uint32_t next_player_id{1}; 
    gd::HashMap<uint32_t, gd::Pair<PlayerInput*, IPlayer*>> players{}; 
 
    gd::RandomNumberGenerator rng{}; 
    gd::HashMap<gd::StringName, Level3D*> levels{}; 
    gd::Vector<SpawnPoint3D*> spawn_points{}; 
    GameMode *game_mode{}; 
    gd::Ref<GameState> game_state{};
 
    gd::Ref<gd::PackedScene> first_boot_level{}; 
    gd::Ref<GameState> game_state_prototype{}; 
};
}
 
#endif // !UTILS_GAME_ROOT_HPP