njin_script.h

#pragma once
#include "_math.h"
#include "_types.h"
#include "njin_json.h"
#include <entt/entity/fwd.hpp>
#include <functional>
#include <initializer_list>
#include <span>
#include <string>
#include <type_traits>
#include <utility>
#include <variant>
 
namespace njin {
struct context;


using script_value = std::variant<std::monostate, bool, f64, std::string, vec2, vec3, entt::entity>;

struct script_desc {
  bool allow_io = false;
};

void script_init(context &ctx, const script_desc &desc = {});

bool script_run_file(context &ctx, const char *path);

bool script_run_string(context &ctx, const char *code, const char *name = "string");

struct script_result {
  bool ok = false;      
  script_value value{}; 
};

script_result script_call(context &ctx, const char *function, std::initializer_list<script_value> args = {});

script_result script_call(context &ctx, const char *function, std::span<const script_value> args);

using script_fn = std::function<script_value(context &, std::span<const script_value>)>;

void script_register(context &ctx, const char *name, script_fn fn);
 
namespace script_detail {
template <class> inline constexpr bool always_false = false;

template <class T> std::remove_cvref_t<T> to(const script_value &v) {
  using U = std::remove_cvref_t<T>;
  if constexpr (std::is_same_v<U, bool>) {
    if (const bool *b = std::get_if<bool>(&v))
      return *b;
    if (const f64 *d = std::get_if<f64>(&v))
      return *d != 0.0;
    return false;
  } else if constexpr (std::is_same_v<U, entt::entity>) {
    if (const entt::entity *e = std::get_if<entt::entity>(&v))
      return *e;
    if (const f64 *d = std::get_if<f64>(&v))
      return entt::entity((u32)*d);
    return entt::entity(~u32{0});
  } else if constexpr (std::is_arithmetic_v<U>) {
    if (const f64 *d = std::get_if<f64>(&v))
      return (U)*d;
    if (const bool *b = std::get_if<bool>(&v))
      return (U)(*b ? 1 : 0);
    return U{};
  } else if constexpr (std::is_same_v<U, std::string> || std::is_same_v<U, vec2> || std::is_same_v<U, vec3>) {
    if (const U *p = std::get_if<U>(&v))
      return *p;
    return U{};
  } else if constexpr (std::is_same_v<U, script_value>) {
    return v;
  } else {
    static_assert(always_false<U>, "script_register: kiểu tham số không hỗ trợ");
  }
}

template <class T> script_value from(T &&value) {
  using U = std::remove_cvref_t<T>;
  if constexpr (std::is_same_v<U, script_value>)
    return std::forward<T>(value);
  else if constexpr (std::is_same_v<U, bool> || std::is_same_v<U, vec2> || std::is_same_v<U, vec3> ||
                     std::is_same_v<U, entt::entity> || std::is_same_v<U, std::string>)
    return script_value{std::forward<T>(value)};
  else if constexpr (std::is_arithmetic_v<U>)
    return script_value{(f64)value};
  else if constexpr (std::is_convertible_v<U, const char *>)
    return script_value{std::string(value)};
  else
    static_assert(always_false<U>, "script_register: kiểu trả về không hỗ trợ");
}
 
inline const script_value &arg(std::span<const script_value> args, usize i) {
  static const script_value none{};
  return i < args.size() ? args[i] : none;
}
 
template <class R, class... A, usize... I>
script_value call(const std::function<R(context &, A...)> &f, context &ctx, std::span<const script_value> args,
                  std::index_sequence<I...>) {
  if constexpr (std::is_void_v<R>) {
    f(ctx, to<A>(arg(args, I))...);
    return {};
  } else {
    return from(f(ctx, to<A>(arg(args, I))...));
  }
}
 
template <class R, class... A, usize... I>
script_value call(const std::function<R(A...)> &f, std::span<const script_value> args, std::index_sequence<I...>) {
  if constexpr (std::is_void_v<R>) {
    f(to<A>(arg(args, I))...);
    return {};
  } else {
    return from(f(to<A>(arg(args, I))...));
  }
}
 
template <class R, class... A> script_fn wrap(std::function<R(context &, A...)> f) {
  return [f = std::move(f)](context &ctx, std::span<const script_value> args) {
    return call(f, ctx, args, std::index_sequence_for<A...>{});
  };
}
 
template <class R, class... A> script_fn wrap(std::function<R(A...)> f) {
  return [f = std::move(f)](context &, std::span<const script_value> args) {
    return call(f, args, std::index_sequence_for<A...>{});
  };
}
} // namespace script_detail

template <class F>
  requires(!std::is_convertible_v<F, script_fn>)
void script_register(context &ctx, const char *name, F &&fn) {
  script_register(ctx, name, script_detail::wrap(std::function{std::forward<F>(fn)}));
}

void script_set_global(context &ctx, const char *name, const script_value &value);

script_value script_get_global(context &ctx, const char *name);

bool script_attach(context &ctx, entt::entity entity, const char *path);

void script_detach(context &ctx, entt::entity entity);

bool script_attached(const context &ctx, entt::entity entity);

script_value script_field(context &ctx, entt::entity entity, const char *key);

void script_set_field(context &ctx, entt::entity entity, const char *key, const script_value &value);

i32 script_count(const context &ctx);

void script_set_save_id(context &ctx, entt::entity entity, const char *id);

std::string script_save_id(context &ctx, entt::entity entity);

json_value script_save_state(context &ctx);

i32 script_load_state(context &ctx, const json_value &state);
} // namespace njin