parent
96efc990c1
commit
9e91c71125
@ -1,45 +0,0 @@ |
|||||||
#include "components.hpp" |
|
||||||
|
|
||||||
namespace components { |
|
||||||
void configure(DinkyECS::World &world, DinkyECS::Entity entity, json& entity_data) { |
|
||||||
for(auto &comp : entity_data["components"]) { |
|
||||||
json& config = comp["config"]; |
|
||||||
const string comp_type = comp["type"]; |
|
||||||
|
|
||||||
if(comp_type == "Weapon") { |
|
||||||
world.set<Weapon>(entity, {config["damage"]}); |
|
||||||
} else if(comp_type == "LightSource") { |
|
||||||
world.set<LightSource>(entity, {config["strength"], config["radius"]}); |
|
||||||
} else if(comp_type == "Loot") { |
|
||||||
world.set<Loot>(entity, {config["amount"]}); |
|
||||||
} else if(comp_type == "Tile") { |
|
||||||
world.set<Tile>(entity, { |
|
||||||
config["chr"], |
|
||||||
entity_data["foreground"][0], |
|
||||||
entity_data["foreground"][1], |
|
||||||
entity_data["foreground"][2], |
|
||||||
entity_data["background"][0], |
|
||||||
entity_data["background"][1], |
|
||||||
entity_data["background"][2]}); |
|
||||||
|
|
||||||
} else if(comp_type == "EnemyConfig") { |
|
||||||
world.set<EnemyConfig>(entity, {config["hearing_distance"]}); |
|
||||||
} else if(comp_type == "Combat") { |
|
||||||
world.set<Combat>(entity, {config["hp"], config["damage"]}); |
|
||||||
} else if(comp_type == "Curative") { |
|
||||||
world.set<Curative>(entity, {config["hp"]}); |
|
||||||
} else if(comp_type == "Motion") { |
|
||||||
world.set<Motion>(entity, {config["dx"], config["dy"], config["random"]}); |
|
||||||
} else if(comp_type == "Device") { |
|
||||||
Device device{.config=config, .events={}}; |
|
||||||
device.configure_events(comp["events"]); |
|
||||||
world.set<Device>(entity, device); |
|
||||||
} else { |
|
||||||
dbc::sentinel(fmt::format("ITEM COMPONENT TYPE MISSING: {}", |
|
||||||
std::string(comp_type))); |
|
||||||
} |
|
||||||
|
|
||||||
// json config variable dies
|
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,35 +0,0 @@ |
|||||||
#include <catch2/catch_test_macros.hpp> |
|
||||||
#include <fmt/core.h> |
|
||||||
#include <nlohmann/json.hpp> |
|
||||||
#include <fstream> |
|
||||||
#include "map.hpp" |
|
||||||
#include "worldbuilder.hpp" |
|
||||||
|
|
||||||
using namespace fmt; |
|
||||||
using namespace nlohmann; |
|
||||||
using std::string; |
|
||||||
|
|
||||||
TEST_CASE("bsp algo test", "[builder]") { |
|
||||||
Map map(31, 20); |
|
||||||
WorldBuilder builder(map); |
|
||||||
builder.generate_map(); |
|
||||||
} |
|
||||||
|
|
||||||
TEST_CASE("pathing", "[builder]") { |
|
||||||
Map map(23, 14); |
|
||||||
WorldBuilder builder(map); |
|
||||||
builder.generate_map(); |
|
||||||
|
|
||||||
matrix::dump("WALLS", map.$walls, 0,0); |
|
||||||
println("wall at 0,0=={}", map.$walls[0][0]); |
|
||||||
|
|
||||||
for(matrix::each_cell it{map.$walls}; it.next();) { |
|
||||||
if(map.$walls[it.y][it.x] == WALL_VALUE) { |
|
||||||
REQUIRE(map.iswall(it.x, it.y) == true); |
|
||||||
REQUIRE(map.can_move({it.x, it.y}) == false); |
|
||||||
} else { |
|
||||||
REQUIRE(map.iswall(it.x, it.y) == false); |
|
||||||
REQUIRE(map.can_move({it.x, it.y}) == true); |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,220 +0,0 @@ |
|||||||
// Licensed under the Boost License <https://opensource.org/licenses/BSL-1.0>.
|
|
||||||
// SPDX-License-Identifier: BSL-1.0
|
|
||||||
#pragma once |
|
||||||
#include <array> |
|
||||||
#include <ostream> |
|
||||||
#include <cstring> |
|
||||||
#include <string> |
|
||||||
#include <string_view> |
|
||||||
#include <type_traits> |
|
||||||
#include <tuple> |
|
||||||
#include <locale> |
|
||||||
#include <codecvt> |
|
||||||
|
|
||||||
|
|
||||||
namespace tser{ |
|
||||||
//implementation details for C++20 is_detected
|
|
||||||
namespace detail { |
|
||||||
struct ns { |
|
||||||
~ns() = delete; |
|
||||||
ns(ns const&) = delete; |
|
||||||
}; |
|
||||||
|
|
||||||
template <class Default, class AlwaysVoid, template<class...> class Op, class... Args> |
|
||||||
struct detector { |
|
||||||
using value_t = std::false_type; |
|
||||||
using type = Default; |
|
||||||
}; |
|
||||||
|
|
||||||
template <class Default, template<class...> class Op, class... Args> |
|
||||||
struct detector<Default, std::void_t<Op<Args...>>, Op, Args...> { |
|
||||||
using value_t = std::true_type; |
|
||||||
using type = Op<Args...>; |
|
||||||
}; |
|
||||||
|
|
||||||
template<class T> |
|
||||||
struct is_array : std::is_array<T> {}; |
|
||||||
|
|
||||||
template<template<typename, size_t> class TArray, typename T, size_t N> |
|
||||||
struct is_array<TArray<T, N>> : std::true_type {}; |
|
||||||
|
|
||||||
constexpr size_t n_args(char const* c, size_t nargs = 1) { |
|
||||||
for (; *c; ++c) if (*c == ',') ++nargs; |
|
||||||
return nargs; |
|
||||||
} |
|
||||||
|
|
||||||
constexpr size_t str_size(char const* c, size_t strSize = 1) { |
|
||||||
for (; *c; ++c) ++strSize; |
|
||||||
return strSize; |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// we need a bunch of template metaprogramming for being able to differentiate between different types
|
|
||||||
template <template<class...> class Op, class... Args> |
|
||||||
constexpr bool is_detected_v = detail::detector<detail::ns, void, Op, Args...>::value_t::value; |
|
||||||
|
|
||||||
class BinaryArchive; |
|
||||||
template<class T> using has_begin_t = decltype(*std::begin(std::declval<T>())); |
|
||||||
|
|
||||||
template<class T> using has_members_t = decltype(std::declval<T>().members()); |
|
||||||
|
|
||||||
template<class T> using has_smaller_t = decltype(std::declval<T>() < std::declval<T>()); |
|
||||||
|
|
||||||
template<class T> using has_equal_t = decltype(std::declval<T>() == std::declval<T>()); |
|
||||||
|
|
||||||
template<class T> using has_nequal_t = decltype(std::declval<T>() != std::declval<T>()); |
|
||||||
|
|
||||||
template<class T> using has_outstream_op_t = decltype(std::declval<std::ostream>() << std::declval<T>()); |
|
||||||
|
|
||||||
template<class T> using has_tuple_t = std::tuple_element_t<0, T>; |
|
||||||
|
|
||||||
template<class T> using has_optional_t = decltype(std::declval<T>().has_value()); |
|
||||||
|
|
||||||
template<class T> using has_element_t = typename T::element_type; |
|
||||||
|
|
||||||
template<class T> using has_mapped_t = typename T::mapped_type; |
|
||||||
|
|
||||||
template<class T> using has_custom_save_t = decltype(std::declval<T>().save(std::declval<BinaryArchive&>())); |
|
||||||
|
|
||||||
template<class T> using has_free_save_t = decltype(std::declval<const T&>() << std::declval<BinaryArchive&>()); |
|
||||||
|
|
||||||
template<class T> constexpr bool is_container_v = is_detected_v<has_begin_t, T>; |
|
||||||
|
|
||||||
template<class T> constexpr bool is_tuple_v = is_detected_v<has_tuple_t, T>; |
|
||||||
|
|
||||||
template<class T> constexpr bool is_tser_t_v = is_detected_v<has_members_t, T>; |
|
||||||
|
|
||||||
template<class T> constexpr bool is_pointer_like_v = std::is_pointer_v<T> || is_detected_v<has_element_t, T> || is_detected_v<has_optional_t, T>; |
|
||||||
|
|
||||||
class BinaryArchive { |
|
||||||
std::string m_bytes = std::string(1024, '\0'); |
|
||||||
size_t m_bufferSize = 0, m_readOffset = 0; |
|
||||||
|
|
||||||
public: |
|
||||||
explicit BinaryArchive(const size_t initialSize = 1024) : m_bytes(initialSize, '\0') {} |
|
||||||
|
|
||||||
template<typename T> |
|
||||||
explicit BinaryArchive(const T& t) { save(t); } |
|
||||||
|
|
||||||
template<typename T> |
|
||||||
void save(const T& t) { |
|
||||||
if constexpr (is_detected_v<has_free_save_t, T>) { |
|
||||||
operator<<(t,*this); |
|
||||||
} else if constexpr (is_detected_v<has_custom_save_t, T>) { |
|
||||||
t.save(*this); |
|
||||||
} else if constexpr(is_tser_t_v<T>) { |
|
||||||
std::apply([&](auto& ... mVal) { (save(mVal), ...); }, t.members()); |
|
||||||
} else if constexpr(is_tuple_v<T>) { |
|
||||||
std::apply([&](auto& ... tVal) { (save(tVal), ...); }, t); |
|
||||||
} else if constexpr (is_pointer_like_v<T>) { |
|
||||||
save(static_cast<bool>(t)); |
|
||||||
if (t) |
|
||||||
save(*t); |
|
||||||
} else if constexpr (is_container_v<T>) { |
|
||||||
if constexpr (!detail::is_array<T>::value) { |
|
||||||
save(t.size()); |
|
||||||
} |
|
||||||
|
|
||||||
for (auto& val : t) save(val); |
|
||||||
} else { |
|
||||||
if (m_bufferSize + sizeof(T) + sizeof(T) / 4 > m_bytes.size()) { |
|
||||||
m_bytes.resize((m_bufferSize + sizeof(T)) * 2); |
|
||||||
} |
|
||||||
|
|
||||||
std::memcpy(m_bytes.data() + m_bufferSize, std::addressof(t), sizeof(T)); |
|
||||||
m_bufferSize += sizeof(T); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
template<typename T> |
|
||||||
void load(T& t) { |
|
||||||
using V = std::decay_t<T>; |
|
||||||
if constexpr (is_detected_v<has_free_save_t, V>) { |
|
||||||
operator>>(t, *this); |
|
||||||
} else if constexpr (is_detected_v<has_custom_save_t, T>) { |
|
||||||
t.load(*this); |
|
||||||
} else if constexpr (is_tser_t_v<T>) { |
|
||||||
std::apply([&](auto& ... mVal) { (load(mVal), ...); }, t.members()); |
|
||||||
} else if constexpr (is_tuple_v<V>) { |
|
||||||
std::apply([&](auto& ... tVal) { (load(tVal), ...); }, t); |
|
||||||
} else if constexpr (is_pointer_like_v<T>) { |
|
||||||
if constexpr (std::is_pointer_v<T>) { |
|
||||||
t = load<bool>() ? (t = new std::remove_pointer_t<T>(), load(*t), t) : nullptr; |
|
||||||
} else if constexpr (is_detected_v<has_optional_t, T>) { |
|
||||||
t = load<bool>() ? T(load<typename V::value_type>()) : T(); |
|
||||||
} else { //smart pointer
|
|
||||||
t = T(load<has_element_t<V>*>()); |
|
||||||
} |
|
||||||
} else if constexpr (is_container_v<T>) { |
|
||||||
if constexpr (!detail::is_array<T>::value) { |
|
||||||
const auto size = load<decltype(t.size())>(); |
|
||||||
using VT = typename V::value_type; |
|
||||||
for (size_t i = 0; i < size; ++i) { |
|
||||||
if constexpr (!is_detected_v<has_mapped_t, V>) { |
|
||||||
t.insert(t.end(), load<VT>()); |
|
||||||
} else { |
|
||||||
//we have to special case map, because of the const key
|
|
||||||
t.emplace(VT{ load<typename V::key_type>(), load<typename V::mapped_type>() }); |
|
||||||
} |
|
||||||
} |
|
||||||
} else { |
|
||||||
for (auto& val : t) load(val); |
|
||||||
} |
|
||||||
} else { |
|
||||||
std::memcpy(&t, m_bytes.data() + m_readOffset, sizeof(T)); |
|
||||||
m_readOffset += sizeof(T); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
template<typename T> |
|
||||||
T load() { |
|
||||||
std::remove_const_t<T> t{}; load(t); return t; |
|
||||||
} |
|
||||||
|
|
||||||
template<typename T> |
|
||||||
friend BinaryArchive& operator<<(BinaryArchive& ba, const T& t) { |
|
||||||
ba.save(t); return ba; |
|
||||||
} |
|
||||||
|
|
||||||
template<typename T> |
|
||||||
friend BinaryArchive& operator>>(BinaryArchive& ba, T& t) { |
|
||||||
ba.load(t); return ba; |
|
||||||
} |
|
||||||
|
|
||||||
void reset() { |
|
||||||
m_bufferSize = 0; |
|
||||||
m_readOffset = 0; |
|
||||||
} |
|
||||||
|
|
||||||
void initialize(std::string_view str) { |
|
||||||
m_bytes = str; |
|
||||||
m_bufferSize = str.size(); |
|
||||||
m_readOffset = 0; |
|
||||||
} |
|
||||||
|
|
||||||
std::string_view get_buffer() const { |
|
||||||
return std::string_view(m_bytes.data(), m_bufferSize); |
|
||||||
} |
|
||||||
|
|
||||||
}; |
|
||||||
|
|
||||||
template<class Base, typename Derived> |
|
||||||
std::conditional_t<std::is_const_v<Derived>, const Base, Base>& base(Derived* thisPtr) { return *thisPtr; } |
|
||||||
|
|
||||||
template<typename T> |
|
||||||
auto load(std::string_view encoded) { BinaryArchive ba(encoded); return ba.load<T>(); } |
|
||||||
} |
|
||||||
|
|
||||||
//this macro defines printing, serialisation and comparision operators (==,!=,<) for custom types
|
|
||||||
#define DEFINE_SERIALIZABLE(Type, ...) \ |
|
||||||
inline decltype(auto) members() const { return std::tie(__VA_ARGS__); } \
|
|
||||||
inline decltype(auto) members() { return std::tie(__VA_ARGS__); } \
|
|
||||||
static constexpr std::array<char, tser::detail::str_size(#__VA_ARGS__)> _memberNameData = [](){ \
|
|
||||||
std::array<char, tser::detail::str_size(#__VA_ARGS__)> chars{'\0'}; size_t _idx = 0; constexpr auto* ini(#__VA_ARGS__); \
|
|
||||||
for (char const* _c = ini; *_c; ++_c, ++_idx) { if(*_c != ',' && *_c != ' ') chars[_idx] = *_c; } return chars;}(); \
|
|
||||||
static constexpr const char* _typeName = #Type; \
|
|
||||||
static constexpr std::array<const char*, tser::detail::n_args(#__VA_ARGS__)> _memberNames = \
|
|
||||||
[](){ std::array<const char*, tser::detail::n_args(#__VA_ARGS__)> out{ }; \
|
|
||||||
for(size_t _i = 0, nArgs = 0; nArgs < tser::detail::n_args(#__VA_ARGS__) ; ++_i) { \
|
|
||||||
while(Type::_memberNameData[_i] == '\0') {_i++;} out[nArgs++] = &Type::_memberNameData[_i]; \
|
|
||||||
while(Type::_memberNameData[++_i] != '\0'); } return out;}(); |
|
||||||
Loading…
Reference in new issue