GameObject.h

Go to the documentation of this file.

//   ____   __                  __  __
// /\__  _\/\ \                /\ \/\ \
// \/_/\ \/\ \ \___      __    \ \ \_\ \    ___   __  __    ____     __
//    \ \ \ \ \  _ `\  /'__`\   \ \  _  \  / __`\/\ \/\ \  /',__\  /'__`\
//     \ \ \ \ \ \ \ \/\  __/    \ \ \ \ \/\ \L\ \ \ \_\ \/\__, `\/\  __/
//      \ \_\ \ \_\ \_\ \____\    \ \_\ \_\ \____/\ \____/\/\____/\ \____\
//       \/_/  \/_/\/_/\/____/     \/_/\/_/\/___/  \/___/  \/___/  \/____/
 
#pragma once
 
 
#include <string>
#include <memory>
 
#include "System/Json.h"
 
 
namespace sol
{
class state;
}
 
class Engine;
class Node;
template <class>
class ChildrenHandeler;
 
namespace sys
{
class SceneManager;
}
 
class Entity;
namespace gobj
{
struct PathNode;
 
enum class Type
{
    null_obj_type   = 0,   // reserved for uninitialized or invalid objects
    no_parent_type  = 100, // reserved for Engine
    Engine          = 200,
    Root            = 300, // object held by root node. see Root.h
    Node            = 400,
    ChildrenHandler = 500,
    System          = 600,
    Entity          = 700,
    Component       = 800,
    Action          = 900,
    Script          = 1000,
};
 
}
 
namespace gobj
{
using UUID = unsigned int; // replace with boost later
}
 
using RenderLayer = unsigned int; // replace with a real enum
using Stream      = sys::Json;    // replace with whatever stream we are using
 
 
static unsigned int ObjectCount = 0;

class GameObject
{
public:
    class Key;

    friend gobj::PathNode;
    friend Entity;
    friend sys::SceneManager;
    friend Node;
 
    template <typename T>
    friend class ChildrenHandeler;
 
    friend Engine;
 
#pragma region big_6_functions

    GameObject(std::string typeName, gobj::Type parentType, gobj::Type type);
    virtual ~GameObject(); //possibly declare noexcept

    GameObject(const GameObject& other);
    auto operator=(const GameObject& other) -> GameObject&;
    GameObject(GameObject&& other) noexcept;
    auto operator=(GameObject&& other) noexcept -> GameObject&;
 
#pragma endregion
 
#pragma region abstract functions

    virtual auto clone() const -> std::unique_ptr<GameObject> = 0;
 

    virtual auto update(float dt) -> void;
 
private:
    virtual auto onUpdate(float dt) -> void = 0;
 
public:
    virtual auto endWindow() -> void = 0; // for debug ImGUI
 

    virtual auto render() -> void;
 
private:
    virtual auto onRender() -> void = 0;
 
public:
    virtual auto load(const Stream& stream) -> void = 0;

    virtual auto save(Stream& stream) const -> void = 0;

    virtual auto destroy() -> void;

    virtual auto showMenu() -> void
    {
    }

    virtual auto onEnterEngine() -> void
    {
    }

    virtual auto onSceneStart(const std::string& sceneName) -> void
    {
    }

    virtual auto onSceneExit(const std::string& sceneName) -> void
    {
    }

    virtual auto for_each(std::function<void(GameObject&)> func) -> void;

    virtual auto for_each(std::function<void(const GameObject&)> func) const -> void;
 
#pragma endregion
 
 
#pragma region parent_functions
    virtual auto getParent() const -> GameObject*;

    [[nodiscard("Parenting may fail")]] virtual auto parentTo(GameObject* newParent) -> bool;

    [[nodiscard]] auto getInternalParent() const -> GameObject*;
 
 
#pragma endregion
 
#pragma region child_functions

    [[nodiscard("adding child may fail")]]
    virtual auto addChild(std::unique_ptr<GameObject> newChild) -> bool;
    
public:
    auto addChildLua(std::unique_ptr<GameObject>& newChild) -> bool;
public:
 
#pragma endregion

    [[nodiscard]] virtual auto getKey() const -> Key;
 
    [[nodiscard]] auto destroyed() const -> bool;
    [[nodiscard]] auto getUUID() const -> gobj::UUID;
    auto coolerGetUUID() const -> unsigned int;
    [[nodiscard]] auto isUUID(gobj::UUID compareUUID) const -> bool;
    [[nodiscard]] auto getName() const -> const std::string&;
    [[nodiscard]] auto getNickname() const -> const std::string&;
    [[nodiscard]] auto getFormattedName() const -> const std::string&;

    [[nodiscard]] auto nameEquals(const std::string& compareString) const -> bool;

    [[nodiscard]] auto isType(gobj::Type otherType) const -> bool;
    [[nodiscard]] auto getObjectType() const -> gobj::Type;

    auto setNickname(const std::string& newNickname) -> void;

    [[nodiscard]] auto updates() const -> bool;

    [[nodiscard]] auto renders() const -> bool;

    [[nodiscard]] auto receivesMessages() const -> bool;

    [[nodiscard]] auto isActive() const -> bool;

    virtual auto setShouldUpdate(bool _shouldUpdate) -> void;

    virtual auto setShouldRender(bool _shouldRender) -> void;

    virtual auto setShouldReceiveMessages(bool _shouldReceiveMessages) -> void;

    auto setActive(bool shouldBeActive) -> void;
    
    auto getGameObjectJson() const -> json;
    
    auto setGameObjectJson(const json& stream) -> void;

    class Key
    {
    public:
        Key(gobj::UUID uuid, gobj::Type type, unsigned short subtype);
        auto getUUID() const -> gobj::UUID;
        auto getType() const -> gobj::Type;
        auto getSubtype() const -> unsigned short;
        friend auto operator<(const Key& lhs, const Key& rhs) -> bool;
 
    private:
        gobj::UUID uuid;

        gobj::Type type;

        unsigned short subtype;
    };
 
 
protected:
    auto setInternalParent(GameObject* parent) -> bool;
 
 

    virtual auto getChildren() const -> std::shared_ptr<std::vector<GameObject*>>;

    auto checkAddToSceneHook() -> void;
 
private:
    const gobj::UUID uuid;
    bool isDestroyed;
    gobj::Type parentType;
    gobj::Type type;
    GameObject* internalParent;
    RenderLayer renderLayer;

    bool shouldUpdate = true;

    bool shouldRender = true;

    bool shouldReceiveMessages = true;

    bool inEngine = false;

    std::string typeName;
    std::string nickname;

    mutable std::string formattedName;
 

    auto calculateFormattedName() const -> void;
};
 
namespace gobj
{
auto operator<(const GameObject& lhs, const GameObject& rhs) -> bool;
}