#pragma once
#include <cstddef>
#include <vector>
#include <fstream>
#include <zlib.h>
#include <Utility.hpp>
namespace nbt {
enum TagType {
End, //nullptr
Byte, //int8_t
Short, //int16_t
Int, //int32_t
Long, //int64_t
Float, //float
Double, //double
ByteArray, //std::vector<signed char>
String, //std::string
List, //std::vector<NbtTag>
Compound, //std::vector<NbtTag>
IntArray, //std::vector<int32_t>
Unknown, //dummy value
};
class NbtTag;
typedef std::vector<NbtTag> compound_t;
typedef std::string string_t;
typedef std::vector<signed char> byteArray_t;
typedef std::vector<int> intArray_t;
class NbtTag {
TagType type = Unknown;
string_t name = "";
unsigned char *data = nullptr;
public:
NbtTag(TagType type, string_t name) : type(type), name(name) {
switch (type) {
case End:
data = nullptr;
break;
case Compound:
data = (unsigned char *) new compound_t;
break;
case String:
data = (unsigned char *) new string_t;
break;
case Int:
data = (unsigned char *) new int32_t;
break;
case Long:
data = (unsigned char *) new int64_t;
break;
case Byte:
data = (unsigned char *) new int8_t;
break;
case Short:
data = (unsigned char *) new int16_t;
break;
case Float:
data = (unsigned char *) new float;
break;
case Double:
data = (unsigned char *) new double;
break;
case ByteArray:
data = (unsigned char *) new byteArray_t;
break;
case List:
data = (unsigned char *) new compound_t;
break;
case IntArray:
data = (unsigned char *) new intArray_t;
}
}
NbtTag(const NbtTag &other) : type(other.type), name(other.name) {
switch (type) {
case Byte:
data = (unsigned char *) new int8_t;
*((int8_t *) data) = *((int8_t *) other.data);
break;
case Short:
data = (unsigned char *) new int16_t;
*((int16_t *) data) = *((int16_t *) other.data);
break;
case Int:
data = (unsigned char *) new int32_t;
*((int32_t *) data) = *((int32_t *) other.data);
break;
case Long:
data = (unsigned char *) new int64_t;
*((int64_t *) data) = *((int64_t *) other.data);
break;
case Float:
data = (unsigned char *) new float;
*((float *) data) = *((float *) other.data);
break;
case Double:
data = (unsigned char *) new double;
*((double *) data) = *((double *) other.data);
break;
case ByteArray:
data = (unsigned char *) new byteArray_t;
*((std::vector<signed char> *) data) = *((std::vector<signed char> *) other.data);
break;
case String:
data = (unsigned char *) new string_t;
*((std::string *) data) = *((std::string *) other.data);
break;
case List:
data = (unsigned char *) new compound_t;
*((std::vector<NbtTag> *) data) = *((std::vector<NbtTag> *) other.data);
break;
case Compound:
data = (unsigned char *) new compound_t;
*((std::vector<NbtTag> *) data) = *((std::vector<NbtTag> *) other.data);
break;
case IntArray:
data = (unsigned char *) new intArray_t;
*((std::vector<int> *) data) = *((std::vector<int> *) other.data);
break;
}
}
~NbtTag() {
switch (type) {
case Byte:
delete ((int8_t *) data);
break;
case Short:
delete ((int16_t *) data);
break;
case Int:
delete ((int32_t *) data);
break;
case Long:
delete ((int64_t *) data);
break;
case Float:
delete ((float *) data);
break;
case Double:
delete ((double *) data);
break;
case ByteArray:
delete ((std::vector<signed char> *) data);
break;
case String:
delete ((std::string *) data);
break;
case List:
delete ((std::vector<NbtTag> *) data);
break;
case Compound:
delete ((std::vector<NbtTag> *) data);
break;
case IntArray:
delete ((std::vector<int> *) data);
break;
}
};
void swap(NbtTag &other) {
std::swap(other.data, data);
std::swap(other.name, name);
std::swap(other.type, type);
}
NbtTag &operator=(NbtTag other) {
other.swap(*this);
return *this;
}
TagType GetType() const {
return type;
}
string_t GetName() const {
return name;
}
string_t &GetString() {
string_t &val = *reinterpret_cast<std::string *>(data);
return val;
}
compound_t &GetCompound() {
std::vector<NbtTag> &val = *reinterpret_cast<std::vector<NbtTag> *>(data);
return val;
}
compound_t &GetList() {
std::vector<NbtTag> &val = *reinterpret_cast<std::vector<NbtTag> *>(data);
return val;
}
int64_t &GetLong() {
int64_t &val = *reinterpret_cast<int64_t *>(data);
return val;
}
float &GetFloat() {
float &val = *reinterpret_cast<float *>(data);
return val;
}
double &GetDouble() {
double &val = *reinterpret_cast<double *>(data);
return val;
}
byteArray_t &GetByteArray() {
auto &val = *reinterpret_cast<byteArray_t *>(data);
return val;
}
intArray_t &GetIntArray() {
auto &val = *reinterpret_cast<intArray_t *>(data);
return val;
}
int16_t &GetShort() {
auto &val = *reinterpret_cast<int16_t *>(data);
return val;
}
int32_t &GetInt() {
auto &val = *reinterpret_cast<int32_t *>(data);
return val;
}
int8_t &GetByte() {
auto &val = *reinterpret_cast<int8_t *>(data);
return val;
}
};
NbtTag ParseTag(unsigned char *data, size_t &size, TagType listItemType = Unknown) {
size = 0;
TagType type;
if (listItemType == Unknown) {
type = (TagType) *data;
data += 1;
size += 1;
} else
type = listItemType;
string_t name;
if (listItemType == Unknown && type != End) {
short nameLen = *((short *) data);
data += 2;
size += 2;
endswap(&nameLen);
name = std::string((char *) data, nameLen);
data += nameLen;
size += nameLen;
}
NbtTag tag(type, name);
switch (type) {
case Compound: {
do {
size_t s;
tag.GetCompound().push_back(ParseTag(data, s));
data += s;
size += s;
} while (tag.GetCompound().back().GetType() != End);
tag.GetCompound().pop_back();
return tag;
}
case String: {
short len = *((short *) data);
data += 2;
size += 2;
endswap(&len);
string_t str((char *) data, len);
data += len;
size += len;
tag.GetString() = str;
return tag;
}
case End:
return tag;
case Long:
tag.GetLong() = *((int64_t *) data);
endswap(&tag.GetLong());
data += 8;
size += 8;
return tag;
case Short:
tag.GetShort() = *((int16_t *) data);
endswap(&tag.GetShort());
data += 2;
size += 2;
return tag;
case Float:
tag.GetFloat() = *((float *) data);
endswap(&tag.GetFloat());
data += 4;
size += 4;
return tag;
case Double:
tag.GetDouble() = *((double *) data);
endswap(&tag.GetDouble());
data += 8;
size += 8;
return tag;
case Byte:
tag.GetByte() = *((int8_t *) data);
endswap(&tag.GetByte());
data += 1;
size += 1;
return tag;
case Int:
tag.GetInt() = *((int32_t *) data);
endswap(&tag.GetInt());
data += 4;
size += 4;
return tag;
case List: {
TagType listType = *((TagType *) data);
data += 1;
size += 1;
int32_t listLength = *((int32_t *) data);
endswap(&listLength);
data += 4;
size += 4;
for (int i = 0; i < listLength; i++) {
size_t s = 0;
std::vector<NbtTag> &vec = tag.GetCompound();
vec.push_back(ParseTag(data, s, listType));
data += s;
size += s;
}
return tag;
}
case ByteArray: {
int32_t arrLength = *((int32_t *) data);
endswap(&arrLength);
data += 4;
size += 4;
for (int i = 0; i < arrLength; i++) {
signed char val = (signed char) data[i];
std::vector<signed char> &vec = tag.GetByteArray();
vec.push_back(val);
}
data += arrLength;
size += arrLength;
return tag;
}
default:
throw 13;
}
}
NbtTag ParseTag(unsigned char *data, size_t *optionalSize = nullptr) {
size_t s = 0;
size_t &size = (optionalSize ? *optionalSize : s);
return ParseTag(data, size);
}
std::vector<unsigned char> Decompress(unsigned char *data, size_t dataLen) {
const size_t decompBuffSize = 1024 * 16;
unsigned char *decompBuff = new unsigned char[decompBuffSize];
std::vector<unsigned char> uncompressed;
for (int i = 0; i < decompBuffSize; i++)
decompBuff[i] = 0;
z_stream stream;
stream.zalloc = Z_NULL;
stream.zfree = Z_NULL;
stream.opaque = Z_NULL;
stream.next_in = data;
stream.avail_in = dataLen;
stream.next_out = decompBuff;
stream.avail_out = decompBuffSize;
if (inflateInit2(&stream, 15 + 32) != Z_OK) {
delete[] decompBuff;
throw 171;
}
int res;
do {
stream.avail_out = decompBuffSize;
switch ((res = inflate(&stream, Z_NO_FLUSH))) {
case Z_MEM_ERROR:
throw 172;
case Z_DATA_ERROR:
throw 173;
case Z_NEED_DICT:
throw 174;
}
uncompressed.resize(uncompressed.size() + decompBuffSize);
std::copy(decompBuff, decompBuff + decompBuffSize, uncompressed.end() - decompBuffSize);
} while (stream.avail_out == 0);
if (res != Z_STREAM_END)
throw 175;
if (inflateEnd(&stream) != Z_OK)
throw 176;
delete[] decompBuff;
return uncompressed;
}
NbtTag ParseCompressed(unsigned char *data, size_t dataLen) {
auto uncompressed = Decompress(data, dataLen);
NbtTag root = ParseTag(uncompressed.data());
return root;
}
NbtTag Parse(unsigned char *data, size_t dataLen) {
bool isCompressed = *data != 10;
if (isCompressed)
return ParseCompressed(data, dataLen);
else
return ParseTag(data);
}
void PrintTree(NbtTag &tree, int deepness = 0, std::ostream &ostream = std::cout) {
ostream << std::string(deepness, '\t') << "Tag ";
switch (tree.GetType()) {
case Byte:
ostream << "byte";
break;
case Short:
ostream << "short";
break;
case Int:
ostream << "int";
break;
case Long:
ostream << "long";
break;
case Float:
ostream << "float";
break;
case Double:
ostream << "double";
break;
case ByteArray:
ostream << "byte array";
break;
case String:
ostream << "string";
break;
case List:
ostream << "list";
break;
case Compound:
ostream << "compound";
break;
case IntArray:
ostream << "int array";
break;
case End:
ostream << "end";
break;
}
if (tree.GetName().length() > 0)
ostream << " (" << tree.GetName() << ")";
ostream << ": ";
if (tree.GetType() == Compound || tree.GetType() == List) {
std::vector<NbtTag> &vec = (tree.GetType() == Compound ? tree.GetCompound() : tree.GetList());
ostream << vec.size() << " entries {" << std::endl;
for (auto it = vec.begin(); it != vec.end(); ++it) {
PrintTree(*it, deepness + 1, std::cout);
}
ostream << std::string(deepness, '\t') << "}" << std::endl;
return;
} else {
switch (tree.GetType()) {
case Int:
ostream << tree.GetInt();
break;
case String:
ostream << "\"" << tree.GetString() << "\"";
break;
case Double:
ostream << tree.GetDouble();
break;
case Float:
ostream << tree.GetFloat();
break;
case Short:
ostream << tree.GetShort();
break;
case Byte:
ostream << (int) tree.GetByte();
break;
case Long:
ostream << tree.GetLong();
break;
case ByteArray:
ostream << "[" << tree.GetByteArray().size() << " bytes]: ";
for (int i = 0; i < (tree.GetByteArray().size() > 10 ? 10 : tree.GetByteArray().size()); i++) {
ostream << std::hex << "0x" << (tree.GetByteArray()[i] > 15 ? "" : "0")
<< (int) tree.GetByteArray()[i]
<< std::dec << " ";
}
break;
case IntArray:
break;
}
ostream << std::endl;
}
}
}
