Script.h

Go to the documentation of this file.

//   ____   __                  __  __
// /\__  _\/\ \                /\ \/\ \
// \/_/\ \/\ \ \___      __    \ \ \_\ \    ___   __  __    ____     __
//    \ \ \ \ \  _ `\  /'__`\   \ \  _  \  / __`\/\ \/\ \  /',__\  /'__`\
//     \ \ \ \ \ \ \ \/\  __/    \ \ \ \ \/\ \L\ \ \ \_\ \/\__, `\/\  __/
//      \ \_\ \ \_\ \_\ \____\    \ \_\ \_\ \____/\ \____/\/\____/\ \____\
//       \/_/  \/_/\/_/\/____/     \/_/\/_/\/___/  \/___/  \/___/  \/____/
 
#pragma once
#include <filesystem>
 
#define SOL_NO_CHECK_NUMBER_PRECISION 1
#define SOL_ALL_SAFETIES_ON 1
#include <sol/sol.hpp>
 
#include "Framework/GameObject.h"
 
 
class ScriptHolder;
struct Message;
 
struct Script final : GameObject
{
    friend ScriptHolder;
    
    explicit Script(const std::filesystem::path& path);

    Script();
 
 
    Script(const Script& other);
    Script(Script&& other) noexcept;
    auto operator=(const Script& other) -> Script&;
    auto operator=(Script&& other) noexcept -> Script&;
 
    explicit operator bool() const
    {
        return !isNull;
    }
 
    auto showMenu() -> void override;
 
    auto clone() const -> std::unique_ptr<GameObject> override;
    auto endWindow() -> void override;
 
private:
    auto onUpdate(float dt) -> void override;
    auto onRender() -> void override;
 
public:
    auto onEnterEngine() -> void override;
    auto onSceneStart(const std::string& sceneName) -> void override;
    auto onSceneExit(const std::string& sceneName) -> void override;
 
    auto load(const Stream& stream) -> void override;
    auto save(Stream& stream) const -> void override;

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

    template <typename... Args>
    auto callIfFunction(const std::string& functionName,
                        Args&&... args) -> sol::optional<sol::protected_function_result>
    {
        if (sol::optional<sol::protected_function> func = luaObject[functionName])
        {
            // result is a sol::protected_function_result
            auto result = func.value()(luaObject, std::forward<Args>(args)...);
            if (result.valid())
            {
                hlg::Trace("Call to function {} succeeded", functionName);
            }
            else
            {
                sol::error err   = result;
                std::string what = err.what();
                hlg::Error("Function {} has Error: {}", functionName, what);
            }
            return result;
        }
        return {};
    }

    template <typename... Args>
    auto callFunction(const std::string& functionName, Args&&... args) -> sol::protected_function_result
    {
        if (sol::optional<sol::protected_function_result> result = Script::callIfFunction(functionName, std::forward<Args>(args)...))
        {
            return std::move(result.value());
        }
        return {};
            
    }

    __forceinline auto getVariable(
            const std::string& name) -> sol::table_proxy<
        sol::basic_table_core<false, sol::basic_reference<>>&, std::tuple<
            const char(&)[5], const std::string&>>
    {
        using namespace sol;
        // no function, get from data
        return luaObject["data"][name];
    }
 
    
    __forceinline auto operator[](
            const std::string& name) -> sol::table_proxy<
        sol::basic_table_core<false, sol::basic_reference<>>&, std::tuple<
            const char(&)[5], const std::string&>>
    {
        return getVariable(name);
    };
 

    auto loadDataFromJson(const nlohmann::json& j) -> void;

    auto getDataAsJson() const -> nlohmann::json;
 

    auto reloadScript() -> void;

    std::filesystem::path scriptPath;
    
    std::string scriptName;
    
    sol::table luaObject;
    
    // generally const members like this aren't amazing, but we're going to use it for NULL scripts. 
    const bool isNull = false;
 
private:
    auto updateOtherComponentBindings() -> void;

    auto receiveComponentAdded(const Message*) -> Message;

    auto setParentInLua(GameObject* newParent) -> void;

    static auto tableToJson(const sol::table& table) -> nlohmann::json;

    static auto jsonToTable(const nlohmann::json& j, sol::table table) -> void;

    static auto tableShowMenu(sol::table table) -> void;
    void deepCopyTable(sol::table table, const sol::table& otherTable);
};
 
 
namespace nlohmann
{
template <>
struct adl_serializer<Script>
{
    static auto from_json(const json& j) -> Script
    {
        auto script = Script(j.at("scriptPath").get<std::string>());
        script.setGameObjectJson(j.at("GameObject"));
        script.loadDataFromJson(j);
        return script;
    }
 
    static auto to_json(json& j, const Script& s) -> void
    {
        j = {
                {"GameObject", s.getGameObjectJson()},
                {"scriptPath", s.scriptPath.string()},
                {"data", s.getDataAsJson()}
        };
    }
};
}