From 377c8e5029aad70310d1b9fd6f46db2e44b4a6eb Mon Sep 17 00:00:00 2001 From: MihailRis Date: Wed, 17 Jan 2024 16:32:53 +0300 Subject: [PATCH] the big refactor + extracted data classes from coders/json to data/dynamic --- src/coders/binary_json.cpp | 159 +++++++++ src/coders/binary_json.h | 28 ++ src/coders/json.cpp | 564 ++----------------------------- src/coders/json.h | 126 ++----- src/content/Content.cpp | 1 - src/content/Content.h | 6 +- src/content/ContentLUT.cpp | 31 +- src/content/ContentLUT.h | 4 +- src/content/ContentLoader.cpp | 80 +++-- src/content/ContentLoader.h | 14 +- src/content/ContentPack.cpp | 13 +- src/data/dynamic.cpp | 331 ++++++++++++++++++ src/data/dynamic.h | 113 +++++++ src/files/WorldFiles.cpp | 34 +- src/files/WorldFiles.h | 47 ++- src/files/files.cpp | 11 +- src/files/files.h | 13 +- src/files/settings_io.cpp | 19 +- src/frontend/ContentGfxCache.cpp | 8 +- src/frontend/InventoryView.cpp | 2 +- src/frontend/WorldRenderer.cpp | 6 +- src/frontend/hud.cpp | 4 +- src/frontend/locale/langs.cpp | 90 +++-- src/graphics/BlocksRenderer.cpp | 6 +- src/lighting/Lighting.cpp | 18 +- src/logic/BlocksController.cpp | 4 +- src/logic/PlayerController.cpp | 12 +- src/logic/scripting/api_lua.cpp | 11 +- src/objects/Player.cpp | 3 - src/objects/Player.h | 2 +- src/typedefs.h | 2 + src/voxels/Chunk.h | 3 +- src/voxels/Chunks.cpp | 5 +- src/voxels/Chunks.h | 2 +- src/voxels/ChunksStorage.cpp | 9 +- src/voxels/ChunksStorage.h | 2 +- 36 files changed, 908 insertions(+), 875 deletions(-) create mode 100644 src/coders/binary_json.cpp create mode 100644 src/coders/binary_json.h create mode 100644 src/data/dynamic.cpp create mode 100644 src/data/dynamic.h diff --git a/src/coders/binary_json.cpp b/src/coders/binary_json.cpp new file mode 100644 index 00000000..c65012d3 --- /dev/null +++ b/src/coders/binary_json.cpp @@ -0,0 +1,159 @@ +#include "binary_json.h" + +#include + +#include "byte_utils.h" + +using namespace json; +using namespace dynamic; + +static void to_binary(ByteBuilder& builder, const Value* value) { + switch (value->type) { + case valtype::map: { + std::vector bytes = to_binary(value->value.map); + builder.put(bytes.data(), bytes.size()); + break; + } + case valtype::list: + builder.put(BJSON_TYPE_LIST); + for (auto& element : value->value.list->values) { + to_binary(builder, element.get()); + } + builder.put(BJSON_END); + break; + case valtype::integer: { + int64_t val = value->value.integer; + if (val >= 0 && val <= 255) { + builder.put(BJSON_TYPE_BYTE); + builder.put(val); + } else if (val >= INT16_MIN && val <= INT16_MAX){ + builder.put(BJSON_TYPE_INT16); + builder.putInt16(val); + } else if (val >= INT32_MIN && val <= INT32_MAX) { + builder.put(BJSON_TYPE_INT32); + builder.putInt32(val); + } else { + builder.put(BJSON_TYPE_INT64); + builder.putInt64(val); + } + break; + } + case valtype::number: + builder.put(BJSON_TYPE_NUMBER); + builder.putFloat64(value->value.decimal); + break; + case valtype::boolean: + builder.put(BJSON_TYPE_FALSE + value->value.boolean); + break; + case valtype::string: + builder.put(BJSON_TYPE_STRING); + builder.put(*value->value.str); + break; + } +} + +static List* array_from_binary(ByteReader& reader); +static Map* object_from_binary(ByteReader& reader); + +std::vector json::to_binary(const Map* obj) { + ByteBuilder builder; + // type byte + builder.put(BJSON_TYPE_DOCUMENT); + // document size + builder.putInt32(0); + + // writing entries + for (auto& entry : obj->values) { + builder.putCStr(entry.first.c_str()); + to_binary(builder, entry.second.get()); + } + // terminating byte + builder.put(BJSON_END); + + // updating document size + builder.setInt32(1, builder.size()); + return builder.build(); +} + +static Value* value_from_binary(ByteReader& reader) { + ubyte typecode = reader.get(); + valtype type; + valvalue val; + switch (typecode) { + case BJSON_TYPE_DOCUMENT: + type = valtype::map; + reader.getInt32(); + val.map = object_from_binary(reader); + break; + case BJSON_TYPE_LIST: + type = valtype::list; + val.list = array_from_binary(reader); + break; + case BJSON_TYPE_BYTE: + type = valtype::integer; + val.integer = reader.get(); + break; + case BJSON_TYPE_INT16: + type = valtype::integer; + val.integer = reader.getInt16(); + break; + case BJSON_TYPE_INT32: + type = valtype::integer; + val.integer = reader.getInt32(); + break; + case BJSON_TYPE_INT64: + type = valtype::integer; + val.integer = reader.getInt64(); + break; + case BJSON_TYPE_NUMBER: + type = valtype::number; + val.decimal = reader.getFloat64(); + break; + case BJSON_TYPE_FALSE: + case BJSON_TYPE_TRUE: + type = valtype::boolean; + val.boolean = typecode - BJSON_TYPE_FALSE; + break; + case BJSON_TYPE_STRING: + type = valtype::string; + val.str = new std::string(reader.getString()); + break; + default: + throw std::runtime_error( + "type "+std::to_string(typecode)+" is not supported"); + } + return new Value(type, val); +} + +static List* array_from_binary(ByteReader& reader) { + auto array = std::make_unique(); + auto& items = array->values; + while (reader.peek() != BJSON_END) { + items.push_back(std::unique_ptr(value_from_binary(reader))); + } + reader.get(); + return array.release(); +} + +static Map* object_from_binary(ByteReader& reader) { + auto obj = std::make_unique(); + auto& map = obj->values; + while (reader.peek() != BJSON_END) { + const char* key = reader.getCString(); + Value* value = value_from_binary(reader); + map.insert(std::make_pair(key, value)); + } + reader.get(); + return obj.release(); +} + +std::unique_ptr json::from_binary(const ubyte* src, size_t size) { + ByteReader reader(src, size); + std::unique_ptr value (value_from_binary(reader)); + if (value->type != valtype::map) { + throw std::runtime_error("root value is not an object"); + } + std::unique_ptr obj (value->value.map); + value->value.map = nullptr; + return obj; +} diff --git a/src/coders/binary_json.h b/src/coders/binary_json.h new file mode 100644 index 00000000..018f6573 --- /dev/null +++ b/src/coders/binary_json.h @@ -0,0 +1,28 @@ +#ifndef CODERS_BINARY_JSON_H_ +#define CODERS_BINARY_JSON_H_ + +#include +#include +#include "../data/dynamic.h" + +namespace json { + const int BJSON_END = 0x0; + const int BJSON_TYPE_DOCUMENT = 0x1; + const int BJSON_TYPE_LIST = 0x2; + const int BJSON_TYPE_BYTE = 0x3; + const int BJSON_TYPE_INT16 = 0x4; + const int BJSON_TYPE_INT32 = 0x5; + const int BJSON_TYPE_INT64 = 0x6; + const int BJSON_TYPE_NUMBER = 0x7; + const int BJSON_TYPE_STRING = 0x8; + const int BJSON_TYPE_BYTES = 0x9; + const int BJSON_TYPE_FALSE = 0xA; + const int BJSON_TYPE_TRUE = 0xB; + const int BJSON_TYPE_NULL = 0xC; + const int BJSON_TYPE_CDOCUMENT = 0x1F; + + extern std::vector to_binary(const dynamic::Map* obj); + extern std::unique_ptr from_binary(const ubyte* src, size_t size); +} + +#endif // CODERS_BINARY_JSON_H_ diff --git a/src/coders/json.cpp b/src/coders/json.cpp index 64e38383..31440b7d 100644 --- a/src/coders/json.cpp +++ b/src/coders/json.cpp @@ -6,24 +6,10 @@ #include #include "commons.h" -#include "byte_utils.h" +#include "../data/dynamic.h" using namespace json; - -const int BJSON_END = 0x0; -const int BJSON_TYPE_DOCUMENT = 0x1; -const int BJSON_TYPE_LIST = 0x2; -const int BJSON_TYPE_BYTE = 0x3; -const int BJSON_TYPE_INT16 = 0x4; -const int BJSON_TYPE_INT32 = 0x5; -const int BJSON_TYPE_INT64 = 0x6; -const int BJSON_TYPE_NUMBER = 0x7; -const int BJSON_TYPE_STRING = 0x8; -const int BJSON_TYPE_BYTES = 0x9; -const int BJSON_TYPE_FALSE = 0xA; -const int BJSON_TYPE_TRUE = 0xB; -const int BJSON_TYPE_NULL = 0xC; -const int BJSON_TYPE_CDOCUMENT = 0x1F; +using namespace dynamic; inline void newline(std::stringstream& ss, bool nice, uint indent, @@ -44,7 +30,7 @@ void stringify(const Value* value, const std::string& indentstr, bool nice); -void stringifyObj(const JObject* obj, +void stringifyObj(const Map* obj, std::stringstream& ss, int indent, const std::string& indentstr, @@ -55,23 +41,23 @@ void stringify(const Value* value, int indent, const std::string& indentstr, bool nice) { - if (value->type == valtype::object) { - stringifyObj(value->value.obj, ss, indent, indentstr, nice); + if (value->type == valtype::map) { + stringifyObj(value->value.map, ss, indent, indentstr, nice); } - else if (value->type == valtype::array) { - std::vector& list = value->value.arr->values; - if (list.empty()) { + else if (value->type == valtype::list) { + auto list = value->value.list; + if (list->size() == 0) { ss << "[]"; return; } ss << '['; - for (uint i = 0; i < list.size(); i++) { - Value* value = list[i]; + for (uint i = 0; i < list->size(); i++) { + Value* value = list->get(i); if (i > 0 || nice) { newline(ss, nice, indent, indentstr); } stringify(value, ss, indent+1, indentstr, nice); - if (i + 1 < list.size()) { + if (i + 1 < list->size()) { ss << ','; } } @@ -91,27 +77,27 @@ void stringify(const Value* value, } } -void stringifyObj(const JObject* obj, +void stringifyObj(const Map* obj, std::stringstream& ss, int indent, const std::string& indentstr, bool nice) { - if (obj->map.empty()) { + if (obj->values.empty()) { ss << "{}"; return; } ss << "{"; uint index = 0; - for (auto entry : obj->map) { + for (auto& entry : obj->values) { const std::string& key = entry.first; if (index > 0 || nice) { newline(ss, nice, indent, indentstr); } - Value* value = entry.second; + Value* value = entry.second.get(); ss << escape_string(key) << ": "; stringify(value, ss, indent+1, indentstr, nice); index++; - if (index < obj->map.size()) { + if (index < obj->values.size()) { ss << ','; } } @@ -122,7 +108,7 @@ void stringifyObj(const JObject* obj, } std::string json::stringify( - const JObject* obj, + const Map* obj, bool nice, const std::string& indent) { std::stringstream ss; @@ -130,497 +116,11 @@ std::string json::stringify( return ss.str(); } -static void to_binary(ByteBuilder& builder, const Value* value) { - switch (value->type) { - case valtype::object: { - std::vector bytes = to_binary(value->value.obj); - builder.put(bytes.data(), bytes.size()); - break; - } - case valtype::array: - builder.put(BJSON_TYPE_LIST); - for (Value* element : value->value.arr->values) { - to_binary(builder, element); - } - builder.put(BJSON_END); - break; - case valtype::integer: { - int64_t val = value->value.integer; - if (val >= 0 && val <= 255) { - builder.put(BJSON_TYPE_BYTE); - builder.put(val); - } else if (val >= INT16_MIN && val <= INT16_MAX){ - builder.put(BJSON_TYPE_INT16); - builder.putInt16(val); - } else if (val >= INT32_MIN && val <= INT32_MAX) { - builder.put(BJSON_TYPE_INT32); - builder.putInt32(val); - } else { - builder.put(BJSON_TYPE_INT64); - builder.putInt64(val); - } - break; - } - case valtype::number: - builder.put(BJSON_TYPE_NUMBER); - builder.putFloat64(value->value.decimal); - break; - case valtype::boolean: - builder.put(BJSON_TYPE_FALSE + value->value.boolean); - break; - case valtype::string: - builder.put(BJSON_TYPE_STRING); - builder.put(*value->value.str); - break; - } -} - -static JArray* array_from_binary(ByteReader& reader); -static JObject* object_from_binary(ByteReader& reader); - -std::vector json::to_binary(const JObject* obj) { - ByteBuilder builder; - // type byte - builder.put(BJSON_TYPE_DOCUMENT); - // document size - builder.putInt32(0); - - // writing entries - for (auto& entry : obj->map) { - builder.putCStr(entry.first.c_str()); - to_binary(builder, entry.second); - } - // terminating byte - builder.put(BJSON_END); - - // updating document size - builder.setInt32(1, builder.size()); - return builder.build(); -} - -static Value* value_from_binary(ByteReader& reader) { - ubyte typecode = reader.get(); - valtype type; - valvalue val; - switch (typecode) { - case BJSON_TYPE_DOCUMENT: - type = valtype::object; - reader.getInt32(); - val.obj = object_from_binary(reader); - break; - case BJSON_TYPE_LIST: - type = valtype::array; - val.arr = array_from_binary(reader); - break; - case BJSON_TYPE_BYTE: - type = valtype::integer; - val.integer = reader.get(); - break; - case BJSON_TYPE_INT16: - type = valtype::integer; - val.integer = reader.getInt16(); - break; - case BJSON_TYPE_INT32: - type = valtype::integer; - val.integer = reader.getInt32(); - break; - case BJSON_TYPE_INT64: - type = valtype::integer; - val.integer = reader.getInt64(); - break; - case BJSON_TYPE_NUMBER: - type = valtype::number; - val.decimal = reader.getFloat64(); - break; - case BJSON_TYPE_FALSE: - case BJSON_TYPE_TRUE: - type = valtype::boolean; - val.boolean = typecode - BJSON_TYPE_FALSE; - break; - case BJSON_TYPE_STRING: - type = valtype::string; - val.str = new std::string(reader.getString()); - break; - default: - throw std::runtime_error( - "type "+std::to_string(typecode)+" is not supported"); - } - return new Value(type, val); -} - -static JArray* array_from_binary(ByteReader& reader) { - auto array = std::make_unique(); - auto& items = array->values; - while (reader.peek() != BJSON_END) { - items.push_back(value_from_binary(reader)); - } - reader.get(); - return array.release(); -} - -static JObject* object_from_binary(ByteReader& reader) { - auto obj = std::make_unique(); - auto& map = obj->map; - while (reader.peek() != BJSON_END) { - const char* key = reader.getCString(); - Value* value = value_from_binary(reader); - map.insert(std::make_pair(key, value)); - } - reader.get(); - return obj.release(); -} - -JObject* json::from_binary(const ubyte* src, size_t size) { - ByteReader reader(src, size); - std::unique_ptr value (value_from_binary(reader)); - if (value->type != valtype::object) { - throw std::runtime_error("root value is not an object"); - } - JObject* obj = value->value.obj; - value->value.obj = nullptr; - return obj; -} - -JArray::~JArray() { - for (auto value : values) { - delete value; - } -} - -std::string JArray::str(size_t index) const { - const auto& val = values[index]; - switch (val->type) { - case valtype::string: return *val->value.str; - case valtype::boolean: return val->value.boolean ? "true" : "false"; - case valtype::number: return std::to_string(val->value.decimal); - case valtype::integer: return std::to_string(val->value.integer); - default: - throw std::runtime_error("type error"); - } -} - -double JArray::num(size_t index) const { - const auto& val = values[index]; - switch (val->type) { - case valtype::number: return val->value.decimal; - case valtype::integer: return val->value.integer; - case valtype::string: return std::stoll(*val->value.str); - case valtype::boolean: return val->value.boolean; - default: - throw std::runtime_error("type error"); - } -} - -int64_t JArray::integer(size_t index) const { - const auto& val = values[index]; - switch (val->type) { - case valtype::number: return val->value.decimal; - case valtype::integer: return val->value.integer; - case valtype::string: return std::stoll(*val->value.str); - case valtype::boolean: return val->value.boolean; - default: - throw std::runtime_error("type error"); - } -} - -JObject* JArray::obj(size_t index) const { - return values[index]->value.obj; -} - -JArray* JArray::arr(size_t index) const { - return values[index]->value.arr; -} - -bool JArray::flag(size_t index) const { - return values[index]->value.boolean; -} - -JArray& JArray::put(std::string value) { - valvalue val; - val.str = new std::string(value); - values.push_back(new Value(valtype::string, val)); - return *this; -} - -JArray& JArray::put(uint value) { - return put((int64_t)value); -} - -JArray& JArray::put(int value) { - return put((int64_t)value); -} - -JArray& JArray::put(int64_t value) { - valvalue val; - val.integer = value; - values.push_back(new Value(valtype::integer, val)); - return *this; -} - -JArray& JArray::put(uint64_t value) { - return put((int64_t)value); -} - -JArray& JArray::put(double value) { - valvalue val; - val.decimal = value; - values.push_back(new Value(valtype::number, val)); - return *this; -} - -JArray& JArray::put(float value) { - return put((double)value); -} - -JArray& JArray::put(bool value) { - valvalue val; - val.boolean = value; - values.push_back(new Value(valtype::boolean, val)); - return *this; -} - -JArray& JArray::put(JObject* value) { - valvalue val; - val.obj = value; - values.push_back(new Value(valtype::object, val)); - return *this; -} - -JArray& JArray::put(JArray* value) { - valvalue val; - val.arr = value; - values.push_back(new Value(valtype::array, val)); - return *this; -} - -JArray& JArray::putArray() { - JArray* arr = new JArray(); - put(arr); - return *arr; -} - -JObject& JArray::putObj() { - JObject* obj = new JObject(); - put(obj); - return *obj; -} - -void JArray::remove(size_t index) { - values.erase(values.begin() + index); -} - -JObject::~JObject() { - for (auto entry : map) { - delete entry.second; - } -} - -void JObject::str(std::string key, std::string& dst) const { - dst = getStr(key, dst); -} - -std::string JObject::getStr(std::string key, const std::string& def) const { - auto found = map.find(key); - if (found == map.end()) - return def; - auto& val = found->second; - switch (val->type) { - case valtype::string: return *val->value.str; - case valtype::boolean: return val->value.boolean ? "true" : "false"; - case valtype::number: return std::to_string(val->value.decimal); - case valtype::integer: return std::to_string(val->value.integer); - default: throw std::runtime_error("type error"); - } -} - -double JObject::getNum(std::string key, double def) const { - auto found = map.find(key); - if (found == map.end()) - return def; - auto& val = found->second; - switch (val->type) { - case valtype::number: return val->value.decimal; - case valtype::integer: return val->value.integer; - case valtype::string: return std::stoull(*val->value.str); - case valtype::boolean: return val->value.boolean; - default: throw std::runtime_error("type error"); - } -} - -int64_t JObject::getInteger(std::string key, int64_t def) const { - auto found = map.find(key); - if (found == map.end()) - return def; - auto& val = found->second; - switch (val->type) { - case valtype::number: return val->value.decimal; - case valtype::integer: return val->value.integer; - case valtype::string: return std::stoull(*val->value.str); - case valtype::boolean: return val->value.boolean; - default: throw std::runtime_error("type error"); - } -} - -void JObject::num(std::string key, double& dst) const { - dst = getNum(key, dst); -} - -void JObject::num(std::string key, float& dst) const { - dst = getNum(key, dst); -} - -void JObject::num(std::string key, ubyte& dst) const { - dst = getInteger(key, dst); -} - -void JObject::num(std::string key, int& dst) const { - dst = getInteger(key, dst); -} - -void JObject::num(std::string key, int64_t& dst) const { - dst = getInteger(key, dst); -} - -void JObject::num(std::string key, uint64_t& dst) const { - dst = getInteger(key, dst); -} - -void JObject::num(std::string key, uint& dst) const { - dst = getInteger(key, dst); -} - -JObject* JObject::obj(std::string key) const { - auto found = map.find(key); - if (found != map.end()) { - auto& val = found->second; - if (val->type != valtype::object) - return nullptr; - return val->value.obj; - } - return nullptr; -} - -JArray* JObject::arr(std::string key) const { - auto found = map.find(key); - if (found != map.end()) - return found->second->value.arr; - return nullptr; -} - -void JObject::flag(std::string key, bool& dst) const { - auto found = map.find(key); - if (found != map.end()) - dst = found->second->value.boolean; -} - -JObject& JObject::put(std::string key, uint value) { - return put(key, (int64_t)value); -} - -JObject& JObject::put(std::string key, int value) { - return put(key, (int64_t)value); -} - -JObject& JObject::put(std::string key, int64_t value) { - auto found = map.find(key); - if (found != map.end()) found->second; - valvalue val; - val.integer = value; - map.insert(std::make_pair(key, new Value(valtype::integer, val))); - return *this; -} - -JObject& JObject::put(std::string key, uint64_t value) { - return put(key, (int64_t)value); -} - -JObject& JObject::put(std::string key, float value) { - return put(key, (double)value); -} - -JObject& JObject::put(std::string key, double value) { - auto found = map.find(key); - if (found != map.end()) delete found->second; - valvalue val; - val.decimal = value; - map.insert(std::make_pair(key, new Value(valtype::number, val))); - return *this; -} - -JObject& JObject::put(std::string key, std::string value){ - auto found = map.find(key); - if (found != map.end()) delete found->second; - valvalue val; - val.str = new std::string(value); - map.insert(std::make_pair(key, new Value(valtype::string, val))); - return *this; -} - -JObject& JObject::put(std::string key, const char* value) { - return put(key, std::string(value)); -} - -JObject& JObject::put(std::string key, JObject* value){ - auto found = map.find(key); - if (found != map.end()) delete found->second; - valvalue val; - val.obj = value; - map.insert(std::make_pair(key, new Value(valtype::object, val))); - return *this; -} - -JObject& JObject::put(std::string key, JArray* value){ - auto found = map.find(key); - if (found != map.end()) delete found->second; - valvalue val; - val.arr = value; - map.insert(std::make_pair(key, new Value(valtype::array, val))); - return *this; -} - -JObject& JObject::put(std::string key, bool value){ - auto found = map.find(key); - if (found != map.end()) delete found->second; - valvalue val; - val.boolean = value; - map.insert(std::make_pair(key, new Value(valtype::boolean, val))); - return *this; -} - -JArray& JObject::putArray(std::string key) { - JArray* arr = new JArray(); - put(key, arr); - return *arr; -} - -JObject& JObject::putObj(std::string key) { - JObject* obj = new JObject(); - put(key, obj); - return *obj; -} - -bool JObject::has(std::string key) { - return map.find(key) != map.end(); -} - -Value::Value(valtype type, valvalue value) : type(type), value(value) { -} - -Value::~Value() { - switch (type) { - case valtype::object: delete value.obj; break; - case valtype::array: delete value.arr; break; - case valtype::string: delete value.str; break; - default: - break; - } -} - Parser::Parser(std::string filename, std::string source) : BasicParser(filename, source) { } -JObject* Parser::parse() { +Map* Parser::parse() { char next = peek(); if (next != '{') { throw error("'{' expected"); @@ -628,10 +128,10 @@ JObject* Parser::parse() { return parseObject(); } -JObject* Parser::parseObject() { +Map* Parser::parseObject() { expect('{'); - auto obj = std::make_unique(); - auto& map = obj->map; + auto obj = std::make_unique(); + auto& map = obj->values; while (peek() != '}') { if (peek() == '#') { skipLine(); @@ -657,16 +157,16 @@ JObject* Parser::parseObject() { return obj.release(); } -JArray* Parser::parseArray() { +List* Parser::parseList() { expect('['); - auto arr = std::make_unique(); + auto arr = std::make_unique(); auto& values = arr->values; while (peek() != ']') { if (peek() == '#') { skipLine(); continue; } - values.push_back(parseValue()); + values.push_back(std::unique_ptr(parseValue())); char next = peek(); if (next == ',') { @@ -683,7 +183,7 @@ JArray* Parser::parseArray() { Value* Parser::parseValue() { char next = peek(); - valvalue val; + dynamic::valvalue val; if (next == '-' || next == '+') { pos++; number_u num; @@ -715,12 +215,12 @@ Value* Parser::parseValue() { throw error("invalid literal "); } if (next == '{') { - val.obj = parseObject(); - return new Value(valtype::object, val); + val.map = parseObject(); + return new Value(valtype::map, val); } if (next == '[') { - val.arr = parseArray(); - return new Value(valtype::array, val); + val.list = parseList(); + return new Value(valtype::list, val); } if (is_digit(next)) { number_u num; @@ -742,11 +242,11 @@ Value* Parser::parseValue() { throw error("unexpected character '"+std::string({next})+"'"); } -JObject* json::parse(std::string filename, std::string source) { +std::unique_ptr json::parse(std::string filename, std::string source) { Parser parser(filename, source); - return parser.parse(); + return std::unique_ptr(parser.parse()); } -JObject* json::parse(std::string source) { +std::unique_ptr json::parse(std::string source) { return parse("", source); } diff --git a/src/coders/json.h b/src/coders/json.h index c90e3314..3fc917da 100644 --- a/src/coders/json.h +++ b/src/coders/json.h @@ -8,122 +8,34 @@ #include #include "commons.h" +#include "../typedefs.h" -typedef unsigned int uint; +#include "binary_json.h" + +namespace dynamic { + class Map; + class List; + class Value; +} namespace json { - class JObject; - class JArray; - class Value; - - extern std::string stringify(const JObject* obj, bool nice, const std::string& indent); - extern std::vector to_binary(const JObject* obj); - extern JObject* from_binary(const ubyte* src, size_t size); - - enum class valtype { - object, array, number, integer, string, boolean - }; - - union valvalue { - JObject* obj; - JArray* arr; - std::string* str; - double decimal; - int64_t integer; - bool boolean; - }; - - class Value { - public: - valtype type; - valvalue value; - Value(valtype type, valvalue value); - ~Value(); - }; - - class JArray { - public: - std::vector values; - ~JArray(); - - std::string str(size_t index) const; - double num(size_t index) const; - int64_t integer(size_t num) const; - JObject* obj(size_t index) const; - JArray* arr(size_t index) const; - bool flag(size_t index) const; - - inline size_t size() const { - return values.size(); - } - - JArray& put(uint value); - JArray& put(int value); - JArray& put(uint64_t value); - JArray& put(int64_t value); - JArray& put(float value); - JArray& put(double value); - JArray& put(std::string value); - JArray& put(JObject* value); - JArray& put(JArray* value); - JArray& put(bool value); - - JArray& putArray(); - JObject& putObj(); - - void remove(size_t index); - }; - - class JObject { - public: - std::unordered_map map; - ~JObject(); - - std::string getStr(std::string key, const std::string& def) const; - double getNum(std::string key, double def) const; - int64_t getInteger(std::string key, int64_t def) const; - void str(std::string key, std::string& dst) const; - void num(std::string key, int& dst) const; - void num(std::string key, float& dst) const; - void num(std::string key, uint& dst) const; - void num(std::string key, int64_t& dst) const; - void num(std::string key, uint64_t& dst) const; - void num(std::string key, ubyte& dst) const; - void num(std::string key, double& dst) const; - JObject* obj(std::string key) const; - JArray* arr(std::string key) const; - void flag(std::string key, bool& dst) const; - - JObject& put(std::string key, uint value); - JObject& put(std::string key, int value); - JObject& put(std::string key, int64_t value); - JObject& put(std::string key, uint64_t value); - JObject& put(std::string key, float value); - JObject& put(std::string key, double value); - JObject& put(std::string key, const char* value); - JObject& put(std::string key, std::string value); - JObject& put(std::string key, JObject* value); - JObject& put(std::string key, JArray* value); - JObject& put(std::string key, bool value); - - JArray& putArray(std::string key); - JObject& putObj(std::string key); - - bool has(std::string key); - }; - class Parser : public BasicParser { - JArray* parseArray(); - JObject* parseObject(); - Value* parseValue(); + dynamic::List* parseList(); + dynamic::Map* parseObject(); + dynamic::Value* parseValue(); public: Parser(std::string filename, std::string source); - JObject* parse(); + dynamic::Map* parse(); }; - extern JObject* parse(std::string filename, std::string source); - extern JObject* parse(std::string source); + extern std::unique_ptr parse(std::string filename, std::string source); + extern std::unique_ptr parse(std::string source); + + extern std::string stringify( + const dynamic::Map* obj, + bool nice, + const std::string& indent); } #endif // CODERS_JSON_H_ \ No newline at end of file diff --git a/src/content/Content.cpp b/src/content/Content.cpp index d808e48b..aa98de9a 100644 --- a/src/content/Content.cpp +++ b/src/content/Content.cpp @@ -131,7 +131,6 @@ Content::Content(ContentIndices* indices, DrawGroups* drawGroups, } Content::~Content() { - delete indices; delete drawGroups; } diff --git a/src/content/Content.h b/src/content/Content.h index db9aae43..cd36a474 100644 --- a/src/content/Content.h +++ b/src/content/Content.h @@ -92,14 +92,18 @@ public: class Content { std::unordered_map blockDefs; std::unordered_map itemDefs; + std::unique_ptr indices; public: - ContentIndices* const indices; DrawGroups* const drawGroups; Content(ContentIndices* indices, DrawGroups* drawGroups, std::unordered_map blockDefs, std::unordered_map itemDefs); ~Content(); + + inline ContentIndices* getIndices() const { + return indices.get(); + } Block* findBlock(std::string id) const; Block* requireBlock(std::string id) const; diff --git a/src/content/ContentLUT.cpp b/src/content/ContentLUT.cpp index 7a0d6eb8..11e7b5e8 100644 --- a/src/content/ContentLUT.cpp +++ b/src/content/ContentLUT.cpp @@ -8,15 +8,10 @@ #include "../coders/json.h" #include "../voxels/Block.h" -using std::string; -using std::unique_ptr; -using std::make_unique; -using std::filesystem::path; - -#include +#include "../data/dynamic.h" ContentLUT::ContentLUT(size_t blocksCount, const Content* content) { - ContentIndices* indices = content->indices; + auto* indices = content->getIndices(); for (size_t i = 0; i < blocksCount; i++) { blocks.push_back(i); } @@ -24,25 +19,25 @@ ContentLUT::ContentLUT(size_t blocksCount, const Content* content) { blockNames.push_back(indices->getBlockDef(i)->name); } - for (size_t i = indices->countBlockDefs(); i < blocksCount; i++) { + for (size_t i = indices->countBlockDefs(); i < blocksCount; i++) { blockNames.push_back(""); } } -ContentLUT* ContentLUT::create(const path& filename, +ContentLUT* ContentLUT::create(const fs::path& filename, const Content* content) { - unique_ptr root(files::read_json(filename)); - json::JArray* blocksarr = root->arr("blocks"); + auto root = files::read_json(filename); + auto blocklist = root->list("blocks"); - auto& indices = content->indices; - size_t blocks_c = blocksarr - ? std::max(blocksarr->size(), indices->countBlockDefs()) + auto* indices = content->getIndices(); + size_t blocks_c = blocklist + ? std::max(blocklist->size(), indices->countBlockDefs()) : indices->countBlockDefs(); - auto lut = make_unique(blocks_c, content); - if (blocksarr) { - for (size_t i = 0; i < blocksarr->size(); i++) { - string name = blocksarr->str(i); + auto lut = std::make_unique(blocks_c, content); + if (blocklist) { + for (size_t i = 0; i < blocklist->size(); i++) { + std::string name = blocklist->str(i); Block* def = content->findBlock(name); if (def) { lut->setBlock(i, name, def->rt.id); diff --git a/src/content/ContentLUT.h b/src/content/ContentLUT.h index 4da4df78..458d4bfb 100644 --- a/src/content/ContentLUT.h +++ b/src/content/ContentLUT.h @@ -8,6 +8,8 @@ #include "../typedefs.h" #include "../constants.h" +namespace fs = std::filesystem; + class Content; /* Content indices lookup table or report @@ -40,7 +42,7 @@ public: } } - static ContentLUT* create(const std::filesystem::path& filename, + static ContentLUT* create(const fs::path& filename, const Content* content); inline bool hasContentReorder() const { diff --git a/src/content/ContentLoader.cpp b/src/content/ContentLoader.cpp index f0c803c6..d0cd7e90 100644 --- a/src/content/ContentLoader.cpp +++ b/src/content/ContentLoader.cpp @@ -13,6 +13,7 @@ #include "../files/files.h" #include "../coders/json.h" #include "../typedefs.h" +#include "../data/dynamic.h" #include "ContentPack.h" #include "../logic/scripting/scripting.h" @@ -23,9 +24,8 @@ ContentLoader::ContentLoader(ContentPack* pack) : pack(pack) { } bool ContentLoader::fixPackIndices(fs::path folder, - json::JObject* indicesRoot, + dynamic::Map* indicesRoot, std::string contentSection) { - std::vector detected; std::vector indexed; if (fs::is_directory(folder)) { @@ -42,9 +42,9 @@ bool ContentLoader::fixPackIndices(fs::path folder, bool modified = false; if (!indicesRoot->has(contentSection)) { - indicesRoot->putArray(contentSection); + indicesRoot->putList(contentSection); } - json::JArray* arr = indicesRoot->arr(contentSection); + auto arr = indicesRoot->list(contentSection); if (arr) { for (uint i = 0; i < arr->size(); i++) { std::string name = arr->str(i); @@ -72,11 +72,11 @@ void ContentLoader::fixPackIndices() { auto blocksFolder = folder/ContentPack::BLOCKS_FOLDER; auto itemsFolder = folder/ContentPack::ITEMS_FOLDER; - std::unique_ptr root; + std::unique_ptr root; if (fs::is_regular_file(indexFile)) { - root.reset(files::read_json(indexFile)); + root = std::move(files::read_json(indexFile)); } else { - root.reset(new json::JObject()); + root.reset(new dynamic::Map()); } bool modified = false; @@ -93,7 +93,7 @@ void ContentLoader::fixPackIndices() { // TODO: add basic validation and logging void ContentLoader::loadBlock(Block* def, std::string name, fs::path file) { - std::unique_ptr root(files::read_json(file)); + auto root = files::read_json(file); // block texturing if (root->has("texture")) { @@ -103,7 +103,7 @@ void ContentLoader::loadBlock(Block* def, std::string name, fs::path file) { def->textureFaces[i] = texture; } } else if (root->has("texture-faces")) { - json::JArray* texarr = root->arr("texture-faces"); + auto texarr = root->list("texture-faces"); for (uint i = 0; i < 6; i++) { def->textureFaces[i] = texarr->str(i); } @@ -117,7 +117,7 @@ void ContentLoader::loadBlock(Block* def, std::string name, fs::path file) { else if (model == "custom") { def->model = BlockModel::custom; if (root->has("model-primitives")) { - loadCustomBlockModel(def, root->obj("model-primitives")); + loadCustomBlockModel(def, root->map("model-primitives")); } else { std::cerr << "ERROR occured while block " @@ -145,20 +145,20 @@ void ContentLoader::loadBlock(Block* def, std::string name, fs::path file) { } // block hitbox AABB [x, y, z, width, height, depth] - json::JArray* boxobj = root->arr("hitbox"); - if (boxobj) { + auto boxarr = root->list("hitbox"); + if (boxarr) { AABB& aabb = def->hitbox; - aabb.a = glm::vec3(boxobj->num(0), boxobj->num(1), boxobj->num(2)); - aabb.b = glm::vec3(boxobj->num(3), boxobj->num(4), boxobj->num(5)); + aabb.a = glm::vec3(boxarr->num(0), boxarr->num(1), boxarr->num(2)); + aabb.b = glm::vec3(boxarr->num(3), boxarr->num(4), boxarr->num(5)); aabb.b += aabb.a; } // block light emission [r, g, b] where r,g,b in range [0..15] - json::JArray* emissionobj = root->arr("emission"); - if (emissionobj) { - def->emission[0] = emissionobj->num(0); - def->emission[1] = emissionobj->num(1); - def->emission[2] = emissionobj->num(2); + auto emissionarr = root->list("emission"); + if (emissionarr) { + def->emission[0] = emissionarr->num(0); + def->emission[1] = emissionarr->num(1); + def->emission[2] = emissionarr->num(2); } // primitive properties @@ -171,29 +171,28 @@ void ContentLoader::loadBlock(Block* def, std::string name, fs::path file) { root->flag("hidden", def->hidden); root->flag("sky-light-passing", def->skyLightPassing); root->num("draw-group", def->drawGroup); - root->str("picking-item", def->pickingItem); } -void ContentLoader::loadCustomBlockModel(Block* def, json::JObject* primitives) { +void ContentLoader::loadCustomBlockModel(Block* def, dynamic::Map* primitives) { if (primitives->has("aabbs")) { - json::JArray* modelboxes = primitives->arr("aabbs"); + auto modelboxes = primitives->list("aabbs"); for (uint i = 0; i < modelboxes->size(); i++ ) { /* Parse aabb */ - json::JArray* boxobj = modelboxes->arr(i); + auto boxarr = modelboxes->list(i); AABB modelbox; - modelbox.a = glm::vec3(boxobj->num(0), boxobj->num(1), boxobj->num(2)); - modelbox.b = glm::vec3(boxobj->num(3), boxobj->num(4), boxobj->num(5)); + modelbox.a = glm::vec3(boxarr->num(0), boxarr->num(1), boxarr->num(2)); + modelbox.b = glm::vec3(boxarr->num(3), boxarr->num(4), boxarr->num(5)); modelbox.b += modelbox.a; def->modelBoxes.push_back(modelbox); - if (boxobj->size() == 7) + if (boxarr->size() == 7) for (uint i = 6; i < 12; i++) { - def->modelTextures.push_back(boxobj->str(6)); + def->modelTextures.push_back(boxarr->str(6)); } - else if (boxobj->size() == 12) + else if (boxarr->size() == 12) for (uint i = 6; i < 12; i++) { - def->modelTextures.push_back(boxobj->str(i)); + def->modelTextures.push_back(boxarr->str(i)); } else for (uint i = 6; i < 12; i++) { @@ -202,10 +201,10 @@ void ContentLoader::loadCustomBlockModel(Block* def, json::JObject* primitives) } } if (primitives->has("tetragons")) { - json::JArray* modeltetragons = primitives->arr("tetragons"); + auto modeltetragons = primitives->list("tetragons"); for (uint i = 0; i < modeltetragons->size(); i++) { /* Parse tetragon to points */ - json::JArray* tgonobj = modeltetragons->arr(i); + auto tgonobj = modeltetragons->list(i); glm::vec3 p1(tgonobj->num(0), tgonobj->num(1), tgonobj->num(2)), xw(tgonobj->num(3), tgonobj->num(4), tgonobj->num(5)), yh(tgonobj->num(6), tgonobj->num(7), tgonobj->num(8)); @@ -220,7 +219,7 @@ void ContentLoader::loadCustomBlockModel(Block* def, json::JObject* primitives) } void ContentLoader::loadItem(ItemDef* def, std::string name, fs::path file) { - std::unique_ptr root(files::read_json(file)); + auto root = files::read_json(file); std::string iconTypeStr = "none"; root->str("icon-type", iconTypeStr); if (iconTypeStr == "none") { @@ -236,11 +235,11 @@ void ContentLoader::loadItem(ItemDef* def, std::string name, fs::path file) { root->str("placing-block", def->placingBlock); // item light emission [r, g, b] where r,g,b in range [0..15] - json::JArray* emissionobj = root->arr("emission"); - if (emissionobj) { - def->emission[0] = emissionobj->num(0); - def->emission[1] = emissionobj->num(1); - def->emission[2] = emissionobj->num(2); + auto emissionarr = root->list("emission"); + if (emissionarr) { + def->emission[0] = emissionarr->num(0); + def->emission[1] = emissionarr->num(1); + def->emission[2] = emissionarr->num(2); } } @@ -274,9 +273,8 @@ void ContentLoader::load(ContentBuilder* builder) { auto folder = pack->folder; if (!fs::is_regular_file(pack->getContentFile())) return; - std::unique_ptr root (files::read_json(pack->getContentFile())); - - json::JArray* blocksarr = root->arr("blocks"); + auto root = files::read_json(pack->getContentFile()); + auto blocksarr = root->list("blocks"); if (blocksarr) { for (uint i = 0; i < blocksarr->size(); i++) { std::string name = blocksarr->str(i); @@ -297,7 +295,7 @@ void ContentLoader::load(ContentBuilder* builder) { } } - json::JArray* itemsarr = root->arr("items"); + auto itemsarr = root->list("items"); if (itemsarr) { for (uint i = 0; i < itemsarr->size(); i++) { std::string name = itemsarr->str(i); diff --git a/src/content/ContentLoader.h b/src/content/ContentLoader.h index acdd4e2f..e8517d53 100644 --- a/src/content/ContentLoader.h +++ b/src/content/ContentLoader.h @@ -4,30 +4,32 @@ #include #include +namespace fs = std::filesystem; + class Block; class ItemDef; class ContentPack; class ContentBuilder; -namespace json { - class JObject; +namespace dynamic { + class Map; } class ContentLoader { const ContentPack* pack; void loadBlock(Block* def, std::string full, std::string name); - void loadCustomBlockModel(Block* def, json::JObject* primitives); + void loadCustomBlockModel(Block* def, dynamic::Map* primitives); void loadItem(ItemDef* def, std::string full, std::string name); public: ContentLoader(ContentPack* pack); bool fixPackIndices(std::filesystem::path folder, - json::JObject* indicesRoot, + dynamic::Map* indicesRoot, std::string contentSection); void fixPackIndices(); - void loadBlock(Block* def, std::string name, std::filesystem::path file); - void loadItem(ItemDef* def, std::string name, std::filesystem::path file); + void loadBlock(Block* def, std::string name, fs::path file); + void loadItem(ItemDef* def, std::string name, fs::path file); void load(ContentBuilder* builder); }; diff --git a/src/content/ContentPack.cpp b/src/content/ContentPack.cpp index ae3ea758..2084d571 100644 --- a/src/content/ContentPack.cpp +++ b/src/content/ContentPack.cpp @@ -5,6 +5,7 @@ #include "../coders/json.h" #include "../files/files.h" #include "../files/engine_paths.h" +#include "../data/dynamic.h" namespace fs = std::filesystem; @@ -15,7 +16,7 @@ const fs::path ContentPack::ITEMS_FOLDER = "items"; contentpack_error::contentpack_error( std::string packId, - std::filesystem::path folder, + fs::path folder, std::string message) : std::runtime_error(message), packId(packId), folder(folder) { } @@ -23,19 +24,19 @@ contentpack_error::contentpack_error( std::string contentpack_error::getPackId() const { return packId; } -std::filesystem::path contentpack_error::getFolder() const { +fs::path contentpack_error::getFolder() const { return folder; } -std::filesystem::path ContentPack::getContentFile() const { +fs::path ContentPack::getContentFile() const { return folder/fs::path(CONTENT_FILENAME); } -bool ContentPack::is_pack(std::filesystem::path folder) { +bool ContentPack::is_pack(fs::path folder) { return fs::is_regular_file(folder/fs::path(PACKAGE_FILENAME)); } -ContentPack ContentPack::read(std::filesystem::path folder) { +ContentPack ContentPack::read(fs::path folder) { auto root = files::read_json(folder/fs::path(PACKAGE_FILENAME)); ContentPack pack; root->str("id", pack.id); @@ -88,7 +89,7 @@ fs::path ContentPack::findPack(const EnginePaths* paths, fs::path worldDir, std: void ContentPack::readPacks(const EnginePaths* paths, std::vector& packs, const std::vector& packnames, - std::filesystem::path worldDir) { + fs::path worldDir) { for (const auto& name : packnames) { fs::path packfolder = ContentPack::findPack(paths, worldDir, name); packs.push_back(ContentPack::read(packfolder)); diff --git a/src/data/dynamic.cpp b/src/data/dynamic.cpp new file mode 100644 index 00000000..30fa53ca --- /dev/null +++ b/src/data/dynamic.cpp @@ -0,0 +1,331 @@ +#include "dynamic.h" + +#include + +using namespace dynamic; + +List::~List() { +} + +std::string List::str(size_t index) const { + const auto& val = values[index]; + switch (val->type) { + case valtype::string: return *val->value.str; + case valtype::boolean: return val->value.boolean ? "true" : "false"; + case valtype::number: return std::to_string(val->value.decimal); + case valtype::integer: return std::to_string(val->value.integer); + default: + throw std::runtime_error("type error"); + } +} + +double List::num(size_t index) const { + const auto& val = values[index]; + switch (val->type) { + case valtype::number: return val->value.decimal; + case valtype::integer: return val->value.integer; + case valtype::string: return std::stoll(*val->value.str); + case valtype::boolean: return val->value.boolean; + default: + throw std::runtime_error("type error"); + } +} + +int64_t List::integer(size_t index) const { + const auto& val = values[index]; + switch (val->type) { + case valtype::number: return val->value.decimal; + case valtype::integer: return val->value.integer; + case valtype::string: return std::stoll(*val->value.str); + case valtype::boolean: return val->value.boolean; + default: + throw std::runtime_error("type error"); + } +} + +Map* List::map(size_t index) const { + return values[index]->value.map; +} + +List* List::list(size_t index) const { + return values[index]->value.list; +} + +bool List::flag(size_t index) const { + return values[index]->value.boolean; +} + +List& List::put(std::string value) { + valvalue val; + val.str = new std::string(value); + values.push_back(std::make_unique(valtype::string, val)); + return *this; +} + +List& List::put(uint value) { + return put((int64_t)value); +} + +List& List::put(int value) { + return put((int64_t)value); +} + +List& List::put(int64_t value) { + valvalue val; + val.integer = value; + values.push_back(std::make_unique(valtype::integer, val)); + return *this; +} + +List& List::put(uint64_t value) { + return put((int64_t)value); +} + +List& List::put(double value) { + valvalue val; + val.decimal = value; + values.push_back(std::make_unique(valtype::number, val)); + return *this; +} + +List& List::put(float value) { + return put((double)value); +} + +List& List::put(bool value) { + valvalue val; + val.boolean = value; + values.push_back(std::make_unique(valtype::boolean, val)); + return *this; +} + +List& List::put(Map* value) { + valvalue val; + val.map = value; + values.push_back(std::make_unique(valtype::map, val)); + return *this; +} + +List& List::put(List* value) { + valvalue val; + val.list = value; + values.push_back(std::make_unique(valtype::list, val)); + return *this; +} + +List& List::putList() { + List* arr = new List(); + put(arr); + return *arr; +} + +Map& List::putMap() { + Map* map = new Map(); + put(map); + return *map; +} + +void List::remove(size_t index) { + values.erase(values.begin() + index); +} + +Map::~Map() { +} + +void Map::str(std::string key, std::string& dst) const { + dst = getStr(key, dst); +} + +std::string Map::getStr(std::string key, const std::string& def) const { + auto found = values.find(key); + if (found == values.end()) + return def; + auto& val = found->second; + switch (val->type) { + case valtype::string: return *val->value.str; + case valtype::boolean: return val->value.boolean ? "true" : "false"; + case valtype::number: return std::to_string(val->value.decimal); + case valtype::integer: return std::to_string(val->value.integer); + default: throw std::runtime_error("type error"); + } +} + +double Map::getNum(std::string key, double def) const { + auto found = values.find(key); + if (found == values.end()) + return def; + auto& val = found->second; + switch (val->type) { + case valtype::number: return val->value.decimal; + case valtype::integer: return val->value.integer; + case valtype::string: return std::stoull(*val->value.str); + case valtype::boolean: return val->value.boolean; + default: throw std::runtime_error("type error"); + } +} + +int64_t Map::getInt(std::string key, int64_t def) const { + auto found = values.find(key); + if (found == values.end()) + return def; + auto& val = found->second; + switch (val->type) { + case valtype::number: return val->value.decimal; + case valtype::integer: return val->value.integer; + case valtype::string: return std::stoull(*val->value.str); + case valtype::boolean: return val->value.boolean; + default: throw std::runtime_error("type error"); + } +} + +bool Map::getBool(std::string key, bool def) const { + auto found = values.find(key); + if (found != values.end()) + return found->second->value.boolean; + return def; +} + +void Map::num(std::string key, double& dst) const { + dst = getNum(key, dst); +} + +void Map::num(std::string key, float& dst) const { + dst = getNum(key, dst); +} + +void Map::num(std::string key, ubyte& dst) const { + dst = getInt(key, dst); +} + +void Map::num(std::string key, int& dst) const { + dst = getInt(key, dst); +} + +void Map::num(std::string key, int64_t& dst) const { + dst = getInt(key, dst); +} + +void Map::num(std::string key, uint64_t& dst) const { + dst = getInt(key, dst); +} + +void Map::num(std::string key, uint& dst) const { + dst = getInt(key, dst); +} + +Map* Map::map(std::string key) const { + auto found = values.find(key); + if (found != values.end()) { + auto& val = found->second; + if (val->type != valtype::map) + return nullptr; + return val->value.map; + } + return nullptr; +} + +List* Map::list(std::string key) const { + auto found = values.find(key); + if (found != values.end()) + return found->second->value.list; + return nullptr; +} + +void Map::flag(std::string key, bool& dst) const { + auto found = values.find(key); + if (found != values.end()) + dst = found->second->value.boolean; +} + +Map& Map::put(std::string key, uint value) { + return put(key, (int64_t)value); +} + +Map& Map::put(std::string key, int value) { + return put(key, (int64_t)value); +} + +Map& Map::put(std::string key, int64_t value) { + auto found = values.find(key); + if (found != values.end()) found->second; + valvalue val; + val.integer = value; + values.insert(std::make_pair(key, new Value(valtype::integer, val))); + return *this; +} + +Map& Map::put(std::string key, uint64_t value) { + return put(key, (int64_t)value); +} + +Map& Map::put(std::string key, float value) { + return put(key, (double)value); +} + +Map& Map::put(std::string key, double value) { + valvalue val; + val.decimal = value; + values.insert(std::make_pair(key, new Value(valtype::number, val))); + return *this; +} + +Map& Map::put(std::string key, std::string value){ + valvalue val; + val.str = new std::string(value); + values.insert(std::make_pair(key, new Value(valtype::string, val))); + return *this; +} + +Map& Map::put(std::string key, const char* value) { + return put(key, std::string(value)); +} + +Map& Map::put(std::string key, Map* value){ + valvalue val; + val.map = value; + values.insert(std::make_pair(key, new Value(valtype::map, val))); + return *this; +} + +Map& Map::put(std::string key, List* value){ + valvalue val; + val.list = value; + values.insert(std::make_pair(key, new Value(valtype::list, val))); + return *this; +} + +Map& Map::put(std::string key, bool value){ + valvalue val; + val.boolean = value; + values.insert(std::make_pair(key, new Value(valtype::boolean, val))); + return *this; +} + +List& Map::putList(std::string key) { + List* arr = new List(); + put(key, arr); + return *arr; +} + +Map& Map::putMap(std::string key) { + Map* obj = new Map(); + put(key, obj); + return *obj; +} + +bool Map::has(std::string key) { + return values.find(key) != values.end(); +} + +Value::Value(valtype type, valvalue value) : type(type), value(value) { +} + +Value::~Value() { + switch (type) { + case valtype::map: delete value.map; break; + case valtype::list: delete value.list; break; + case valtype::string: delete value.str; break; + default: + break; + } +} diff --git a/src/data/dynamic.h b/src/data/dynamic.h new file mode 100644 index 00000000..31150f26 --- /dev/null +++ b/src/data/dynamic.h @@ -0,0 +1,113 @@ +#ifndef DATA_DYNAMIC_H_ +#define DATA_DYNAMIC_H_ + +#include +#include +#include +#include "../typedefs.h" + +namespace dynamic { + class Map; + class List; + class Value; + + enum class valtype { + map, list, number, integer, string, boolean + }; + + union valvalue { + Map* map; + List* list; + std::string* str; + double decimal; + int64_t integer; + bool boolean; + }; + + class Value { + public: + valtype type; + valvalue value; + Value(valtype type, valvalue value); + ~Value(); + }; + + class List { + public: + std::vector> values; + ~List(); + + std::string str(size_t index) const; + double num(size_t index) const; + int64_t integer(size_t num) const; + Map* map(size_t index) const; + List* list(size_t index) const; + bool flag(size_t index) const; + + inline size_t size() const { + return values.size(); + } + + inline Value* get(size_t i) const { + return values.at(i).get(); + } + + List& put(uint value); + List& put(int value); + List& put(uint64_t value); + List& put(int64_t value); + List& put(float value); + List& put(double value); + List& put(std::string value); + List& put(Map* value); + List& put(List* value); + List& put(bool value); + + List& putList(); + Map& putMap(); + + void remove(size_t index); + }; + + class Map { + public: + std::unordered_map> values; + ~Map(); + + std::string getStr(std::string key, const std::string& def) const; + double getNum(std::string key, double def) const; + int64_t getInt(std::string key, int64_t def) const; + bool getBool(std::string key, bool def) const; + + void str(std::string key, std::string& dst) const; + void num(std::string key, int& dst) const; + void num(std::string key, float& dst) const; + void num(std::string key, uint& dst) const; + void num(std::string key, int64_t& dst) const; + void num(std::string key, uint64_t& dst) const; + void num(std::string key, ubyte& dst) const; + void num(std::string key, double& dst) const; + Map* map(std::string key) const; + List* list(std::string key) const; + void flag(std::string key, bool& dst) const; + + Map& put(std::string key, uint value); + Map& put(std::string key, int value); + Map& put(std::string key, int64_t value); + Map& put(std::string key, uint64_t value); + Map& put(std::string key, float value); + Map& put(std::string key, double value); + Map& put(std::string key, const char* value); + Map& put(std::string key, std::string value); + Map& put(std::string key, Map* value); + Map& put(std::string key, List* value); + Map& put(std::string key, bool value); + + List& putList(std::string key); + Map& putMap(std::string key); + + bool has(std::string key); + }; +} + +#endif // DATA_DYNAMIC_H_ diff --git a/src/files/WorldFiles.cpp b/src/files/WorldFiles.cpp index 84e857c0..6fd51b84 100644 --- a/src/files/WorldFiles.cpp +++ b/src/files/WorldFiles.cpp @@ -18,6 +18,8 @@ #include "../constants.h" #include "../items/ItemDef.h" +#include "../data/dynamic.h" + #include #include #include @@ -444,7 +446,7 @@ void WorldFiles::write(const World* world, const Content* content) { if (generatorTestMode) return; - writeIndices(content->indices); + writeIndices(content->getIndices()); writeRegions(regions, regionsFolder, REGION_LAYER_VOXELS); writeRegions(lights, lightsFolder, REGION_LAYER_LIGHTS); } @@ -460,16 +462,16 @@ void WorldFiles::writePacks(const World* world) { } void WorldFiles::writeIndices(const ContentIndices* indices) { - json::JObject root; + dynamic::Map root; uint count; - json::JArray& blocks = root.putArray("blocks"); + auto& blocks = root.putList("blocks"); count = indices->countBlockDefs(); for (uint i = 0; i < count; i++) { const Block* def = indices->getBlockDef(i); blocks.put(def->name); } - json::JArray& items = root.putArray("items"); + auto& items = root.putList("items"); count = indices->countItemDefs(); for (uint i = 0; i < count; i++) { const ItemDef* def = indices->getItemDef(i); @@ -480,16 +482,16 @@ void WorldFiles::writeIndices(const ContentIndices* indices) { } void WorldFiles::writeWorldInfo(const World* world) { - json::JObject root; + dynamic::Map root; - json::JObject& versionobj = root.putObj("version"); + auto& versionobj = root.putMap("version"); versionobj.put("major", ENGINE_VERSION_MAJOR); versionobj.put("minor", ENGINE_VERSION_MINOR); root.put("name", world->name); root.put("seed", world->seed); - json::JObject& timeobj = root.putObj("time"); + auto& timeobj = root.putMap("time"); timeobj.put("day-time", world->daytime); timeobj.put("day-time-speed", world->daytimeSpeed); @@ -503,11 +505,11 @@ bool WorldFiles::readWorldInfo(World* world) { return false; } - std::unique_ptr root(files::read_json(file)); + auto root = files::read_json(file); root->str("name", world->name); root->num("seed", world->seed); - json::JObject* verobj = root->obj("version"); + auto verobj = root->map("version"); if (verobj) { int major=0, minor=-1; verobj->num("major", major); @@ -515,7 +517,7 @@ bool WorldFiles::readWorldInfo(World* world) { std::cout << "world version: " << major << "." << minor << std::endl; } - json::JObject* timeobj = root->obj("time"); + auto timeobj = root->map("time"); if (timeobj) { timeobj->num("day-time", world->daytime); timeobj->num("day-time-speed", world->daytimeSpeed); @@ -526,13 +528,13 @@ bool WorldFiles::readWorldInfo(World* world) { void WorldFiles::writePlayer(Player* player){ glm::vec3 position = player->hitbox->position; - json::JObject root; - json::JArray& posarr = root.putArray("position"); + dynamic::Map root; + auto& posarr = root.putList("position"); posarr.put(position.x); posarr.put(position.y); posarr.put(position.z); - json::JArray& rotarr = root.putArray("rotation"); + auto& rotarr = root.putList("rotation"); rotarr.put(player->cam.x); rotarr.put(player->cam.y); @@ -549,15 +551,15 @@ bool WorldFiles::readPlayer(Player* player) { return false; } - std::unique_ptr root(files::read_json(file)); - json::JArray* posarr = root->arr("position"); + auto root = files::read_json(file); + auto posarr = root->list("position"); glm::vec3& position = player->hitbox->position; position.x = posarr->num(0); position.y = posarr->num(1); position.z = posarr->num(2); player->camera->position = position; - json::JArray* rotarr = root->arr("rotation"); + auto rotarr = root->list("rotation"); player->cam.x = rotarr->num(0); player->cam.y = rotarr->num(1); diff --git a/src/files/WorldFiles.h b/src/files/WorldFiles.h index d85b0221..9f44f99c 100644 --- a/src/files/WorldFiles.h +++ b/src/files/WorldFiles.h @@ -34,6 +34,8 @@ class Content; class ContentIndices; class World; +namespace fs = std::filesystem; + class illegal_region_format : public std::runtime_error { public: illegal_region_format(const std::string& message) @@ -63,27 +65,24 @@ struct regfile { files::rafile file; int version; - regfile(std::filesystem::path filename); + regfile(fs::path filename); }; typedef std::unordered_map> regionsmap; + class WorldFiles { std::unordered_map> openRegFiles; void writeWorldInfo(const World* world); - std::filesystem::path getLightsFolder() const; - std::filesystem::path getRegionFilename(int x, int y) const; - std::filesystem::path getPlayerFile() const; - std::filesystem::path getWorldFile() const; - std::filesystem::path getIndicesFile() const; - std::filesystem::path getPacksFile() const; + fs::path getLightsFolder() const; + fs::path getRegionFilename(int x, int y) const; + fs::path getPlayerFile() const; + fs::path getWorldFile() const; + fs::path getIndicesFile() const; + fs::path getPacksFile() const; - WorldRegion* getRegion(regionsmap& regions, - int x, int z); - - WorldRegion* getOrCreateRegion( - regionsmap& regions, - int x, int z); + WorldRegion* getRegion(regionsmap& regions, int x, int z); + WorldRegion* getOrCreateRegion(regionsmap& regions, int x, int z); /* Compress buffer with extrle @param src source buffer @@ -94,38 +93,36 @@ class WorldFiles { /* Decompress buffer with extrle @param src compressed buffer @param srclen length of compressed buffer - @param dstlen max expected length of source buffer - */ + @param dstlen max expected length of source buffer */ ubyte* decompress(const ubyte* src, size_t srclen, size_t dstlen); ubyte* readChunkData(int x, int y, uint32_t& length, - std::filesystem::path folder, + fs::path folder, int layer); void fetchChunks(WorldRegion* region, int x, int y, - std::filesystem::path folder, int layer); + fs::path folder, int layer); void writeRegions(regionsmap& regions, - const std::filesystem::path& folder, int layer); + const fs::path& folder, int layer); ubyte* getData(regionsmap& regions, - const std::filesystem::path& folder, + const fs::path& folder, int x, int z, int layer); - regfile* getRegFile(glm::ivec3 coord, - const std::filesystem::path& folder); + regfile* getRegFile(glm::ivec3 coord, const fs::path& folder); public: static bool parseRegionFilename(const std::string& name, int& x, int& y); - std::filesystem::path getRegionsFolder() const; + fs::path getRegionsFolder() const; regionsmap regions; regionsmap lights; - std::filesystem::path directory; + fs::path directory; std::unique_ptr compressionBuffer; bool generatorTestMode; bool doWriteLights; - WorldFiles(std::filesystem::path directory, const DebugSettings& settings); + WorldFiles(fs::path directory, const DebugSettings& settings); ~WorldFiles(); void put(Chunk* chunk); @@ -142,7 +139,7 @@ public: void writeRegion(int x, int y, WorldRegion* entry, - std::filesystem::path file, + fs::path file, int layer); void writePlayer(Player* player); /* @param world world info to save (nullable) */ diff --git a/src/files/files.cpp b/src/files/files.cpp index d2161b6c..8f459dcc 100644 --- a/src/files/files.cpp +++ b/src/files/files.cpp @@ -7,6 +7,7 @@ #include #include "../coders/json.h" #include "../util/stringutil.h" +#include "../data/dynamic.h" namespace fs = std::filesystem; @@ -92,18 +93,18 @@ bool files::write_string(fs::path filename, const std::string content) { return true; } -bool files::write_json(fs::path filename, const json::JObject* obj, bool nice) { +bool files::write_json(fs::path filename, const dynamic::Map* obj, bool nice) { // -- binary json tests //return write_binary_json(fs::path(filename.u8string()+".bin"), obj); return files::write_string(filename, json::stringify(obj, nice, " ")); } -bool files::write_binary_json(fs::path filename, const json::JObject* obj) { +bool files::write_binary_json(fs::path filename, const dynamic::Map* obj) { std::vector bytes = json::to_binary(obj); return files::write_bytes(filename, (const char*)bytes.data(), bytes.size()); } -json::JObject* files::read_json(fs::path filename) { +std::unique_ptr files::read_json(fs::path filename) { // binary json tests // fs::path binfile = fs::path(filename.u8string()+".bin"); // if (fs::is_regular_file(binfile)){ @@ -121,10 +122,10 @@ json::JObject* files::read_json(fs::path filename) { } } -json::JObject* files::read_binary_json(fs::path file) { +std::unique_ptr files::read_binary_json(fs::path file) { size_t size; std::unique_ptr bytes (files::read_bytes(file, size)); - return json::from_binary((const ubyte*)bytes.get(), size); + return std::unique_ptr(json::from_binary((const ubyte*)bytes.get(), size)); } std::vector files::read_list(fs::path filename) { diff --git a/src/files/files.h b/src/files/files.h index 2ad4a879..4e136fa6 100644 --- a/src/files/files.h +++ b/src/files/files.h @@ -3,14 +3,15 @@ #include #include +#include #include #include #include "../typedefs.h" namespace fs = std::filesystem; -namespace json { - class JObject; +namespace dynamic { + class Map; } namespace files { @@ -30,14 +31,14 @@ namespace files { extern bool write_bytes(fs::path, const char* data, size_t size); extern uint append_bytes(fs::path, const char* data, size_t size); extern bool write_string(fs::path filename, const std::string content); - extern bool write_json(fs::path filename, const json::JObject* obj, bool nice=true); - extern bool write_binary_json(fs::path filename, const json::JObject* obj); + extern bool write_json(fs::path filename, const dynamic::Map* obj, bool nice=true); + extern bool write_binary_json(fs::path filename, const dynamic::Map* obj); extern bool read(fs::path, char* data, size_t size); extern char* read_bytes(fs::path, size_t& length); extern std::string read_string(fs::path filename); - extern json::JObject* read_json(fs::path file); - extern json::JObject* read_binary_json(fs::path file); + extern std::unique_ptr read_json(fs::path file); + extern std::unique_ptr read_binary_json(fs::path file); extern std::vector read_list(fs::path file); } diff --git a/src/files/settings_io.cpp b/src/files/settings_io.cpp index ed19b80f..037282d0 100644 --- a/src/files/settings_io.cpp +++ b/src/files/settings_io.cpp @@ -9,6 +9,8 @@ #include "../coders/toml.h" #include "../coders/json.h" +#include "../data/dynamic.h" + toml::Wrapper* create_wrapper(EngineSettings& settings) { std::unique_ptr wrapper (new toml::Wrapper()); toml::Section& display = wrapper->add("display"); @@ -46,28 +48,27 @@ toml::Wrapper* create_wrapper(EngineSettings& settings) { } std::string write_controls() { - json::JObject* obj = new json::JObject(); + dynamic::Map obj; for (auto& entry : Events::bindings) { const auto& binding = entry.second; - json::JObject* jentry = new json::JObject(); + auto& jentry = obj.putMap(entry.first); switch (binding.type) { - case inputtype::keyboard: jentry->put("type", "keyboard"); break; - case inputtype::mouse: jentry->put("type", "mouse"); break; + case inputtype::keyboard: jentry.put("type", "keyboard"); break; + case inputtype::mouse: jentry.put("type", "mouse"); break; default: throw std::runtime_error("unsupported control type"); } - jentry->put("code", binding.code); - obj->put(entry.first, jentry); + jentry.put("code", binding.code); } - return json::stringify(obj, true, " "); + return json::stringify(&obj, true, " "); } void load_controls(std::string filename, std::string source) { - json::JObject* obj = json::parse(filename, source); + auto obj = json::parse(filename, source); for (auto& entry : Events::bindings) { auto& binding = entry.second; - json::JObject* jentry = obj->obj(entry.first); + auto jentry = obj->map(entry.first); if (jentry == nullptr) continue; inputtype type; diff --git a/src/frontend/ContentGfxCache.cpp b/src/frontend/ContentGfxCache.cpp index 86c8541c..cb9a9ae0 100644 --- a/src/frontend/ContentGfxCache.cpp +++ b/src/frontend/ContentGfxCache.cpp @@ -8,12 +8,12 @@ #include "../voxels/Block.h" ContentGfxCache::ContentGfxCache(const Content* content, Assets* assets) { - const ContentIndices* contentIds = content->indices; - sideregions = new UVRegion[contentIds->countBlockDefs() * 6]; + auto indices = content->getIndices(); + sideregions = new UVRegion[indices->countBlockDefs() * 6]; Atlas* atlas = assets->getAtlas("blocks"); - for (uint i = 0; i < contentIds->countBlockDefs(); i++) { - Block* def = contentIds->getBlockDef(i); + for (uint i = 0; i < indices->countBlockDefs(); i++) { + Block* def = indices->getBlockDef(i); for (uint side = 0; side < 6; side++) { std::string tex = def->textureFaces[side]; if (atlas->has(tex)) { diff --git a/src/frontend/InventoryView.cpp b/src/frontend/InventoryView.cpp index 1c2d2f02..2b898c32 100644 --- a/src/frontend/InventoryView.cpp +++ b/src/frontend/InventoryView.cpp @@ -22,7 +22,7 @@ InventoryView::InventoryView( LevelFrontend* frontend, std::vector items) : content(content), - indices(content->indices), + indices(content->getIndices()), items(items), frontend(frontend), columns(columns) { diff --git a/src/frontend/WorldRenderer.cpp b/src/frontend/WorldRenderer.cpp index a322c10b..0e517951 100644 --- a/src/frontend/WorldRenderer.cpp +++ b/src/frontend/WorldRenderer.cpp @@ -132,7 +132,7 @@ void WorldRenderer::draw(const GfxContext& pctx, Camera* camera, bool hudVisible 1.0f+fog*2.0f, 4); const Content* content = level->content; - const ContentIndices* contentIds = content->indices; + auto indices = content->getIndices(); Assets* assets = engine->getAssets(); Atlas* atlas = assets->getAtlas("blocks"); Shader* shader = assets->getShader("main"); @@ -170,7 +170,7 @@ void WorldRenderer::draw(const GfxContext& pctx, Camera* camera, bool hudVisible shader->uniform1i("u_cubemap", 1); { itemid_t id = level->player->getChosenItem(); - ItemDef* item = contentIds->getItemDef(id); + ItemDef* item = indices->getItemDef(id); assert(item != nullptr); float multiplier = 0.5f; shader->uniform3f("u_torchlightColor", @@ -189,7 +189,7 @@ void WorldRenderer::draw(const GfxContext& pctx, Camera* camera, bool hudVisible // Selected block if (PlayerController::selectedBlockId != -1 && hudVisible){ blockid_t id = PlayerController::selectedBlockId; - Block* block = contentIds->getBlockDef(id); + Block* block = indices->getBlockDef(id); assert(block != nullptr); const vec3 pos = PlayerController::selectedBlockPosition; const vec3 point = PlayerController::selectedPointPosition; diff --git a/src/frontend/hud.cpp b/src/frontend/hud.cpp index 54612c0e..aa7fd378 100644 --- a/src/frontend/hud.cpp +++ b/src/frontend/hud.cpp @@ -82,7 +82,7 @@ void HudRenderer::createDebugPanel(Engine* engine) { })); panel->add(create_label([=](){ auto player = level->player; - auto indices = level->content->indices; + auto* indices = level->content->getIndices(); auto def = indices->getBlockDef(player->selectedVoxel.id); std::wstringstream stream; stream << std::hex << level->player->selectedVoxel.states; @@ -171,7 +171,7 @@ HudRenderer::HudRenderer(Engine* engine, LevelFrontend* frontend) auto level = frontend->getLevel(); auto menu = gui->getMenu(); auto content = level->content; - auto indices = content->indices; + auto indices = content->getIndices(); std::vector items; for (itemid_t id = 1; id < indices->countItemDefs(); id++) { diff --git a/src/frontend/locale/langs.cpp b/src/frontend/locale/langs.cpp index 66b4db75..0074816b 100644 --- a/src/frontend/locale/langs.cpp +++ b/src/frontend/locale/langs.cpp @@ -7,22 +7,17 @@ #include "../../content/ContentPack.h" #include "../../files/files.h" #include "../../util/stringutil.h" +#include "../../data/dynamic.h" -using std::string; -using std::wstring; -using std::vector; -using std::unique_ptr; -using std::unordered_map; -using std::filesystem::path; namespace fs = std::filesystem; -unique_ptr langs::current; -unordered_map langs::locales_info; +std::unique_ptr langs::current; +std::unordered_map langs::locales_info; -langs::Lang::Lang(string locale) : locale(locale) { +langs::Lang::Lang(std::string locale) : locale(locale) { } -const wstring& langs::Lang::get(const wstring& key) const { +const std::wstring& langs::Lang::get(const std::wstring& key) const { auto found = map.find(key); if (found == map.end()) { return key; @@ -30,11 +25,11 @@ const wstring& langs::Lang::get(const wstring& key) const { return found->second; } -void langs::Lang::put(const wstring& key, const wstring& text) { +void langs::Lang::put(const std::wstring& key, const std::wstring& text) { map[key] = text; } -const string& langs::Lang::getId() const { +const std::string& langs::Lang::getId() const { return locale; } @@ -50,16 +45,16 @@ class Reader : public BasicParser { } } public: - Reader(string file, string source) : BasicParser(file, source) { + Reader(std::string file, std::string source) : BasicParser(file, source) { } void read(langs::Lang& lang, std::string prefix) { skipWhitespace(); while (hasNext()) { - string key = parseString('=', true); + std::string key = parseString('=', true); util::trim(key); key = prefix + key; - string text = parseString('\n', false); + std::string text = parseString('\n', false); util::trim(text); lang.put(util::str2wstr_utf8(key), util::str2wstr_utf8(text)); @@ -68,22 +63,22 @@ public: } }; -void langs::loadLocalesInfo(const path& resdir, string& fallback) { - path file = resdir/path(langs::TEXTS_FOLDER)/path("langs.json"); - unique_ptr root (files::read_json(file)); +void langs::loadLocalesInfo(const fs::path& resdir, std::string& fallback) { + fs::path file = resdir/fs::path(langs::TEXTS_FOLDER)/fs::path("langs.json"); + auto root = files::read_json(file); langs::locales_info.clear(); root->str("fallback", fallback); - auto langs = root->obj("langs"); + auto langs = root->map("langs"); if (langs) { std::cout << "locales "; - for (auto& entry : langs->map) { - auto langInfo = entry.second; + for (auto& entry : langs->values) { + auto langInfo = entry.second.get(); - string name; - if (langInfo->type == json::valtype::object) { - name = langInfo->value.obj->getStr("name", "none"); + std::string name; + if (langInfo->type == dynamic::valtype::map) { + name = langInfo->value.map->getStr("name", "none"); } else { continue; } @@ -95,8 +90,8 @@ void langs::loadLocalesInfo(const path& resdir, string& fallback) { } } -std::string langs::locale_by_envlocale(const std::string& envlocale, const path& resdir){ - string fallback = FALLBACK_DEFAULT; +std::string langs::locale_by_envlocale(const std::string& envlocale, const fs::path& resdir){ + std::string fallback = FALLBACK_DEFAULT; if (locales_info.size() == 0) { loadLocalesInfo(resdir, fallback); } @@ -116,32 +111,33 @@ std::string langs::locale_by_envlocale(const std::string& envlocale, const path& } } -void langs::load(const path& resdir, - const string& locale, - const vector& packs, +void langs::load(const fs::path& resdir, + const std::string& locale, + const std::vector& packs, Lang& lang) { - path filename = path(TEXTS_FOLDER)/path(locale + LANG_FILE_EXT); - path core_file = resdir/filename; + fs::path filename = fs::path(TEXTS_FOLDER)/fs::path(locale + LANG_FILE_EXT); + fs::path core_file = resdir/filename; + if (fs::is_regular_file(core_file)) { - string text = files::read_string(core_file); + std::string text = files::read_string(core_file); Reader reader(core_file.string(), text); reader.read(lang, ""); } for (auto pack : packs) { - path file = pack.folder/filename; + fs::path file = pack.folder/filename; if (fs::is_regular_file(file)) { - string text = files::read_string(file); + std::string text = files::read_string(file); Reader reader(file.string(), text); reader.read(lang, pack.id+":"); } } } -void langs::load(const path& resdir, - const string& locale, - const string& fallback, - const vector& packs) { - unique_ptr lang (new Lang(locale)); +void langs::load(const fs::path& resdir, + const std::string& locale, + const std::string& fallback, + const std::vector& packs) { + auto lang = std::make_unique(locale); load(resdir, fallback, packs, *lang.get()); if (locale != fallback) { load(resdir, locale, packs, *lang.get()); @@ -149,10 +145,10 @@ void langs::load(const path& resdir, current.reset(lang.release()); } -void langs::setup(const path& resdir, - string locale, - const vector& packs) { - string fallback = langs::FALLBACK_DEFAULT; +void langs::setup(const fs::path& resdir, + std::string locale, + const std::vector& packs) { + std::string fallback = langs::FALLBACK_DEFAULT; langs::loadLocalesInfo(resdir, fallback); if (langs::locales_info.find(locale) == langs::locales_info.end()) { locale = fallback; @@ -160,13 +156,13 @@ void langs::setup(const path& resdir, langs::load(resdir, locale, fallback, packs); } -const wstring& langs::get(const wstring& key) { +const std::wstring& langs::get(const std::wstring& key) { return current->get(key); } -const wstring& langs::get(const wstring& key, const wstring& context) { - wstring ctxkey = context + L"." + key; - const wstring& text = current->get(ctxkey); +const std::wstring& langs::get(const std::wstring& key, const std::wstring& context) { + std::wstring ctxkey = context + L"." + key; + const std::wstring& text = current->get(ctxkey); if (&ctxkey != &text) { return text; } diff --git a/src/graphics/BlocksRenderer.cpp b/src/graphics/BlocksRenderer.cpp index 8c492a3b..ad8792bd 100644 --- a/src/graphics/BlocksRenderer.cpp +++ b/src/graphics/BlocksRenderer.cpp @@ -34,7 +34,7 @@ BlocksRenderer::BlocksRenderer(size_t capacity, vertexBuffer = new float[capacity]; indexBuffer = new int[capacity]; voxelsBuffer = new VoxelsVolume(CHUNK_W + 2, CHUNK_H, CHUNK_D + 2); - blockDefsCache = content->indices->getBlockDefs(); + blockDefsCache = content->getIndices()->getBlockDefs(); } BlocksRenderer::~BlocksRenderer() { @@ -44,9 +44,7 @@ BlocksRenderer::~BlocksRenderer() { } /* Basic vertex add method */ -void BlocksRenderer::vertex(const vec3& coord, - float u, float v, - const vec4& light) { +void BlocksRenderer::vertex(const vec3& coord, float u, float v, const vec4& light) { vertexBuffer[vertexOffset++] = coord.x; vertexBuffer[vertexOffset++] = coord.y; vertexBuffer[vertexOffset++] = coord.z; diff --git a/src/lighting/Lighting.cpp b/src/lighting/Lighting.cpp index 568bfe9f..25d1a551 100644 --- a/src/lighting/Lighting.cpp +++ b/src/lighting/Lighting.cpp @@ -15,11 +15,11 @@ using std::shared_ptr; Lighting::Lighting(const Content* content, Chunks* chunks) : content(content), chunks(chunks) { - const ContentIndices* contentIds = content->indices; - solverR = new LightSolver(contentIds, chunks, 0); - solverG = new LightSolver(contentIds, chunks, 1); - solverB = new LightSolver(contentIds, chunks, 2); - solverS = new LightSolver(contentIds, chunks, 3); + auto indices = content->getIndices(); + solverR = new LightSolver(indices, chunks, 0); + solverG = new LightSolver(indices, chunks, 1); + solverB = new LightSolver(indices, chunks, 2); + solverS = new LightSolver(indices, chunks, 3); } Lighting::~Lighting(){ @@ -42,7 +42,7 @@ void Lighting::clear(){ } void Lighting::prebuildSkyLight(int cx, int cz){ - const Block* const* blockDefs = content->indices->getBlockDefs(); + const Block* const* blockDefs = content->getIndices()->getBlockDefs(); Chunk* chunk = chunks->getChunk(cx, cz); int highestPoint = 0; @@ -68,7 +68,7 @@ void Lighting::prebuildSkyLight(int cx, int cz){ } void Lighting::buildSkyLight(int cx, int cz){ - const Block* const* blockDefs = content->indices->getBlockDefs(); + const Block* const* blockDefs = content->getIndices()->getBlockDefs(); Chunk* chunk = chunks->getChunk(cx, cz); for (int z = 0; z < CHUNK_D; z++){ @@ -95,7 +95,7 @@ void Lighting::buildSkyLight(int cx, int cz){ } void Lighting::onChunkLoaded(int cx, int cz){ - const Block* const* blockDefs = content->indices->getBlockDefs(); + const Block* const* blockDefs = content->getIndices()->getBlockDefs(); const Chunk* chunk = chunks->getChunk(cx, cz); for (unsigned int y = 0; y < CHUNK_H; y++){ @@ -137,7 +137,7 @@ void Lighting::onChunkLoaded(int cx, int cz){ } void Lighting::onBlockSet(int x, int y, int z, int const id){ - Block* block = content->indices->getBlockDef(id); + Block* block = content->getIndices()->getBlockDef(id); if (id == 0){ solverR->remove(x,y,z); solverG->remove(x,y,z); diff --git a/src/logic/BlocksController.cpp b/src/logic/BlocksController.cpp index a84b7fdf..ab308342 100644 --- a/src/logic/BlocksController.cpp +++ b/src/logic/BlocksController.cpp @@ -69,7 +69,7 @@ void BlocksController::updateBlock(int x, int y, int z) { voxel* vox = chunks->get(x, y, z); if (vox == nullptr) return; - const Block* def = level->content->indices->getBlockDef(vox->id); + const Block* def = level->content->getIndices()->getBlockDef(vox->id); if (def->grounded && !chunks->isSolidBlock(x, y-1, z)) { breakBlock(nullptr, def, x, y, z); return; @@ -89,7 +89,7 @@ void BlocksController::randomTick(int tickid, int parts) { // timeutil::ScopeLogTimer timer(5000+tickid); const int w = chunks->w; const int d = chunks->d; - auto indices = level->content->indices; + auto indices = level->content->getIndices(); for (uint z = padding; z < d-padding; z++){ for (uint x = padding; x < w-padding; x++){ int index = z * w + x; diff --git a/src/logic/PlayerController.cpp b/src/logic/PlayerController.cpp index 253f5bda..a0ef0f2f 100644 --- a/src/logic/PlayerController.cpp +++ b/src/logic/PlayerController.cpp @@ -204,7 +204,7 @@ void PlayerController::updateControls(float delta){ } void PlayerController::updateInteraction(){ - auto contentIds = level->content->indices; + auto indices = level->content->getIndices(); Chunks* chunks = level->chunks; Player* player = level->player; Lighting* lighting = level->lighting; @@ -239,8 +239,8 @@ void PlayerController::updateInteraction(){ int z = iend.z; uint8_t states = 0; - ItemDef* item = contentIds->getItemDef(player->getChosenItem()); - Block* def = contentIds->getBlockDef(item->rt.placingBlock); + ItemDef* item = indices->getItemDef(player->getChosenItem()); + Block* def = indices->getBlockDef(item->rt.placingBlock); if (def && def->rotatable){ const std::string& name = def->rotations.name; if (name == "pipe") { @@ -270,7 +270,7 @@ void PlayerController::updateInteraction(){ } } - Block* target = contentIds->getBlockDef(vox->id); + Block* target = indices->getBlockDef(vox->id); if (lclick && target->breakable){ blocksController->breakBlock(player, target, x, y, z); } @@ -292,7 +292,7 @@ void PlayerController::updateInteraction(){ } vox = chunks->get(x, y, z); blockid_t chosenBlock = def->rt.id; - if (vox && (target = contentIds->getBlockDef(vox->id))->replaceable) { + if (vox && (target = indices->getBlockDef(vox->id))->replaceable) { if (!level->physics->isBlockInside(x,y,z, player->hitbox.get()) || !def->obstacle){ if (def->grounded && !chunks->isSolidBlock(x, y-1, z)) { @@ -310,7 +310,7 @@ void PlayerController::updateInteraction(){ } } if (Events::jactive(BIND_PLAYER_PICK)){ - Block* block = contentIds->getBlockDef(chunks->get(x,y,z)->id); + Block* block = indices->getBlockDef(chunks->get(x,y,z)->id); player->setChosenItem(block->rt.pickingItem); } } else { diff --git a/src/logic/scripting/api_lua.cpp b/src/logic/scripting/api_lua.cpp index 26ade8a6..8403604c 100644 --- a/src/logic/scripting/api_lua.cpp +++ b/src/logic/scripting/api_lua.cpp @@ -107,7 +107,8 @@ static const luaL_Reg playerlib [] = { /* == blocks-related functions == */ static int l_block_name(lua_State* L) { int id = lua_tointeger(L, 1); - lua_pushstring(L, scripting::content->indices->getBlockDef(id)->name.c_str()); + auto def = scripting::content->getIndices()->getBlockDef(id); + lua_pushstring(L, def->name.c_str()); return 1; } @@ -121,7 +122,7 @@ static int l_is_solid_at(lua_State* L) { } static int l_blocks_count(lua_State* L) { - lua_pushinteger(L, scripting::content->indices->countBlockDefs()); + lua_pushinteger(L, scripting::content->getIndices()->countBlockDefs()); return 1; } @@ -163,7 +164,7 @@ static int l_get_block_x(lua_State* L) { if (vox == nullptr) { return lua_pushivec3(L, 1, 0, 0); } - const Block* def = scripting::level->content->indices->getBlockDef(vox->id); + auto def = scripting::level->content->getIndices()->getBlockDef(vox->id); if (!def->rotatable) { return lua_pushivec3(L, 1, 0, 0); } else { @@ -180,7 +181,7 @@ static int l_get_block_y(lua_State* L) { if (vox == nullptr) { return lua_pushivec3(L, 0, 1, 0); } - const Block* def = scripting::level->content->indices->getBlockDef(vox->id); + auto def = scripting::level->content->getIndices()->getBlockDef(vox->id); if (!def->rotatable) { return lua_pushivec3(L, 0, 1, 0); } else { @@ -197,7 +198,7 @@ static int l_get_block_z(lua_State* L) { if (vox == nullptr) { return lua_pushivec3(L, 0, 0, 1); } - const Block* def = scripting::level->content->indices->getBlockDef(vox->id); + auto def = scripting::level->content->getIndices()->getBlockDef(vox->id); if (!def->rotatable) { return lua_pushivec3(L, 0, 0, 1); } else { diff --git a/src/objects/Player.cpp b/src/objects/Player.cpp index d4af3bf8..d61b667a 100644 --- a/src/objects/Player.cpp +++ b/src/objects/Player.cpp @@ -26,9 +26,6 @@ Player::Player(glm::vec3 position, float speed) : hitbox(new Hitbox(position, glm::vec3(0.3f,0.9f,0.3f))) { } -Player::~Player(){ -} - void Player::update( Level* level, PlayerInput& input, diff --git a/src/objects/Player.h b/src/objects/Player.h index 14aa30a2..46f39aa6 100644 --- a/src/objects/Player.h +++ b/src/objects/Player.h @@ -43,7 +43,7 @@ public: glm::vec2 cam = {}; Player(glm::vec3 position, float speed); - ~Player(); + ~Player() = default; void teleport(glm::vec3 position); void update(Level* level, PlayerInput& input, float delta); diff --git a/src/typedefs.h b/src/typedefs.h index 02bd95fd..7a0fd0f0 100644 --- a/src/typedefs.h +++ b/src/typedefs.h @@ -13,6 +13,8 @@ typedef uint8_t ubyte; typedef uint32_t itemid_t; typedef uint16_t blockid_t; +typedef uint32_t itemcount_t; + typedef uint16_t blockstate_t; typedef uint16_t light_t; diff --git a/src/voxels/Chunk.h b/src/voxels/Chunk.h index 0803c8db..6a07ec5c 100644 --- a/src/voxels/Chunk.h +++ b/src/voxels/Chunk.h @@ -4,7 +4,7 @@ #include #include "../constants.h" -struct ChunkFlag{ +struct ChunkFlag { static const int MODIFIED = 0x1; static const int READY = 0x2; static const int LOADED = 0x4; @@ -37,7 +37,6 @@ public: Chunk* clone() const; // flags getters/setters below - inline void setFlags(int mask, bool value){ if (value) flags |= mask; diff --git a/src/voxels/Chunks.cpp b/src/voxels/Chunks.cpp index d774583b..7fb00c6e 100644 --- a/src/voxels/Chunks.cpp +++ b/src/voxels/Chunks.cpp @@ -22,7 +22,7 @@ Chunks::Chunks(int w, int d, LevelEvents* events, const Content* content) : content(content), - contentIds(content->indices), + contentIds(content->getIndices()), chunks(w*d), chunksSecond(w*d), w(w), d(d), ox(ox), oz(oz), @@ -32,9 +32,6 @@ Chunks::Chunks(int w, int d, chunksCount = 0; } -Chunks::~Chunks(){ -} - voxel* Chunks::get(int x, int y, int z){ x -= ox * CHUNK_W; z -= oz * CHUNK_D; diff --git a/src/voxels/Chunks.h b/src/voxels/Chunks.h index 06bfb122..dcecd347 100644 --- a/src/voxels/Chunks.h +++ b/src/voxels/Chunks.h @@ -34,7 +34,7 @@ public: Chunks(int w, int d, int ox, int oz, WorldFiles* worldFiles, LevelEvents* events, const Content* content); - ~Chunks(); + ~Chunks() = default; bool putChunk(std::shared_ptr chunk); diff --git a/src/voxels/ChunksStorage.cpp b/src/voxels/ChunksStorage.cpp index 18c4988c..38f4808a 100644 --- a/src/voxels/ChunksStorage.cpp +++ b/src/voxels/ChunksStorage.cpp @@ -17,9 +17,6 @@ ChunksStorage::ChunksStorage(Level* level) : level(level) { } -ChunksStorage::~ChunksStorage() { -} - void ChunksStorage::store(std::shared_ptr chunk) { chunksMap[glm::ivec2(chunk->x, chunk->z)] = chunk; } @@ -61,7 +58,7 @@ std::shared_ptr ChunksStorage::create(int x, int z) { if (data) { chunk->decode(data.get()); chunk->setLoaded(true); - verifyLoadedChunk(level->content->indices, chunk.get()); + verifyLoadedChunk(level->content->getIndices(), chunk.get()); } light_t* lights = wfile->getLights(chunk->x, chunk->z); @@ -75,7 +72,7 @@ std::shared_ptr ChunksStorage::create(int x, int z) { // some magic code void ChunksStorage::getVoxels(VoxelsVolume* volume, bool backlight) const { const Content* content = level->content; - const ContentIndices* indices = content->indices; + auto indices = content->getIndices(); voxel* voxels = volume->getVoxels(); light_t* lights = volume->getLights(); int x = volume->getX(); @@ -115,7 +112,7 @@ void ChunksStorage::getVoxels(VoxelsVolume* volume, bool backlight) const { } } } else { - const std::shared_ptr& chunk = found->second; + auto& chunk = found->second; const voxel* cvoxels = chunk->voxels; const light_t* clights = chunk->lightmap->getLights(); for (int ly = y; ly < y + h; ly++) { diff --git a/src/voxels/ChunksStorage.h b/src/voxels/ChunksStorage.h index e6549c5a..ad5b0093 100644 --- a/src/voxels/ChunksStorage.h +++ b/src/voxels/ChunksStorage.h @@ -18,7 +18,7 @@ class ChunksStorage { std::unordered_map> chunksMap; public: ChunksStorage(Level* level); - virtual ~ChunksStorage(); + ~ChunksStorage() = default; std::shared_ptr get(int x, int z) const; void store(std::shared_ptr chunk);