1 files changed, 516 insertions, 0 deletions

diff --git a/include/Nbt.hpp b/include/Nbt.hpp
new file mode 100644
index 0000000..03f5af0
--- /dev/null
+++ b/include/Nbt.hpp
@@ -0,0 +1,516 @@
+#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;
+		}
+	}
+}
\ No newline at end of file