WIP

.github/workflows/build-and-test.yml

@@ -36,16 +36,22 @@ jobs:
         testPreset: "ci-${{matrix.os}}"
     - name: artifacts
       uses: actions/upload-artifact@v3
+      if: ${{ github.ref == 'ref/head/main' }}
       with:
         name: build-${{matrix.os}}
         path: |
-          build/*Server*
-          build/*.ini
-          build/*.so
-          build/*.dll
-          build/vanity/
-          build/navmeshes/
-          build/migrations/
-          build/*.dcf
-          !build/*.pdb
-          !build/d*/
+          build
+          !build/tests
+          !build/Testing
+          !build/CMakeFiles
+          !build/DartConfiguration.tcl
+          !build/CTestTestfile.cmake
+          !build/CMakeCache.txt
+          !build/build.ninja
+          !build/_deps
+          !build/cmake_install.cmake
+          !build/*.a
+          !build/*.lib
+          !build/*.dir
+          !build/*.vcxproj
+          !build/*.vcxproj.filters

CMakeLists.txt

@@ -97,56 +97,15 @@ make_directory(${CMAKE_BINARY_DIR}/logs)
 
 # Copy resource files on first build
 set(RESOURCE_FILES "sharedconfig.ini" "authconfig.ini" "chatconfig.ini" "worldconfig.ini" "masterconfig.ini" "blacklist.dcf")
-message(STATUS "Checking resource file integrity")
-foreach (resource_file ${RESOURCE_FILES})
-	set(file_size 0)
-	if (EXISTS ${PROJECT_BINARY_DIR}/${resource_file})
-		file(SIZE ${PROJECT_BINARY_DIR}/${resource_file} file_size)
-	endif()
-	if (${file_size} EQUAL 0)
+foreach(resource_file ${RESOURCE_FILES})
+	if (NOT EXISTS ${PROJECT_BINARY_DIR}/${resource_file})
 		configure_file(
 			${CMAKE_SOURCE_DIR}/resources/${resource_file} ${PROJECT_BINARY_DIR}/${resource_file}
 			COPYONLY
 		)
-		message(STATUS "Moved " ${resource_file} " to project binary directory")
-	elseif (resource_file MATCHES ".ini")
-		message(STATUS "Checking " ${resource_file} " for missing config options")
-		file(READ ${PROJECT_BINARY_DIR}/${resource_file} current_file_contents)
-		string(REPLACE "\\\n" "" current_file_contents ${current_file_contents})
-		string(REPLACE "\n" ";" current_file_contents ${current_file_contents})
-		set(parsed_current_file_contents "")
-		# Remove comment lines so they do not interfere with the variable parsing
-		foreach (line ${current_file_contents})
-			string(FIND ${line} "#" is_comment)
-			if (NOT ${is_comment} EQUAL 0)
-				string(APPEND parsed_current_file_contents ${line})
-			endif()
-		endforeach()
-		file(READ ${CMAKE_SOURCE_DIR}/resources/${resource_file} depot_file_contents)
-		string(REPLACE "\\\n" "" depot_file_contents ${depot_file_contents})
-		string(REPLACE "\n" ";" depot_file_contents ${depot_file_contents})
-		set(line_to_add "")
-		foreach (line ${depot_file_contents})
-			string(FIND ${line} "#" is_comment)
-			if (NOT ${is_comment} EQUAL 0)
-				string(REPLACE "=" ";" line_split ${line})
-				list(GET line_split 0 variable_name)
-				if (NOT ${parsed_current_file_contents} MATCHES ${variable_name})
-					message(STATUS "Adding missing config option " ${variable_name} " to " ${resource_file})
-					set(line_to_add ${line_to_add} ${line})
-					foreach (line_to_append ${line_to_add})
-						file(APPEND ${PROJECT_BINARY_DIR}/${resource_file} "\n" ${line_to_append})
-					endforeach()
-					file(APPEND ${PROJECT_BINARY_DIR}/${resource_file} "\n")
-				endif()
-				set(line_to_add "")
-			else()
-				set(line_to_add ${line_to_add} ${line})
-			endif()
-		endforeach()
+		message("Moved ${resource_file} to project binary directory")
 	endif()
 endforeach()
-message(STATUS "Resource file integrity check complete")
 
 # Copy navmesh data on first build and extract it
 if (NOT EXISTS ${PROJECT_BINARY_DIR}/navmeshes/)

CMakeVariables.txt

@@ -1,6 +1,6 @@
 PROJECT_VERSION_MAJOR=1
-PROJECT_VERSION_MINOR=1
-PROJECT_VERSION_PATCH=0
+PROJECT_VERSION_MINOR=0
+PROJECT_VERSION_PATCH=4
 # LICENSE
 LICENSE=AGPL-3.0
 # The network version.

README.md

@@ -338,7 +338,7 @@ This is a Work in Progress, but below are some quick links to documentaion for s
 ## Former Contributors
 * TheMachine
 * Matthew
-* [Raine](https://github.com/uwainium)
+* [Raine](https://github.com/Rainebannister)
 * Bricknave
 
 ## Special Thanks

dAuthServer/AuthServer.cpp

@@ -29,7 +29,6 @@ namespace Game {
 	dServer* server = nullptr;
 	dConfig* config = nullptr;
 	bool shouldShutdown = false;
-	std::mt19937 randomEngine;
 }
 
 dLogger* SetupLogger();
@@ -84,8 +83,6 @@ int main(int argc, char** argv) {
 	delete res;
 	delete stmt;
 
-	Game::randomEngine = std::mt19937(time(0));
-
 	//It's safe to pass 'localhost' here, as the IP is only used as the external IP.
 	uint32_t maxClients = 50;
 	uint32_t ourPort = 1001; //LU client is hardcoded to use this for auth port, so I'm making it the default.

dCommon/AMFDeserialize.cpp

@@ -1,79 +1,77 @@
 #include "AMFDeserialize.h"
 
-#include <stdexcept>
-
-#include "Amf3.h"
+#include "AMFFormat.h"
 
 /**
  * AMF3 Reference document https://rtmp.veriskope.com/pdf/amf3-file-format-spec.pdf
  * AMF3 Deserializer written by EmosewaMC
  */
 
-AMFBaseValue* AMFDeserialize::Read(RakNet::BitStream* inStream) {
+AMFValue* AMFDeserialize::Read(RakNet::BitStream* inStream) {
 	if (!inStream) return nullptr;
-	AMFBaseValue* returnValue = nullptr;
+	AMFValue* returnValue = nullptr;
 	// Read in the value type from the bitStream
-	eAmf marker;
+	int8_t marker;
 	inStream->Read(marker);
 	// Based on the typing, create the value associated with that and return the base value class
 	switch (marker) {
-	case eAmf::Undefined: {
-		returnValue = new AMFBaseValue();
+	case AMFValueType::AMFUndefined: {
+		returnValue = new AMFUndefinedValue();
 		break;
 	}
 
-	case eAmf::Null: {
+	case AMFValueType::AMFNull: {
 		returnValue = new AMFNullValue();
 		break;
 	}
 
-	case eAmf::False: {
-		returnValue = new AMFBoolValue(false);
+	case AMFValueType::AMFFalse: {
+		returnValue = new AMFFalseValue();
 		break;
 	}
 
-	case eAmf::True: {
-		returnValue = new AMFBoolValue(true);
+	case AMFValueType::AMFTrue: {
+		returnValue = new AMFTrueValue();
 		break;
 	}
 
-	case eAmf::Integer: {
+	case AMFValueType::AMFInteger: {
 		returnValue = ReadAmfInteger(inStream);
 		break;
 	}
 
-	case eAmf::Double: {
+	case AMFValueType::AMFDouble: {
 		returnValue = ReadAmfDouble(inStream);
 		break;
 	}
 
-	case eAmf::String: {
+	case AMFValueType::AMFString: {
 		returnValue = ReadAmfString(inStream);
 		break;
 	}
 
-	case eAmf::Array: {
+	case AMFValueType::AMFArray: {
 		returnValue = ReadAmfArray(inStream);
 		break;
 	}
 
-	// These values are unimplemented in the live client and will remain unimplemented
-	// unless someone modifies the client to allow serializing of these values.
-	case eAmf::XMLDoc:
-	case eAmf::Date:
-	case eAmf::Object:
-	case eAmf::XML:
-	case eAmf::ByteArray:
-	case eAmf::VectorInt:
-	case eAmf::VectorUInt:
-	case eAmf::VectorDouble:
-	case eAmf::VectorObject:
-	case eAmf::Dictionary: {
-		throw marker;
+							   // TODO We do not need these values, but if someone wants to implement them
+							   // then please do so and add the corresponding unit tests.
+	case AMFValueType::AMFXMLDoc:
+	case AMFValueType::AMFDate:
+	case AMFValueType::AMFObject:
+	case AMFValueType::AMFXML:
+	case AMFValueType::AMFByteArray:
+	case AMFValueType::AMFVectorInt:
+	case AMFValueType::AMFVectorUInt:
+	case AMFValueType::AMFVectorDouble:
+	case AMFValueType::AMFVectorObject:
+	case AMFValueType::AMFDictionary: {
+		throw static_cast<AMFValueType>(marker);
 		break;
 	}
 	default:
-		throw std::invalid_argument("Invalid AMF3 marker" + std::to_string(static_cast<int32_t>(marker)));
+		throw static_cast<AMFValueType>(marker);
 		break;
 	}
 	return returnValue;
@@ -101,7 +99,7 @@ uint32_t AMFDeserialize::ReadU29(RakNet::BitStream* inStream) {
 	return actualNumber;
 }
 
-const std::string AMFDeserialize::ReadString(RakNet::BitStream* inStream) {
+std::string AMFDeserialize::ReadString(RakNet::BitStream* inStream) {
 	auto length = ReadU29(inStream);
 	// Check if this is a reference
 	bool isReference = length % 2 == 1;
@@ -115,39 +113,48 @@ const std::string AMFDeserialize::ReadString(RakNet::BitStream* inStream) {
 		return value;
 	} else {
 		// Length is a reference to a previous index - use that as the read in value
-		return accessedElements.at(length);
+		return accessedElements[length];
 	}
 }
 
-AMFBaseValue* AMFDeserialize::ReadAmfDouble(RakNet::BitStream* inStream) {
+AMFValue* AMFDeserialize::ReadAmfDouble(RakNet::BitStream* inStream) {
+	auto doubleValue = new AMFDoubleValue();
 	double value;
 	inStream->Read<double>(value);
-	return new AMFDoubleValue(value);
+	doubleValue->SetDoubleValue(value);
+	return doubleValue;
 }
 
-AMFBaseValue* AMFDeserialize::ReadAmfArray(RakNet::BitStream* inStream) {
+AMFValue* AMFDeserialize::ReadAmfArray(RakNet::BitStream* inStream) {
 	auto arrayValue = new AMFArrayValue();
 
 	// Read size of dense array
 	auto sizeOfDenseArray = (ReadU29(inStream) >> 1);
-	// Then read associative portion
+
+	// Then read Key'd portion
 	while (true) {
 		auto key = ReadString(inStream);
-		// No more associative values when we encounter an empty string key
+		// No more values when we encounter an empty string
 		if (key.size() == 0) break;
-		arrayValue->Insert(key, Read(inStream));
+		arrayValue->InsertValue(key, Read(inStream));
 	}
+
 	// Finally read dense portion
 	for (uint32_t i = 0; i < sizeOfDenseArray; i++) {
-		arrayValue->Insert(i, Read(inStream));
+		arrayValue->PushBackValue(Read(inStream));
 	}
+
 	return arrayValue;
 }
 
-AMFBaseValue* AMFDeserialize::ReadAmfString(RakNet::BitStream* inStream) {
-	return new AMFStringValue(ReadString(inStream));
+AMFValue* AMFDeserialize::ReadAmfString(RakNet::BitStream* inStream) {
+	auto stringValue = new AMFStringValue();
+	stringValue->SetStringValue(ReadString(inStream));
+	return stringValue;
 }
 
-AMFBaseValue* AMFDeserialize::ReadAmfInteger(RakNet::BitStream* inStream) {
-	return new AMFIntValue(ReadU29(inStream));
+AMFValue* AMFDeserialize::ReadAmfInteger(RakNet::BitStream* inStream) {
+	auto integerValue = new AMFIntegerValue();
+	integerValue->SetIntegerValue(ReadU29(inStream));
+	return integerValue;
 }

dCommon/AMFDeserialize.h

@@ -5,8 +5,7 @@
 #include <vector>
 #include <string>
 
-class AMFBaseValue;
-
+class AMFValue;
 class AMFDeserialize {
 public:
 	/**
@@ -15,7 +14,7 @@ public:
 	 * @param inStream inStream to read value from.
 	 * @return Returns an AMFValue with all the information from the bitStream in it.
 	 */
-	AMFBaseValue* Read(RakNet::BitStream* inStream);
+	AMFValue* Read(RakNet::BitStream* inStream);
 private:
 	/**
 	 * @brief Private method to read a U29 integer from a bitstream
@@ -31,7 +30,7 @@ private:
 	 * @param inStream bitStream to read data from
 	 * @return The read string
 	 */
-	const std::string ReadString(RakNet::BitStream* inStream);
+	std::string ReadString(RakNet::BitStream* inStream);
 
 	/**
 	 * @brief Read an AMFDouble value from a bitStream
@@ -39,7 +38,7 @@ private:
 	 * @param inStream bitStream to read data from
 	 * @return Double value represented as an AMFValue
 	 */
-	AMFBaseValue* ReadAmfDouble(RakNet::BitStream* inStream);
+	AMFValue* ReadAmfDouble(RakNet::BitStream* inStream);
 
 	/**
 	 * @brief Read an AMFArray from a bitStream
@@ -47,7 +46,7 @@ private:
 	 * @param inStream bitStream to read data from
 	 * @return Array value represented as an AMFValue
 	 */
-	AMFBaseValue* ReadAmfArray(RakNet::BitStream* inStream);
+	AMFValue* ReadAmfArray(RakNet::BitStream* inStream);
 
 	/**
 	 * @brief Read an AMFString from a bitStream
@@ -55,7 +54,7 @@ private:
 	 * @param inStream bitStream to read data from
 	 * @return String value represented as an AMFValue
 	 */
-	AMFBaseValue* ReadAmfString(RakNet::BitStream* inStream);
+	AMFValue* ReadAmfString(RakNet::BitStream* inStream);
 
 	/**
 	 * @brief Read an AMFInteger from a bitStream
@@ -63,7 +62,7 @@ private:
 	 * @param inStream bitStream to read data from
 	 * @return Integer value represented as an AMFValue
 	 */
-	AMFBaseValue* ReadAmfInteger(RakNet::BitStream* inStream);
+	AMFValue* ReadAmfInteger(RakNet::BitStream* inStream);
 
 	/**
 	 * List of strings read so far saved to be read by reference.

dCommon/AMFFormat.cpp

@@ -0,0 +1,156 @@
+#include "AMFFormat.h"
+
+// AMFInteger
+void AMFIntegerValue::SetIntegerValue(uint32_t value) {
+	this->value = value;
+}
+
+uint32_t AMFIntegerValue::GetIntegerValue() {
+	return this->value;
+}
+
+// AMFDouble
+void AMFDoubleValue::SetDoubleValue(double value) {
+	this->value = value;
+}
+
+double AMFDoubleValue::GetDoubleValue() {
+	return this->value;
+}
+
+// AMFString
+void AMFStringValue::SetStringValue(const std::string& value) {
+	this->value = value;
+}
+
+std::string AMFStringValue::GetStringValue() {
+	return this->value;
+}
+
+// AMFXMLDoc
+void AMFXMLDocValue::SetXMLDocValue(const std::string& value) {
+	this->xmlData = value;
+}
+
+std::string AMFXMLDocValue::GetXMLDocValue() {
+	return this->xmlData;
+}
+
+// AMFDate
+void AMFDateValue::SetDateValue(uint64_t value) {
+	this->millisecondTimestamp = value;
+}
+
+uint64_t AMFDateValue::GetDateValue() {
+	return this->millisecondTimestamp;
+}
+
+// AMFArray Insert Value
+void AMFArrayValue::InsertValue(const std::string& key, AMFValue* value) {
+	this->associative.insert(std::make_pair(key, value));
+}
+
+// AMFArray Remove Value
+void AMFArrayValue::RemoveValue(const std::string& key) {
+	_AMFArrayMap_::iterator it = this->associative.find(key);
+	if (it != this->associative.end()) {
+		this->associative.erase(it);
+	}
+}
+
+// AMFArray Get Associative Iterator Begin
+_AMFArrayMap_::iterator AMFArrayValue::GetAssociativeIteratorValueBegin() {
+	return this->associative.begin();
+}
+
+// AMFArray Get Associative Iterator End
+_AMFArrayMap_::iterator AMFArrayValue::GetAssociativeIteratorValueEnd() {
+	return this->associative.end();
+}
+
+// AMFArray Push Back Value
+void AMFArrayValue::PushBackValue(AMFValue* value) {
+	this->dense.push_back(value);
+}
+
+// AMFArray Pop Back Value
+void AMFArrayValue::PopBackValue() {
+	this->dense.pop_back();
+}
+
+// AMFArray Get Dense List Size
+uint32_t AMFArrayValue::GetDenseValueSize() {
+	return (uint32_t)this->dense.size();
+}
+
+// AMFArray Get Dense Iterator Begin
+_AMFArrayList_::iterator AMFArrayValue::GetDenseIteratorBegin() {
+	return this->dense.begin();
+}
+
+// AMFArray Get Dense Iterator End
+_AMFArrayList_::iterator AMFArrayValue::GetDenseIteratorEnd() {
+	return this->dense.end();
+}
+
+AMFArrayValue::~AMFArrayValue() {
+	for (auto valueToDelete : GetDenseArray()) {
+		if (valueToDelete) delete valueToDelete;
+	}
+	for (auto valueToDelete : GetAssociativeMap()) {
+		if (valueToDelete.second) delete valueToDelete.second;
+	}
+}
+
+// AMFObject Constructor
+AMFObjectValue::AMFObjectValue(std::vector<std::pair<std::string, AMFValueType>> traits) {
+	this->traits.reserve(traits.size());
+	std::vector<std::pair<std::string, AMFValueType>>::iterator it = traits.begin();
+	while (it != traits.end()) {
+		this->traits.insert(std::make_pair(it->first, std::make_pair(it->second, new AMFNullValue())));
+		it++;
+	}
+}
+
+// AMFObject Set Value
+void AMFObjectValue::SetTraitValue(const std::string& trait, AMFValue* value) {
+	if (value) {
+		_AMFObjectTraits_::iterator it = this->traits.find(trait);
+		if (it != this->traits.end()) {
+			if (it->second.first == value->GetValueType()) {
+				it->second.second = value;
+			}
+		}
+	}
+}
+
+// AMFObject Get Value
+AMFValue* AMFObjectValue::GetTraitValue(const std::string& trait) {
+	_AMFObjectTraits_::iterator it = this->traits.find(trait);
+	if (it != this->traits.end()) {
+		return it->second.second;
+	}
+
+	return nullptr;
+}
+
+// AMFObject Get Trait Iterator Begin
+_AMFObjectTraits_::iterator AMFObjectValue::GetTraitsIteratorBegin() {
+	return this->traits.begin();
+}
+
+// AMFObject Get Trait Iterator End
+_AMFObjectTraits_::iterator AMFObjectValue::GetTraitsIteratorEnd() {
+	return this->traits.end();
+}
+
+// AMFObject Get Trait Size
+uint32_t AMFObjectValue::GetTraitArrayCount() {
+	return (uint32_t)this->traits.size();
+}
+
+AMFObjectValue::~AMFObjectValue() {
+	for (auto valueToDelete = GetTraitsIteratorBegin(); valueToDelete != GetTraitsIteratorEnd(); valueToDelete++) {
+		if (valueToDelete->second.second) delete valueToDelete->second.second;
+	}
+}

dCommon/AMFFormat.h

@@ -0,0 +1,413 @@
+#pragma once
+
+// Custom Classes
+#include "dCommonVars.h"
+
+// C++
+#include <unordered_map>
+#include <vector>
+
+/*!
+  \file AMFFormat.hpp
+  \brief A class for managing AMF values
+ */
+
+class AMFValue;     // Forward declaration
+
+// Definitions
+#define _AMFArrayMap_               std::unordered_map<std::string, AMFValue*>
+#define _AMFArrayList_              std::vector<AMFValue*>
+
+#define _AMFObjectTraits_           std::unordered_map<std::string, std::pair<AMFValueType, AMFValue*>>
+#define _AMFObjectDynamicTraits_    std::unordered_map<std::string, AMFValue*>
+
+//! An enum for each AMF value type
+enum AMFValueType : unsigned char {
+	AMFUndefined = 0x00,            //!< An undefined AMF Value
+	AMFNull = 0x01,                 //!< A null AMF value
+	AMFFalse = 0x02,                //!< A false AMF value
+	AMFTrue = 0x03,                 //!< A true AMF value
+	AMFInteger = 0x04,              //!< An integer AMF value
+	AMFDouble = 0x05,               //!< A double AMF value
+	AMFString = 0x06,               //!< A string AMF value
+	AMFXMLDoc = 0x07,               //!< An XML Doc AMF value
+	AMFDate = 0x08,                 //!< A date AMF value
+	AMFArray = 0x09,                //!< An array AMF value
+	AMFObject = 0x0A,               //!< An object AMF value
+	AMFXML = 0x0B,                  //!< An XML AMF value
+	AMFByteArray = 0x0C,            //!< A byte array AMF value
+	AMFVectorInt = 0x0D,            //!< An integer vector AMF value
+	AMFVectorUInt = 0x0E,           //!< An unsigned integer AMF value
+	AMFVectorDouble = 0x0F,         //!< A double vector AMF value
+	AMFVectorObject = 0x10,         //!< An object vector AMF value
+	AMFDictionary = 0x11            //!< A dictionary AMF value
+};
+
+//! An enum for the object value types
+enum AMFObjectValueType : unsigned char {
+	AMFObjectAnonymous = 0x01,
+	AMFObjectTyped = 0x02,
+	AMFObjectDynamic = 0x03,
+	AMFObjectExternalizable = 0x04
+};
+
+//! The base AMF value class
+class AMFValue {
+public:
+	//! Returns the AMF value type
+	/*!
+	  \return The AMF value type
+	 */
+	virtual AMFValueType GetValueType() = 0;
+	virtual ~AMFValue() {};
+};
+
+//! A typedef for a pointer to an AMF value
+typedef AMFValue* NDGFxValue;
+
+
+// The various AMF value types
+
+//! The undefined value AMF type
+class AMFUndefinedValue : public AMFValue {
+private:
+	//! Returns the AMF value type
+	/*!
+	  \return The AMF value type
+	 */
+	AMFValueType GetValueType() { return ValueType; }
+public:
+	static const AMFValueType ValueType = AMFUndefined;
+};
+
+//! The null value AMF type
+class AMFNullValue : public AMFValue {
+private:
+	//! Returns the AMF value type
+	/*!
+	 \return The AMF value type
+	 */
+	AMFValueType GetValueType() { return ValueType; }
+public:
+	static const AMFValueType ValueType = AMFNull;
+};
+
+//! The false value AMF type
+class AMFFalseValue : public AMFValue {
+private:
+	//! Returns the AMF value type
+	/*!
+	 \return The AMF value type
+	 */
+	AMFValueType GetValueType() { return ValueType; }
+public:
+	static const AMFValueType ValueType = AMFFalse;
+};
+
+//! The true value AMF type
+class AMFTrueValue : public AMFValue {
+private:
+	//! Returns the AMF value type
+	/*!
+	 \return The AMF value type
+	 */
+	AMFValueType GetValueType() { return ValueType; }
+public:
+	static const AMFValueType ValueType = AMFTrue;
+};
+
+//! The integer value AMF type
+class AMFIntegerValue : public AMFValue {
+private:
+	uint32_t value;         //!< The value of the AMF type
+
+	//! Returns the AMF value type
+	/*!
+	 \return The AMF value type
+	 */
+	AMFValueType GetValueType() { return ValueType; }
+
+public:
+	static const AMFValueType ValueType = AMFInteger;
+	//! Sets the integer value
+	/*!
+	  \param value The value to set
+	 */
+	void SetIntegerValue(uint32_t value);
+
+	//! Gets the integer value
+	/*!
+	  \return The integer value
+	 */
+	uint32_t GetIntegerValue();
+};
+
+//! The double value AMF type
+class AMFDoubleValue : public AMFValue {
+private:
+	double value;           //!< The value of the AMF type
+
+	//! Returns the AMF value type
+	/*!
+	 \return The AMF value type
+	 */
+	AMFValueType GetValueType() { return ValueType; }
+
+public:
+	static const AMFValueType ValueType = AMFDouble;
+	//! Sets the double value
+	/*!
+	  \param value The value to set to
+	 */
+	void SetDoubleValue(double value);
+
+	//! Gets the double value
+	/*!
+	  \return The double value
+	 */
+	double GetDoubleValue();
+};
+
+//! The string value AMF type
+class AMFStringValue : public AMFValue {
+private:
+	std::string value;          //!< The value of the AMF type
+
+	//! Returns the AMF value type
+	/*!
+	 \return The AMF value type
+	 */
+	AMFValueType GetValueType() { return ValueType; }
+
+public:
+	static const AMFValueType ValueType = AMFString;
+	//! Sets the string value
+	/*!
+	  \param value The string value to set to
+	 */
+	void SetStringValue(const std::string& value);
+
+	//! Gets the string value
+	/*!
+	  \return The string value
+	 */
+	std::string GetStringValue();
+};
+
+//! The XML doc value AMF type
+class AMFXMLDocValue : public AMFValue {
+private:
+	std::string xmlData;            //!< The value of the AMF type
+
+	//! Returns the AMF value type
+	/*!
+	 \return The AMF value type
+	 */
+	AMFValueType GetValueType() { return ValueType; }
+
+public:
+	static const AMFValueType ValueType = AMFXMLDoc;
+	//! Sets the XML Doc value
+	/*!
+	  \param value The value to set to
+	 */
+	void SetXMLDocValue(const std::string& value);
+
+	//! Gets the XML Doc value
+	/*!
+	  \return The XML Doc value
+	 */
+	std::string GetXMLDocValue();
+};
+
+//! The date value AMF type
+class AMFDateValue : public AMFValue {
+private:
+	uint64_t millisecondTimestamp;      //!< The time in milliseconds since the ephoch
+
+	//! Returns the AMF value type
+	/*!
+	 \return The AMF value type
+	 */
+	AMFValueType GetValueType() { return ValueType; }
+
+public:
+	static const AMFValueType ValueType = AMFDate;
+	//! Sets the date time
+	/*!
+	  \param value The value to set to
+	 */
+	void SetDateValue(uint64_t value);
+
+	//! Gets the date value
+	/*!
+	  \return The date value in milliseconds since the epoch
+	 */
+	uint64_t GetDateValue();
+};
+
+//! The array value AMF type
+// This object will manage it's own memory map and list.  Do not delete its values.
+class AMFArrayValue : public AMFValue {
+private:
+	_AMFArrayMap_ associative;      //!< The array map (associative part)
+	_AMFArrayList_ dense;           //!< The array list (dense part)
+
+	//! Returns the AMF value type
+	/*!
+	 \return The AMF value type
+	 */
+	AMFValueType GetValueType() override { return ValueType; }
+
+public:
+	static const AMFValueType ValueType = AMFArray;
+
+	~AMFArrayValue() override;
+	//! Inserts an item into the array map for a specific key
+	/*!
+	  \param key The key to set
+	  \param value The value to add
+	 */
+	void InsertValue(const std::string& key, AMFValue* value);
+
+	//! Removes an item for a specific key
+	/*!
+	  \param key The key to remove
+	 */
+	void RemoveValue(const std::string& key);
+
+	//! Finds an AMF value
+	/*!
+	  \return The AMF value if found, nullptr otherwise
+	 */
+	template <typename T>
+	T* FindValue(const std::string& key) const {
+		_AMFArrayMap_::const_iterator it = this->associative.find(key);
+		if (it != this->associative.end() && T::ValueType == it->second->GetValueType()) {
+			return dynamic_cast<T*>(it->second);
+		}
+
+		return nullptr;
+	};
+
+	//! Returns where the associative iterator begins
+	/*!
+	  \return Where the array map iterator begins
+	 */
+	_AMFArrayMap_::iterator GetAssociativeIteratorValueBegin();
+
+	//! Returns where the associative iterator ends
+	/*!
+	  \return Where the array map iterator ends
+	 */
+	_AMFArrayMap_::iterator GetAssociativeIteratorValueEnd();
+
+	//! Pushes back a value into the array list
+	/*!
+	  \param value The value to push back
+	 */
+	void PushBackValue(AMFValue* value);
+
+	//! Pops back the last value in the array list
+	void PopBackValue();
+
+	//! Gets the count of the dense list
+	/*!
+	  \return The dense list size
+	 */
+	uint32_t GetDenseValueSize();
+
+	//! Gets a specific value from the list for the specified index
+	/*!
+	  \param index The index to get
+	 */
+	template <typename T>
+	T* GetValueAt(uint32_t index) {
+		if (index >= this->dense.size()) return nullptr;
+		AMFValue* foundValue = this->dense.at(index);
+		return T::ValueType == foundValue->GetValueType() ? dynamic_cast<T*>(foundValue) : nullptr;
+	};
+
+	//! Returns where the dense iterator begins
+	/*!
+	  \return Where the iterator begins
+	 */
+	_AMFArrayList_::iterator GetDenseIteratorBegin();
+
+	//! Returns where the dense iterator ends
+	/*!
+	  \return Where the iterator ends
+	 */
+	_AMFArrayList_::iterator GetDenseIteratorEnd();
+
+	//! Returns the associative map
+	/*!
+	  \return The associative map
+	 */
+	_AMFArrayMap_ GetAssociativeMap() { return this->associative; };
+
+	//! Returns the dense array
+	/*!
+	  \return The dense array
+	 */
+	_AMFArrayList_ GetDenseArray() { return this->dense; };
+};
+
+//! The anonymous object value AMF type
+class AMFObjectValue : public AMFValue {
+private:
+	_AMFObjectTraits_ traits;           //!< The object traits
+
+	//! Returns the AMF value type
+	/*!
+	 \return The AMF value type
+	 */
+	AMFValueType GetValueType() override { return ValueType; }
+	~AMFObjectValue() override;
+
+public:
+	static const AMFValueType ValueType = AMFObject;
+	//! Constructor
+	/*!
+	  \param traits The traits to set
+	 */
+	AMFObjectValue(std::vector<std::pair<std::string, AMFValueType>> traits);
+
+	//! Gets the object value type
+	/*!
+	  \return The object value type
+	 */
+	virtual AMFObjectValueType GetObjectValueType() { return AMFObjectAnonymous; }
+
+	//! Sets the value of a trait
+	/*!
+	  \param trait The trait to set the value for
+	  \param value The AMF value to set
+	 */
+	void SetTraitValue(const std::string& trait, AMFValue* value);
+
+	//! Gets a trait value
+	/*!
+	  \param trait The trait to get the value for
+	  \return The trait value
+	 */
+	AMFValue* GetTraitValue(const std::string& trait);
+
+	//! Gets the beginning of the object traits iterator
+	/*!
+	  \return The AMF trait array iterator begin
+	 */
+	_AMFObjectTraits_::iterator GetTraitsIteratorBegin();
+
+	//! Gets the end of the object traits iterator
+	/*!
+	  \return The AMF trait array iterator begin
+	 */
+	_AMFObjectTraits_::iterator GetTraitsIteratorEnd();
+
+	//! Gets the amount of traits
+	/*!
+	  \return The amount of traits
+	 */
+	uint32_t GetTraitArrayCount();
+};

dCommon/AMFFormat_BitStream.cpp

@@ -0,0 +1,259 @@
+#include "AMFFormat_BitStream.h"
+
+// Writes an AMFValue pointer to a RakNet::BitStream
+template<>
+void RakNet::BitStream::Write<AMFValue*>(AMFValue* value) {
+	if (value != nullptr) {
+		AMFValueType type = value->GetValueType();
+
+		switch (type) {
+		case AMFUndefined: {
+			AMFUndefinedValue* v = (AMFUndefinedValue*)value;
+			this->Write(*v);
+			break;
+		}
+
+		case AMFNull: {
+			AMFNullValue* v = (AMFNullValue*)value;
+			this->Write(*v);
+			break;
+		}
+
+		case AMFFalse: {
+			AMFFalseValue* v = (AMFFalseValue*)value;
+			this->Write(*v);
+			break;
+		}
+
+		case AMFTrue: {
+			AMFTrueValue* v = (AMFTrueValue*)value;
+			this->Write(*v);
+			break;
+		}
+
+		case AMFInteger: {
+			AMFIntegerValue* v = (AMFIntegerValue*)value;
+			this->Write(*v);
+			break;
+		}
+
+		case AMFDouble: {
+			AMFDoubleValue* v = (AMFDoubleValue*)value;
+			this->Write(*v);
+			break;
+		}
+
+		case AMFString: {
+			AMFStringValue* v = (AMFStringValue*)value;
+			this->Write(*v);
+			break;
+		}
+
+		case AMFXMLDoc: {
+			AMFXMLDocValue* v = (AMFXMLDocValue*)value;
+			this->Write(*v);
+			break;
+		}
+
+		case AMFDate: {
+			AMFDateValue* v = (AMFDateValue*)value;
+			this->Write(*v);
+			break;
+		}
+
+		case AMFArray: {
+			this->Write((AMFArrayValue*)value);
+			break;
+		}
+		case AMFObject:
+		case AMFXML:
+		case AMFByteArray:
+		case AMFVectorInt:
+		case AMFVectorUInt:
+		case AMFVectorDouble:
+		case AMFVectorObject:
+		case AMFDictionary:
+			break;
+		}
+	}
+}
+
+/**
+ * A private function to write an value to a RakNet::BitStream
+ * RakNet writes in the correct byte order - do not reverse this.
+ */
+void WriteUInt29(RakNet::BitStream* bs, uint32_t v) {
+	unsigned char b4 = (unsigned char)v;
+	if (v < 0x00200000) {
+		b4 = b4 & 0x7F;
+		if (v > 0x7F) {
+			unsigned char b3;
+			v = v >> 7;
+			b3 = ((unsigned char)(v)) | 0x80;
+			if (v > 0x7F) {
+				unsigned char b2;
+				v = v >> 7;
+				b2 = ((unsigned char)(v)) | 0x80;
+				bs->Write(b2);
+			}
+
+			bs->Write(b3);
+		}
+	} else {
+		unsigned char b1;
+		unsigned char b2;
+		unsigned char b3;
+
+		v = v >> 8;
+		b3 = ((unsigned char)(v)) | 0x80;
+		v = v >> 7;
+		b2 = ((unsigned char)(v)) | 0x80;
+		v = v >> 7;
+		b1 = ((unsigned char)(v)) | 0x80;
+
+		bs->Write(b1);
+		bs->Write(b2);
+		bs->Write(b3);
+	}
+
+	bs->Write(b4);
+}
+
+/**
+ * Writes a flag number to a RakNet::BitStream
+ * RakNet writes in the correct byte order - do not reverse this.
+ */
+void WriteFlagNumber(RakNet::BitStream* bs, uint32_t v) {
+	v = (v << 1) | 0x01;
+	WriteUInt29(bs, v);
+}
+
+/**
+ * Writes an AMFString to a RakNet::BitStream
+ *
+ * RakNet writes in the correct byte order - do not reverse this.
+ */
+void WriteAMFString(RakNet::BitStream* bs, const std::string& str) {
+	WriteFlagNumber(bs, (uint32_t)str.size());
+	bs->Write(str.c_str(), (uint32_t)str.size());
+}
+
+/**
+ * Writes an U16 to a bitstream
+ *
+ * RakNet writes in the correct byte order - do not reverse this.
+ */
+void WriteAMFU16(RakNet::BitStream* bs, uint16_t value) {
+	bs->Write(value);
+}
+
+/**
+ * Writes an U32 to a bitstream
+ *
+ * RakNet writes in the correct byte order - do not reverse this.
+ */
+void WriteAMFU32(RakNet::BitStream* bs, uint32_t value) {
+	bs->Write(value);
+}
+
+/**
+ * Writes an U64 to a bitstream
+ *
+ * RakNet writes in the correct byte order - do not reverse this.
+ */
+void WriteAMFU64(RakNet::BitStream* bs, uint64_t value) {
+	bs->Write(value);
+}
+
+
+// Writes an AMFUndefinedValue to BitStream
+template<>
+void RakNet::BitStream::Write<AMFUndefinedValue>(AMFUndefinedValue value) {
+	this->Write(AMFUndefined);
+}
+
+// Writes an AMFNullValue to BitStream
+template<>
+void RakNet::BitStream::Write<AMFNullValue>(AMFNullValue value) {
+	this->Write(AMFNull);
+}
+
+// Writes an AMFFalseValue to BitStream
+template<>
+void RakNet::BitStream::Write<AMFFalseValue>(AMFFalseValue value) {
+	this->Write(AMFFalse);
+}
+
+// Writes an AMFTrueValue to BitStream
+template<>
+void RakNet::BitStream::Write<AMFTrueValue>(AMFTrueValue value) {
+	this->Write(AMFTrue);
+}
+
+// Writes an AMFIntegerValue to BitStream
+template<>
+void RakNet::BitStream::Write<AMFIntegerValue>(AMFIntegerValue value) {
+	this->Write(AMFInteger);
+	WriteUInt29(this, value.GetIntegerValue());
+}
+
+// Writes an AMFDoubleValue to BitStream
+template<>
+void RakNet::BitStream::Write<AMFDoubleValue>(AMFDoubleValue value) {
+	this->Write(AMFDouble);
+	double d = value.GetDoubleValue();
+	WriteAMFU64(this, *((unsigned long long*) & d));
+}
+
+// Writes an AMFStringValue to BitStream
+template<>
+void RakNet::BitStream::Write<AMFStringValue>(AMFStringValue value) {
+	this->Write(AMFString);
+	std::string v = value.GetStringValue();
+	WriteAMFString(this, v);
+}
+
+// Writes an AMFXMLDocValue to BitStream
+template<>
+void RakNet::BitStream::Write<AMFXMLDocValue>(AMFXMLDocValue value) {
+	this->Write(AMFXMLDoc);
+	std::string v = value.GetXMLDocValue();
+	WriteAMFString(this, v);
+}
+
+// Writes an AMFDateValue to BitStream
+template<>
+void RakNet::BitStream::Write<AMFDateValue>(AMFDateValue value) {
+	this->Write(AMFDate);
+	uint64_t date = value.GetDateValue();
+	WriteAMFU64(this, date);
+}
+
+// Writes an AMFArrayValue to BitStream
+template<>
+void RakNet::BitStream::Write<AMFArrayValue*>(AMFArrayValue* value) {
+	this->Write(AMFArray);
+	uint32_t denseSize = value->GetDenseValueSize();
+	WriteFlagNumber(this, denseSize);
+
+	_AMFArrayMap_::iterator it = value->GetAssociativeIteratorValueBegin();
+	_AMFArrayMap_::iterator end = value->GetAssociativeIteratorValueEnd();
+
+	while (it != end) {
+		WriteAMFString(this, it->first);
+		this->Write(it->second);
+		it++;
+	}
+
+	this->Write(AMFNull);
+
+	if (denseSize > 0) {
+		_AMFArrayList_::iterator it2 = value->GetDenseIteratorBegin();
+		_AMFArrayList_::iterator end2 = value->GetDenseIteratorEnd();
+
+		while (it2 != end2) {
+			this->Write(*it2);
+			it2++;
+		}
+	}
+}

dCommon/AMFFormat_BitStream.h

@@ -0,0 +1,92 @@
+#pragma once
+
+// Custom Classes
+#include "AMFFormat.h"
+
+// RakNet
+#include <BitStream.h>
+
+/*!
+ \file AMFFormat_BitStream.h
+ \brief A class that implements native writing of AMF values to RakNet::BitStream
+ */
+
+ // We are using the RakNet namespace
+namespace RakNet {
+	//! Writes an AMFValue pointer to a RakNet::BitStream
+	/*!
+	 \param value The value to write
+	 */
+	template <>
+	void RakNet::BitStream::Write<AMFValue*>(AMFValue* value);
+
+	//! Writes an AMFUndefinedValue to a RakNet::BitStream
+	/*!
+	 \param value The value to write
+	 */
+	template <>
+	void RakNet::BitStream::Write<AMFUndefinedValue>(AMFUndefinedValue value);
+
+	//! Writes an AMFNullValue to a RakNet::BitStream
+	/*!
+	 \param value The value to write
+	 */
+	template <>
+	void RakNet::BitStream::Write<AMFNullValue>(AMFNullValue value);
+
+	//! Writes an AMFFalseValue to a RakNet::BitStream
+	/*!
+	 \param value The value to write
+	 */
+	template <>
+	void RakNet::BitStream::Write<AMFFalseValue>(AMFFalseValue value);
+
+	//! Writes an AMFTrueValue to a RakNet::BitStream
+	/*!
+	 \param value The value to write
+	 */
+	template <>
+	void RakNet::BitStream::Write<AMFTrueValue>(AMFTrueValue value);
+
+	//! Writes an AMFIntegerValue to a RakNet::BitStream
+	/*!
+	 \param value The value to write
+	 */
+	template <>
+	void RakNet::BitStream::Write<AMFIntegerValue>(AMFIntegerValue value);
+
+	//! Writes an AMFDoubleValue to a RakNet::BitStream
+	/*!
+	 \param value The value to write
+	 */
+	template <>
+	void RakNet::BitStream::Write<AMFDoubleValue>(AMFDoubleValue value);
+
+	//! Writes an AMFStringValue to a RakNet::BitStream
+	/*!
+	 \param value The value to write
+	 */
+	template <>
+	void RakNet::BitStream::Write<AMFStringValue>(AMFStringValue value);
+
+	//! Writes an AMFXMLDocValue to a RakNet::BitStream
+	/*!
+	 \param value The value to write
+	 */
+	template <>
+	void RakNet::BitStream::Write<AMFXMLDocValue>(AMFXMLDocValue value);
+
+	//! Writes an AMFDateValue to a RakNet::BitStream
+	/*!
+	 \param value The value to write
+	 */
+	template <>
+	void RakNet::BitStream::Write<AMFDateValue>(AMFDateValue value);
+
+	//! Writes an AMFArrayValue to a RakNet::BitStream
+	/*!
+	 \param value The value to write
+	 */
+	template <>
+	void RakNet::BitStream::Write<AMFArrayValue*>(AMFArrayValue* value);
+} // namespace RakNet

dCommon/Amf3.h

@@ -1,367 +0,0 @@
-#ifndef __AMF3__H__
-#define __AMF3__H__
-
-#include "dCommonVars.h"
-#include "dLogger.h"
-#include "Game.h"
-
-#include <unordered_map>
-#include <vector>
-
-enum class eAmf : uint8_t {
-	Undefined = 0x00,            // An undefined AMF Value
-	Null = 0x01,                 // A null AMF value
-	False = 0x02,                // A false AMF value
-	True = 0x03,                 // A true AMF value
-	Integer = 0x04,              // An integer AMF value
-	Double = 0x05,               // A double AMF value
-	String = 0x06,               // A string AMF value
-	XMLDoc = 0x07,               // Unused in the live client and cannot be serialized without modification.  An XML Doc AMF value
-	Date = 0x08,                 // Unused in the live client and cannot be serialized without modification.  A date AMF value
-	Array = 0x09,                // An array AMF value
-	Object = 0x0A,               // Unused in the live client and cannot be serialized without modification.  An object AMF value
-	XML = 0x0B,                  // Unused in the live client and cannot be serialized without modification.  An XML AMF value
-	ByteArray = 0x0C,            // Unused in the live client and cannot be serialized without modification.  A byte array AMF value
-	VectorInt = 0x0D,            // Unused in the live client and cannot be serialized without modification.  An integer vector AMF value
-	VectorUInt = 0x0E,           // Unused in the live client and cannot be serialized without modification.  An unsigned integer AMF value
-	VectorDouble = 0x0F,         // Unused in the live client and cannot be serialized without modification.  A double vector AMF value
-	VectorObject = 0x10,         // Unused in the live client and cannot be serialized without modification.  An object vector AMF value
-	Dictionary = 0x11            // Unused in the live client and cannot be serialized without modification.  A dictionary AMF value
-};
-
-class AMFBaseValue {
-public:
-	virtual eAmf GetValueType() { return eAmf::Undefined; };
-	AMFBaseValue() {};
-	virtual ~AMFBaseValue() {};
-};
-
-template<typename ValueType>
-class AMFValue : public AMFBaseValue {
-public:
-	AMFValue() {};
-	AMFValue(ValueType value) { SetValue(value); };
-	virtual ~AMFValue() override {};
-
-	eAmf GetValueType() override { return eAmf::Undefined; };
-
-	const ValueType& GetValue() { return data; };
-	void SetValue(ValueType value) { data = value; };
-protected:
-	ValueType data;
-};
-
-// As a string this is much easier to write and read from a BitStream.
-template<>
-class AMFValue<const char*> : public AMFBaseValue {
-public:
-	AMFValue() {};
-	AMFValue(const char* value) { SetValue(std::string(value)); };
-	virtual ~AMFValue() override {};
-
-	eAmf GetValueType() override { return eAmf::String; };
-
-	const std::string& GetValue() { return data; };
-	void SetValue(std::string value) { data = value; };
-protected:
-	std::string data;
-};
-
-typedef AMFValue<std::nullptr_t> AMFNullValue;
-typedef AMFValue<bool> AMFBoolValue;
-typedef AMFValue<int32_t> AMFIntValue;
-typedef AMFValue<std::string> AMFStringValue;
-typedef AMFValue<double> AMFDoubleValue;
-
-template<> inline eAmf AMFValue<std::nullptr_t>::GetValueType() { return eAmf::Null; };
-template<> inline eAmf AMFValue<bool>::GetValueType() { return this->data ? eAmf::True : eAmf::False; };
-template<> inline eAmf AMFValue<int32_t>::GetValueType() { return eAmf::Integer; };
-template<> inline eAmf AMFValue<uint32_t>::GetValueType() { return eAmf::Integer; };
-template<> inline eAmf AMFValue<std::string>::GetValueType() { return eAmf::String; };
-template<> inline eAmf AMFValue<double>::GetValueType() { return eAmf::Double; };
-
-/**
- * The AMFArrayValue object holds 2 types of lists:
- * An associative list where a key maps to a value
- * A Dense list where elements are stored back to back
- *
- * Objects that are Registered are owned by this object
- * and are not to be deleted by a caller.
- */
-class AMFArrayValue : public AMFBaseValue {
-
-	typedef std::unordered_map<std::string, AMFBaseValue*> AMFAssociative;
-	typedef std::vector<AMFBaseValue*> AMFDense;
-
-public:
-	eAmf GetValueType() override { return eAmf::Array; };
-
-	~AMFArrayValue() override {
-		for (auto valueToDelete : GetDense()) {
-			if (valueToDelete) {
-				delete valueToDelete;
-				valueToDelete = nullptr;
-			}
-		}
-		for (auto valueToDelete : GetAssociative()) {
-			if (valueToDelete.second) {
-				delete valueToDelete.second;
-				valueToDelete.second = nullptr;
-			}
-		}
-	};
-
-	/**
-	 * Returns the Associative portion of the object
-	 */
-	inline AMFAssociative& GetAssociative() { return this->associative; };
-
-	/**
-	 * Returns the dense portion of the object
-	 */
-	inline AMFDense& GetDense() { return this->dense; };
-
-	/**
-	 * Inserts an AMFValue into the associative portion with the given key.
-	 * If a duplicate is attempted to be inserted, it is ignored and the
-	 * first value with that key is kept in the map.
-	 *
-	 * These objects are not to be deleted by the caller as they are owned by
-	 * the AMFArray object which manages its own memory.
-	 *
-	 * @param key The key to associate with the value
-	 * @param value The value to insert
-	 *
-	 * @return The inserted element if the type matched,
-	 * or nullptr if a key existed and was not the same type
-	 */
-	template<typename ValueType>
-	std::pair<AMFValue<ValueType>*, bool> Insert(const std::string& key, ValueType value) {
-		auto element = associative.find(key);
-		AMFValue<ValueType>* val = nullptr;
-		bool found = true;
-		if (element == associative.end()) {
-			val = new AMFValue<ValueType>(value);
-			associative.insert(std::make_pair(key, val));
-		} else {
-			val = dynamic_cast<AMFValue<ValueType>*>(element->second);
-			found = false;
-		}
-		return std::make_pair(val, found);
-	};
-
-	// Associates an array with a string key
-	std::pair<AMFBaseValue*, bool> Insert(const std::string& key) {
-		auto element = associative.find(key);
-		AMFArrayValue* val = nullptr;
-		bool found = true;
-		if (element == associative.end()) {
-			val = new AMFArrayValue();
-			associative.insert(std::make_pair(key, val));
-		} else {
-			val = dynamic_cast<AMFArrayValue*>(element->second);
-			found = false;
-		}
-		return std::make_pair(val, found);
-	};
-
-	// Associates an array with an integer key
-	std::pair<AMFBaseValue*, bool> Insert(const uint32_t& index) {
-		AMFArrayValue* val = nullptr;
-		bool inserted = false;
-		if (index >= dense.size()) {
-			dense.resize(index + 1);
-			val = new AMFArrayValue();
-			dense.at(index) = val;
-			inserted = true;
-		}
-		return std::make_pair(dynamic_cast<AMFArrayValue*>(dense.at(index)), inserted);
-	};
-
-	/**
-	 * @brief Inserts an AMFValue into the AMFArray key'd by index.
-	 * Attempting to insert the same key to the same value twice overwrites
-	 * the previous value with the new one.
-	 *
-	 * @param index The index to associate with the value
-	 * @param value The value to insert
-	 * @return The inserted element, or nullptr if the type did not match
-	 * what was at the index.
-	 */
-	template<typename ValueType>
-	std::pair<AMFValue<ValueType>*, bool> Insert(const uint32_t& index, ValueType value) {
-		AMFValue<ValueType>* val = nullptr;
-		bool inserted = false;
-		if (index >= this->dense.size()) {
-			this->dense.resize(index + 1);
-			val = new AMFValue<ValueType>(value);
-			this->dense.at(index) = val;
-			inserted = true;
-		}
-		return std::make_pair(dynamic_cast<AMFValue<ValueType>*>(this->dense.at(index)), inserted);
-	};
-
-	/**
-	 * Inserts an AMFValue into the associative portion with the given key.
-	 * If a duplicate is attempted to be inserted, it replaces the original
-	 *
-	 * The inserted element is now owned by this object and is not to be deleted
-	 *
-	 * @param key The key to associate with the value
-	 * @param value The value to insert
-	 */
-	void Insert(const std::string& key, AMFBaseValue* value) {
-		auto element = associative.find(key);
-		if (element != associative.end() && element->second) {
-			delete element->second;
-			element->second = value;
-		} else {
-			associative.insert(std::make_pair(key, value));
-		}
-	};
-
-	/**
-	 * Inserts an AMFValue into the associative portion with the given index.
-	 * If a duplicate is attempted to be inserted, it replaces the original
-	 *
-	 * The inserted element is now owned by this object and is not to be deleted
-	 *
-	 * @param key The key to associate with the value
-	 * @param value The value to insert
-	 */
-	void Insert(const uint32_t index, AMFBaseValue* value) {
-		if (index < dense.size()) {
-			AMFDense::iterator itr = dense.begin() + index;
-			if (*itr) delete dense.at(index);
-		} else {
-			dense.resize(index + 1);
-		}
-		dense.at(index) = value;
-	};
-
-	/**
-	 * Pushes an AMFValue into the back of the dense portion.
-	 *
-	 * These objects are not to be deleted by the caller as they are owned by
-	 * the AMFArray object which manages its own memory.
-	 *
-	 * @param value The value to insert
-	 *
-	 * @return The inserted pointer, or nullptr should the key already be in use.
-	 */
-	template<typename ValueType>
-	inline AMFValue<ValueType>* Push(ValueType value) {
-		return Insert(this->dense.size(), value).first;
-	};
-
-	/**
-	 * Removes the key from the associative portion
-	 *
-	 * The pointer removed is now no longer managed by this container
-	 *
-	 * @param key The key to remove from the associative portion
-	 */
-	void Remove(const std::string& key, bool deleteValue = true) {
-		AMFAssociative::iterator it = this->associative.find(key);
-		if (it != this->associative.end()) {
-			if (deleteValue) delete it->second;
-			this->associative.erase(it);
-		}
-	}
-
-	/**
-	 * Pops the last element in the dense portion, deleting it in the process.
-	 */
-	void Remove(const uint32_t index) {
-		if (!this->dense.empty() && index < this->dense.size()) {
-			auto itr = this->dense.begin() + index;
-			if (*itr) delete (*itr);
-			this->dense.erase(itr);
-		}
-	}
-
-	void Pop() {
-		if (!this->dense.empty()) Remove(this->dense.size() - 1);
-	}
-
-	AMFArrayValue* GetArray(const std::string& key) {
-		AMFAssociative::const_iterator it = this->associative.find(key);
-		if (it != this->associative.end()) {
-			return dynamic_cast<AMFArrayValue*>(it->second);
-		}
-		return nullptr;
-	};
-
-	AMFArrayValue* GetArray(const uint32_t index) {
-		return index >= this->dense.size() ? nullptr : dynamic_cast<AMFArrayValue*>(this->dense.at(index));
-	};
-
-	inline AMFArrayValue* InsertArray(const std::string& key) {
-		return static_cast<AMFArrayValue*>(Insert(key).first);
-	};
-
-	inline AMFArrayValue* InsertArray(const uint32_t index) {
-		return static_cast<AMFArrayValue*>(Insert(index).first);
-	};
-
-	inline AMFArrayValue* PushArray() {
-		return static_cast<AMFArrayValue*>(Insert(this->dense.size()).first);
-	};
-
-	/**
-	 * Gets an AMFValue by the key from the associative portion and converts it
-	 * to the AmfValue template type.  If the key did not exist, it is inserted.
-	 *
-	 * @tparam The target object type
-	 * @param key The key to lookup
-	 *
-	 * @return The AMFValue
-	 */
-	template <typename AmfType>
-	AMFValue<AmfType>* Get(const std::string& key) const {
-		AMFAssociative::const_iterator it = this->associative.find(key);
-		return it != this->associative.end() ?
-			dynamic_cast<AMFValue<AmfType>*>(it->second) :
-			nullptr;
-	};
-
-	// Get from the array but dont cast it
-	AMFBaseValue* Get(const std::string& key) const {
-		AMFAssociative::const_iterator it = this->associative.find(key);
-		return it != this->associative.end() ? it->second : nullptr;
-	};
-
-	/**
-	 * @brief Get an AMFValue object at a position in the dense portion.
-	 * Gets an AMFValue by the index from the dense portion and converts it
-	 * to the AmfValue template type.  If the index did not exist, it is inserted.
-	 *
-	 * @tparam The target object type
-	 * @param index The index to get
-	 * @return The casted object, or nullptr.
-	 */
-	template <typename AmfType>
-	AMFValue<AmfType>* Get(uint32_t index) const {
-		return index < this->dense.size() ?
-			dynamic_cast<AMFValue<AmfType>*>(this->dense.at(index)) :
-			nullptr;
-	};
-
-	// Get from the dense but dont cast it
-	AMFBaseValue* Get(const uint32_t index) const {
-		return index < this->dense.size() ? this->dense.at(index) : nullptr;
-	};
-private:
-	/**
-	 * The associative portion.  These values are key'd with strings to an AMFValue.
-	 */
-	AMFAssociative associative;
-
-	/**
-	 * The dense portion.  These AMFValue's are stored one after
-	 * another with the most recent addition being at the back.
-	 */
-	AMFDense dense;
-};
-
-#endif  //!__AMF3__H__

dCommon/AmfSerialize.cpp

@@ -1,184 +0,0 @@
-#include "AmfSerialize.h"
-
-#include "Game.h"
-#include "dLogger.h"
-
-// Writes an AMFValue pointer to a RakNet::BitStream
-template<>
-void RakNet::BitStream::Write<AMFBaseValue&>(AMFBaseValue& value) {
-	eAmf type = value.GetValueType();
-	this->Write(type);
-	switch (type) {
-	case eAmf::Integer: {
-		this->Write<AMFIntValue&>(*static_cast<AMFIntValue*>(&value));
-		break;
-	}
-
-	case eAmf::Double: {
-		this->Write<AMFDoubleValue&>(*static_cast<AMFDoubleValue*>(&value));
-		break;
-	}
-
-	case eAmf::String: {
-		this->Write<AMFStringValue&>(*static_cast<AMFStringValue*>(&value));
-		break;
-	}
-
-	case eAmf::Array: {
-		this->Write<AMFArrayValue&>(*static_cast<AMFArrayValue*>(&value));
-		break;
-	}
-	default: {
-		Game::logger->Log("AmfSerialize", "Encountered unwritable AMFType %i!", type);
-	}
-	case eAmf::Undefined:
-	case eAmf::Null:
-	case eAmf::False:
-	case eAmf::True:
-	case eAmf::Date:
-	case eAmf::Object:
-	case eAmf::XML:
-	case eAmf::XMLDoc:
-	case eAmf::ByteArray:
-	case eAmf::VectorInt:
-	case eAmf::VectorUInt:
-	case eAmf::VectorDouble:
-	case eAmf::VectorObject:
-	case eAmf::Dictionary:
-		break;
-	}
-}
-
-/**
- * A private function to write an value to a RakNet::BitStream
- * RakNet writes in the correct byte order - do not reverse this.
- */
-void WriteUInt29(RakNet::BitStream* bs, uint32_t v) {
-	unsigned char b4 = (unsigned char)v;
-	if (v < 0x00200000) {
-		b4 = b4 & 0x7F;
-		if (v > 0x7F) {
-			unsigned char b3;
-			v = v >> 7;
-			b3 = ((unsigned char)(v)) | 0x80;
-			if (v > 0x7F) {
-				unsigned char b2;
-				v = v >> 7;
-				b2 = ((unsigned char)(v)) | 0x80;
-				bs->Write(b2);
-			}
-
-			bs->Write(b3);
-		}
-	} else {
-		unsigned char b1;
-		unsigned char b2;
-		unsigned char b3;
-
-		v = v >> 8;
-		b3 = ((unsigned char)(v)) | 0x80;
-		v = v >> 7;
-		b2 = ((unsigned char)(v)) | 0x80;
-		v = v >> 7;
-		b1 = ((unsigned char)(v)) | 0x80;
-
-		bs->Write(b1);
-		bs->Write(b2);
-		bs->Write(b3);
-	}
-
-	bs->Write(b4);
-}
-
-/**
- * Writes a flag number to a RakNet::BitStream
- * RakNet writes in the correct byte order - do not reverse this.
- */
-void WriteFlagNumber(RakNet::BitStream* bs, uint32_t v) {
-	v = (v << 1) | 0x01;
-	WriteUInt29(bs, v);
-}
-
-/**
- * Writes an AMFString to a RakNet::BitStream
- *
- * RakNet writes in the correct byte order - do not reverse this.
- */
-void WriteAMFString(RakNet::BitStream* bs, const std::string& str) {
-	WriteFlagNumber(bs, (uint32_t)str.size());
-	bs->Write(str.c_str(), (uint32_t)str.size());
-}
-
-/**
- * Writes an U16 to a bitstream
- *
- * RakNet writes in the correct byte order - do not reverse this.
- */
-void WriteAMFU16(RakNet::BitStream* bs, uint16_t value) {
-	bs->Write(value);
-}
-
-/**
- * Writes an U32 to a bitstream
- *
- * RakNet writes in the correct byte order - do not reverse this.
- */
-void WriteAMFU32(RakNet::BitStream* bs, uint32_t value) {
-	bs->Write(value);
-}
-
-/**
- * Writes an U64 to a bitstream
- *
- * RakNet writes in the correct byte order - do not reverse this.
- */
-void WriteAMFU64(RakNet::BitStream* bs, uint64_t value) {
-	bs->Write(value);
-}
-
-// Writes an AMFIntegerValue to BitStream
-template<>
-void RakNet::BitStream::Write<AMFIntValue&>(AMFIntValue& value) {
-	WriteUInt29(this, value.GetValue());
-}
-
-// Writes an AMFDoubleValue to BitStream
-template<>
-void RakNet::BitStream::Write<AMFDoubleValue&>(AMFDoubleValue& value) {
-	double d = value.GetValue();
-	WriteAMFU64(this, *reinterpret_cast<uint64_t*>(&d));
-}
-
-// Writes an AMFStringValue to BitStream
-template<>
-void RakNet::BitStream::Write<AMFStringValue&>(AMFStringValue& value) {
-	WriteAMFString(this, value.GetValue());
-}
-
-// Writes an AMFArrayValue to BitStream
-template<>
-void RakNet::BitStream::Write<AMFArrayValue&>(AMFArrayValue& value) {
-	uint32_t denseSize = value.GetDense().size();
-	WriteFlagNumber(this, denseSize);
-
-	auto it = value.GetAssociative().begin();
-	auto end = value.GetAssociative().end();
-
-	while (it != end) {
-		WriteAMFString(this, it->first);
-		this->Write<AMFBaseValue&>(*it->second);
-		it++;
-	}
-
-	this->Write(eAmf::Null);
-
-	if (denseSize > 0) {
-		auto it2 = value.GetDense().begin();
-		auto end2 = value.GetDense().end();
-
-		while (it2 != end2) {
-			this->Write<AMFBaseValue&>(**it2);
-			it2++;
-		}
-	}
-}

dCommon/AmfSerialize.h

@@ -1,50 +0,0 @@
-#pragma once
-
-// Custom Classes
-#include "Amf3.h"
-
-// RakNet
-#include <BitStream.h>
-
-/*!
- \file AmfSerialize.h
- \brief A class that implements native writing of AMF values to RakNet::BitStream
- */
-
- // We are using the RakNet namespace
-namespace RakNet {
-	//! Writes an AMFValue pointer to a RakNet::BitStream
-	/*!
-	 \param value The value to write
-	 */
-	template <>
-	void RakNet::BitStream::Write<AMFBaseValue&>(AMFBaseValue& value);
-
-	//! Writes an AMFIntegerValue to a RakNet::BitStream
-	/*!
-	 \param value The value to write
-	 */
-	template <>
-	void RakNet::BitStream::Write<AMFIntValue&>(AMFIntValue& value);
-
-	//! Writes an AMFDoubleValue to a RakNet::BitStream
-	/*!
-	 \param value The value to write
-	 */
-	template <>
-	void RakNet::BitStream::Write<AMFDoubleValue&>(AMFDoubleValue& value);
-
-	//! Writes an AMFStringValue to a RakNet::BitStream
-	/*!
-	 \param value The value to write
-	 */
-	template <>
-	void RakNet::BitStream::Write<AMFStringValue&>(AMFStringValue& value);
-
-	//! Writes an AMFArrayValue to a RakNet::BitStream
-	/*!
-	 \param value The value to write
-	 */
-	template <>
-	void RakNet::BitStream::Write<AMFArrayValue&>(AMFArrayValue& value);
-} // namespace RakNet

dCommon/CMakeLists.txt

@@ -1,6 +1,6 @@
-set(DCOMMON_SOURCES
+set(DCOMMON_SOURCES "AMFFormat.cpp"
 		"AMFDeserialize.cpp"
-		"AmfSerialize.cpp"
+		"AMFFormat_BitStream.cpp"
 		"BinaryIO.cpp"
 		"dConfig.cpp"
 		"Diagnostics.cpp"

dCommon/DluAssert.h

@@ -1,12 +0,0 @@
-#ifndef __DLUASSERT__H__
-#define __DLUASSERT__H__
-
-#include <assert.h>
-
-#ifdef _DEBUG
-#	define DluAssert(expression) assert(expression)
-#else
-#	define DluAssert(expression)
-#endif
-
-#endif  //!__DLUASSERT__H__

dCommon/Game.h

@@ -10,8 +10,6 @@ class dConfig;
 class RakPeerInterface;
 class AssetManager;
 struct SystemAddress;
-class EntityManager;
-class dZoneManager;
 
 namespace Game {
 	extern dLogger* logger;
@@ -24,6 +22,4 @@ namespace Game {
 	extern AssetManager* assetManager;
 	extern SystemAddress chatSysAddr;
 	extern bool shouldShutdown;
-	extern EntityManager* entityManager;
-	extern dZoneManager* zoneManager;
 }

dCommon/GeneralUtils.h

@@ -111,6 +111,29 @@ namespace GeneralUtils {
 	 */
 	bool CheckBit(int64_t value, uint32_t index);
 
+	// MARK: Random Number Generation
+
+	//! Generates a random number
+	/*!
+	  \param min The minimum the generate from
+	  \param max The maximum to generate to
+	 */
+	template <typename T>
+	inline T GenerateRandomNumber(std::size_t min, std::size_t max) {
+		// Make sure it is a numeric type
+		static_assert(std::is_arithmetic<T>::value, "Not an arithmetic type");
+
+		if constexpr (std::is_integral_v<T>) {  // constexpr only necessary on first statement
+			std::uniform_int_distribution<T> distribution(min, max);
+			return distribution(Game::randomEngine);
+		} else if (std::is_floating_point_v<T>) {
+			std::uniform_real_distribution<T> distribution(min, max);
+			return distribution(Game::randomEngine);
+		}
+
+		return T();
+	}
+
 	bool ReplaceInString(std::string& str, const std::string& from, const std::string& to);
 
 	std::u16string ReadWString(RakNet::BitStream* inStream);
@@ -200,42 +223,4 @@ namespace GeneralUtils {
 		std::hash<T> h;
 		s ^= h(v) + 0x9e3779b9 + (s << 6) + (s >> 2);
 	}
-
-	// MARK: Random Number Generation
-
-	//! Generates a random number
-	/*!
-	  \param min The minimum the generate from
-	  \param max The maximum to generate to
-	 */
-	template <typename T>
-	inline T GenerateRandomNumber(std::size_t min, std::size_t max) {
-		// Make sure it is a numeric type
-		static_assert(std::is_arithmetic<T>::value, "Not an arithmetic type");
-
-		if constexpr (std::is_integral_v<T>) {  // constexpr only necessary on first statement
-			std::uniform_int_distribution<T> distribution(min, max);
-			return distribution(Game::randomEngine);
-		} else if (std::is_floating_point_v<T>) {
-			std::uniform_real_distribution<T> distribution(min, max);
-			return distribution(Game::randomEngine);
-		}
-
-		return T();
-	}
-
-// on Windows we need to undef these or else they conflict with our numeric limits calls
-// DEVELOPERS DEVELOPERS DEVELOPERS DEVELOPERS DEVELOPERS DEVELOPERS DEVELOPERS DEVELOPERS
-#ifdef _WIN32
-#undef min
-#undef max
-#endif
-
-	template <typename T>
-	inline T GenerateRandomNumber() {
-		// Make sure it is a numeric type
-		static_assert(std::is_arithmetic<T>::value, "Not an arithmetic type");
-		
-		return GenerateRandomNumber<T>(std::numeric_limits<T>::min(), std::numeric_limits<T>::max());
-	}
 }

dDatabase/CDClientDatabase.h

@@ -13,7 +13,18 @@
 #include <sstream>
 #include <iostream>
 
-//! The CDClient Database namespace
+ // Enable this to cache all entries in each table for fast access, comes with more memory cost
+ //#define CDCLIENT_CACHE_ALL
+
+ // Enable this to skip some unused columns in some tables
+#define UNUSED(v)
+
+/*!
+  \file CDClientDatabase.hpp
+  \brief An interface between the CDClient.sqlite file and the server
+ */
+
+ //! The CDClient Database namespace
 namespace CDClientDatabase {
 
 	//! Opens a connection with the CDClient

dDatabase/CDClientManager.cpp

@@ -38,53 +38,43 @@
 #include "CDFeatureGatingTable.h"
 #include "CDRailActivatorComponent.h"
 
-// Uncomment this to cache the full cdclient database into memory. This will make the server load faster, but will use more memory.
-// A vanilla CDClient takes about 46MB of memory + the regular world data.
-// #define CDCLIENT_CACHE_ALL
-
-#ifdef CDCLIENT_CACHE_ALL
-	#define CDCLIENT_DONT_CACHE_TABLE(x) x
-#else
-	#define CDCLIENT_DONT_CACHE_TABLE(x)
-#endif
-
 CDClientManager::CDClientManager() {
-	CDActivityRewardsTable::Instance().LoadValuesFromDatabase();
-	CDActivitiesTable::Instance().LoadValuesFromDatabase();
-	CDCLIENT_DONT_CACHE_TABLE(CDAnimationsTable::Instance().LoadValuesFromDatabase());
-	CDBehaviorParameterTable::Instance().LoadValuesFromDatabase();
-	CDBehaviorTemplateTable::Instance().LoadValuesFromDatabase();
-	CDBrickIDTableTable::Instance().LoadValuesFromDatabase();
-	CDComponentsRegistryTable::Instance().LoadValuesFromDatabase();
-	CDCurrencyTableTable::Instance().LoadValuesFromDatabase();
-	CDDestructibleComponentTable::Instance().LoadValuesFromDatabase();
-	CDEmoteTableTable::Instance().LoadValuesFromDatabase();
-	CDFeatureGatingTable::Instance().LoadValuesFromDatabase();
-	CDInventoryComponentTable::Instance().LoadValuesFromDatabase();
-	CDCLIENT_DONT_CACHE_TABLE(CDItemComponentTable::Instance().LoadValuesFromDatabase());
-	CDItemSetSkillsTable::Instance().LoadValuesFromDatabase();
-	CDItemSetsTable::Instance().LoadValuesFromDatabase();
-	CDLevelProgressionLookupTable::Instance().LoadValuesFromDatabase();
-	CDLootMatrixTable::Instance().LoadValuesFromDatabase();
-	CDLootTableTable::Instance().LoadValuesFromDatabase();
-	CDMissionEmailTable::Instance().LoadValuesFromDatabase();
-	CDMissionNPCComponentTable::Instance().LoadValuesFromDatabase();
-	CDMissionTasksTable::Instance().LoadValuesFromDatabase();
-	CDMissionsTable::Instance().LoadValuesFromDatabase();
-	CDMovementAIComponentTable::Instance().LoadValuesFromDatabase();
-	CDObjectSkillsTable::Instance().LoadValuesFromDatabase();
-	CDCLIENT_DONT_CACHE_TABLE(CDObjectsTable::Instance().LoadValuesFromDatabase());
-	CDPhysicsComponentTable::Instance().LoadValuesFromDatabase();
-	CDPackageComponentTable::Instance().LoadValuesFromDatabase();
-	CDProximityMonitorComponentTable::Instance().LoadValuesFromDatabase();
-	CDPropertyEntranceComponentTable::Instance().LoadValuesFromDatabase();
-	CDPropertyTemplateTable::Instance().LoadValuesFromDatabase();
-	CDRailActivatorComponentTable::Instance().LoadValuesFromDatabase();
-	CDRarityTableTable::Instance().LoadValuesFromDatabase();
-	CDRebuildComponentTable::Instance().LoadValuesFromDatabase();
-	CDRewardsTable::Instance().LoadValuesFromDatabase();
-	CDScriptComponentTable::Instance().LoadValuesFromDatabase();
-	CDSkillBehaviorTable::Instance().LoadValuesFromDatabase();
-	CDVendorComponentTable::Instance().LoadValuesFromDatabase();
-	CDZoneTableTable::Instance().LoadValuesFromDatabase();
+	CDActivityRewardsTable::Instance();
+	UNUSED(CDAnimationsTable::Instance());
+	CDBehaviorParameterTable::Instance();
+	CDBehaviorTemplateTable::Instance();
+	CDComponentsRegistryTable::Instance();
+	CDCurrencyTableTable::Instance();
+	CDDestructibleComponentTable::Instance();
+	CDEmoteTableTable::Instance();
+	CDInventoryComponentTable::Instance();
+	CDItemComponentTable::Instance();
+	CDItemSetsTable::Instance();
+	CDItemSetSkillsTable::Instance();
+	CDLevelProgressionLookupTable::Instance();
+	CDLootMatrixTable::Instance();
+	CDLootTableTable::Instance();
+	CDMissionNPCComponentTable::Instance();
+	CDMissionTasksTable::Instance();
+	CDMissionsTable::Instance();
+	CDObjectSkillsTable::Instance();
+	CDObjectsTable::Instance();
+	CDPhysicsComponentTable::Instance();
+	CDRebuildComponentTable::Instance();
+	CDScriptComponentTable::Instance();
+	CDSkillBehaviorTable::Instance();
+	CDZoneTableTable::Instance();
+	CDVendorComponentTable::Instance();
+	CDActivitiesTable::Instance();
+	CDPackageComponentTable::Instance();
+	CDProximityMonitorComponentTable::Instance();
+	CDMovementAIComponentTable::Instance();
+	CDBrickIDTableTable::Instance();
+	CDRarityTableTable::Instance();
+	CDMissionEmailTable::Instance();
+	CDRewardsTable::Instance();
+	CDPropertyEntranceComponentTable::Instance();
+	CDPropertyTemplateTable::Instance();
+	CDFeatureGatingTable::Instance();
+	CDRailActivatorComponentTable::Instance();
 }

dDatabase/CDClientManager.h

@@ -4,8 +4,6 @@
 
 #include "Singleton.h"
 
-#define UNUSED_TABLE(v)
-
 /**
  * Initialize the CDClient tables so they are all loaded into memory.
  */

dDatabase/Tables/CDActivitiesTable.cpp

@@ -1,6 +1,7 @@
 #include "CDActivitiesTable.h"
 
-void CDActivitiesTable::LoadValuesFromDatabase() {
+CDActivitiesTable::CDActivitiesTable(void) {
+
 	// First, get the size of the table
 	unsigned int size = 0;
 	auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM Activities");
@@ -54,3 +55,8 @@ std::vector<CDActivities> CDActivitiesTable::Query(std::function<bool(CDActiviti
 
 	return data;
 }
+
+std::vector<CDActivities> CDActivitiesTable::GetEntries(void) const {
+	return this->entries;
+}
+

dDatabase/Tables/CDActivitiesTable.h

@@ -30,10 +30,9 @@ private:
 	std::vector<CDActivities> entries;
 
 public:
-	void LoadValuesFromDatabase();
-
+	CDActivitiesTable();
 	// Queries the table with a custom "where" clause
 	std::vector<CDActivities> Query(std::function<bool(CDActivities)> predicate);
 
-	const std::vector<CDActivities>& GetEntries() const { return this->entries; }
+	std::vector<CDActivities> GetEntries(void) const;
 };

dDatabase/Tables/CDActivityRewardsTable.cpp

@@ -1,6 +1,6 @@
 #include "CDActivityRewardsTable.h"
 
-void CDActivityRewardsTable::LoadValuesFromDatabase() {
+CDActivityRewardsTable::CDActivityRewardsTable(void) {
 
 	// First, get the size of the table
 	unsigned int size = 0;
@@ -43,3 +43,8 @@ std::vector<CDActivityRewards> CDActivityRewardsTable::Query(std::function<bool(
 
 	return data;
 }
+
+std::vector<CDActivityRewards> CDActivityRewardsTable::GetEntries(void) const {
+	return this->entries;
+}
+

dDatabase/Tables/CDActivityRewardsTable.h

@@ -18,10 +18,10 @@ private:
 	std::vector<CDActivityRewards> entries;
 
 public:
-	void LoadValuesFromDatabase();
+	CDActivityRewardsTable();
 	// Queries the table with a custom "where" clause
 	std::vector<CDActivityRewards> Query(std::function<bool(CDActivityRewards)> predicate);
 
-	std::vector<CDActivityRewards> GetEntries() const;
+	std::vector<CDActivityRewards> GetEntries(void) const;
 
 };

dDatabase/Tables/CDAnimationsTable.cpp

@@ -1,112 +1,56 @@
 #include "CDAnimationsTable.h"
-#include "GeneralUtils.h"
-#include "Game.h"
 
+CDAnimationsTable::CDAnimationsTable(void) {
 
-void CDAnimationsTable::LoadValuesFromDatabase() {
+	// First, get the size of the table
+	unsigned int size = 0;
+	auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM Animations");
+	while (!tableSize.eof()) {
+		size = tableSize.getIntField(0, 0);
+
+		tableSize.nextRow();
+	}
+
+	tableSize.finalize();
+
+	// Reserve the size
+	this->entries.reserve(size);
+
+	// Now get the data
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM Animations");
 	while (!tableData.eof()) {
-		std::string animation_type = tableData.getStringField("animation_type", "");
-		DluAssert(!animation_type.empty());
-		AnimationGroupID animationGroupID = tableData.getIntField("animationGroupID", -1);
-		DluAssert(animationGroupID != -1);
-
-		CDAnimation entry;
+		CDAnimations entry;
+		entry.animationGroupID = tableData.getIntField("animationGroupID", -1);
+		entry.animation_type = tableData.getStringField("animation_type", "");
 		entry.animation_name = tableData.getStringField("animation_name", "");
-		entry.chance_to_play = tableData.getFloatField("chance_to_play", 1.0f);
-		UNUSED_COLUMN(entry.min_loops = tableData.getIntField("min_loops", 0);)
-		UNUSED_COLUMN(entry.max_loops = tableData.getIntField("max_loops", 0);)
-		entry.animation_length = tableData.getFloatField("animation_length", 0.0f);
-		UNUSED_COLUMN(entry.hideEquip = tableData.getIntField("hideEquip", 0) == 1;)
-		UNUSED_COLUMN(entry.ignoreUpperBody = tableData.getIntField("ignoreUpperBody", 0) == 1;)
-		UNUSED_COLUMN(entry.restartable = tableData.getIntField("restartable", 0) == 1;)
-		UNUSED_COLUMN(entry.face_animation_name = tableData.getStringField("face_animation_name", "");)
-		UNUSED_COLUMN(entry.priority = tableData.getFloatField("priority", 0.0f);)
-		UNUSED_COLUMN(entry.blendTime = tableData.getFloatField("blendTime", 0.0f);)
+		entry.chance_to_play = tableData.getFloatField("chance_to_play", -1.0f);
+		entry.min_loops = tableData.getIntField("min_loops", -1);
+		entry.max_loops = tableData.getIntField("max_loops", -1);
+		entry.animation_length = tableData.getFloatField("animation_length", -1.0f);
+		entry.hideEquip = tableData.getIntField("hideEquip", -1) == 1 ? true : false;
+		entry.ignoreUpperBody = tableData.getIntField("ignoreUpperBody", -1) == 1 ? true : false;
+		entry.restartable = tableData.getIntField("restartable", -1) == 1 ? true : false;
+		entry.face_animation_name = tableData.getStringField("face_animation_name", "");
+		entry.priority = tableData.getFloatField("priority", -1.0f);
+		entry.blendTime = tableData.getFloatField("blendTime", -1.0f);
 
-		this->animations[CDAnimationKey(animation_type, animationGroupID)].push_back(entry);
+		this->entries.push_back(entry);
 		tableData.nextRow();
 	}
 
 	tableData.finalize();
 }
 
-bool CDAnimationsTable::CacheData(CppSQLite3Statement& queryToCache) {
-	auto tableData = queryToCache.execQuery();
-	// If we received a bad lookup, cache it anyways so we do not run the query again.
-	if (tableData.eof()) return false;
+std::vector<CDAnimations> CDAnimationsTable::Query(std::function<bool(CDAnimations)> predicate) {
 
-	do {
-		std::string animation_type = tableData.getStringField("animation_type", "");
-		DluAssert(!animation_type.empty());
-		AnimationGroupID animationGroupID = tableData.getIntField("animationGroupID", -1);
-		DluAssert(animationGroupID != -1);
+	std::vector<CDAnimations> data = cpplinq::from(this->entries)
+		>> cpplinq::where(predicate)
+		>> cpplinq::to_vector();
 
-		CDAnimation entry;
-		entry.animation_name = tableData.getStringField("animation_name", "");
-		entry.chance_to_play = tableData.getFloatField("chance_to_play", 1.0f);
-		UNUSED_COLUMN(entry.min_loops = tableData.getIntField("min_loops", 0);)
-		UNUSED_COLUMN(entry.max_loops = tableData.getIntField("max_loops", 0);)
-		entry.animation_length = tableData.getFloatField("animation_length", 0.0f);
-		UNUSED_COLUMN(entry.hideEquip = tableData.getIntField("hideEquip", 0) == 1;)
-		UNUSED_COLUMN(entry.ignoreUpperBody = tableData.getIntField("ignoreUpperBody", 0) == 1;)
-		UNUSED_COLUMN(entry.restartable = tableData.getIntField("restartable", 0) == 1;)
-		UNUSED_COLUMN(entry.face_animation_name = tableData.getStringField("face_animation_name", "");)
-		UNUSED_COLUMN(entry.priority = tableData.getFloatField("priority", 0.0f);)
-		UNUSED_COLUMN(entry.blendTime = tableData.getFloatField("blendTime", 0.0f);)
-
-		this->animations[CDAnimationKey(animation_type, animationGroupID)].push_back(entry);
-		tableData.nextRow();
-	} while (!tableData.eof());
-
-	tableData.finalize();
-
-	return true;
+	return data;
 }
 
-void CDAnimationsTable::CacheAnimations(const CDAnimationKey animationKey) {
-	auto query = CDClientDatabase::CreatePreppedStmt("SELECT * FROM Animations WHERE animationGroupID = ? and animation_type = ?");
-	query.bind(1, static_cast<int32_t>(animationKey.second));
-	query.bind(2, animationKey.first.c_str());
-	// If we received a bad lookup, cache it anyways so we do not run the query again.
-	if (!CacheData(query)) {
-		this->animations[animationKey];
-	}
+std::vector<CDAnimations> CDAnimationsTable::GetEntries(void) const {
+	return this->entries;
 }
 
-void CDAnimationsTable::CacheAnimationGroup(AnimationGroupID animationGroupID) {
-	auto animationEntryCached = this->animations.find(CDAnimationKey("", animationGroupID));
-	if (animationEntryCached != this->animations.end()) {
-		return;
-	}
-
-	auto query = CDClientDatabase::CreatePreppedStmt("SELECT * FROM Animations WHERE animationGroupID = ?");
-	query.bind(1, static_cast<int32_t>(animationGroupID));
-
-	// Cache the query so we don't run the query again.
-	CacheData(query);
-	this->animations[CDAnimationKey("", animationGroupID)];
-}
-
-CDAnimationLookupResult CDAnimationsTable::GetAnimation(const AnimationID& animationType, const std::string& previousAnimationName, const AnimationGroupID animationGroupID) {
-	CDAnimationKey animationKey(animationType, animationGroupID);
-	auto animationEntryCached = this->animations.find(animationKey);
-	if (animationEntryCached == this->animations.end()) {
-		this->CacheAnimations(animationKey);
-	}
-
-	auto animationEntry = this->animations.find(animationKey);
-	// If we have only one animation, return it regardless of the chance to play.
-	if (animationEntry->second.size() == 1) {
-		return CDAnimationLookupResult(animationEntry->second.front());
-	}
-	auto randomAnimation = GeneralUtils::GenerateRandomNumber<float>(0, 1);
-
-	for (auto& animationEntry : animationEntry->second) {
-		randomAnimation -= animationEntry.chance_to_play;
-		// This is how the client gets the random animation.
-		if (animationEntry.animation_name != previousAnimationName && randomAnimation <= 0.0f) return CDAnimationLookupResult(animationEntry);
-	}
-
-	return CDAnimationLookupResult();
-}

dDatabase/Tables/CDAnimationsTable.h

@@ -1,67 +1,33 @@
 #pragma once
 
+// Custom Classes
 #include "CDTable.h"
-#include <list>
 
-struct CDAnimation {
-	// unsigned int animationGroupID;
-	// std::string animation_type;
-	// The above two are a pair to represent a primary key in the map.
+struct CDAnimations {
+	unsigned int animationGroupID;          //!< The animation group ID
+	std::string animation_type;        //!< The animation type
 	std::string animation_name;        //!< The animation name
 	float chance_to_play;           //!< The chance to play the animation
-	UNUSED_COLUMN(unsigned int min_loops;)                 //!< The minimum number of loops
-	UNUSED_COLUMN(unsigned int max_loops;)                 //!< The maximum number of loops
+	unsigned int min_loops;                 //!< The minimum number of loops
+	unsigned int max_loops;                 //!< The maximum number of loops
 	float animation_length;         //!< The animation length
-	UNUSED_COLUMN(bool hideEquip;)                 //!< Whether or not to hide the equip
-	UNUSED_COLUMN(bool ignoreUpperBody;)           //!< Whether or not to ignore the upper body
-	UNUSED_COLUMN(bool restartable;)               //!< Whether or not the animation is restartable
-	UNUSED_COLUMN(std::string face_animation_name;)   //!< The face animation name
-	UNUSED_COLUMN(float priority;)                 //!< The priority
-	UNUSED_COLUMN(float blendTime;)                //!< The blend time
+	bool hideEquip;                 //!< Whether or not to hide the equip
+	bool ignoreUpperBody;           //!< Whether or not to ignore the upper body
+	bool restartable;               //!< Whether or not the animation is restartable
+	std::string face_animation_name;   //!< The face animation name
+	float priority;                 //!< The priority
+	float blendTime;                //!< The blend time
 };
 
-typedef LookupResult<CDAnimation> CDAnimationLookupResult;
 
 class CDAnimationsTable : public CDTable<CDAnimationsTable> {
-	typedef int32_t AnimationGroupID;
-	typedef std::string AnimationID;
-	typedef std::pair<std::string, AnimationGroupID> CDAnimationKey;
-public:
-	void LoadValuesFromDatabase();
-	/**
-	 * Given an animationType and the previousAnimationName played, return the next animationType to play.
-	 * If there are more than 1 animationTypes that can be played, one is selected at random but also does not allow
-	 * the previousAnimationName to be played twice.
-	 * 
-	 * @param animationType The animationID to lookup
-	 * @param previousAnimationName The previously played animation
-	 * @param animationGroupID The animationGroupID to lookup
-	 * @return CDAnimationLookupResult 
-	 */
-	[[nodiscard]] CDAnimationLookupResult GetAnimation(const AnimationID& animationType, const std::string& previousAnimationName, const AnimationGroupID animationGroupID);
-
-	/**
-	 * Cache a full AnimationGroup by its ID.
-	 */
-	void CacheAnimationGroup(AnimationGroupID animationGroupID);
 private:
+	std::vector<CDAnimations> entries;
 
-	/**
-	 * Cache all animations given a premade key
-	 */
-	void CacheAnimations(const CDAnimationKey animationKey);
+public:
+	CDAnimationsTable();
+	// Queries the table with a custom "where" clause
+	std::vector<CDAnimations> Query(std::function<bool(CDAnimations)> predicate);
 
-	/**
-	 * Run the query responsible for caching the data.
-	 * @param queryToCache 
-	 * @return true 
-	 * @return false 
-	 */
-	bool CacheData(CppSQLite3Statement& queryToCache);
-
-	/**
-	 * Each animation is key'd by its animationName and its animationGroupID.  Each
-	 * animation has a possible list of animations.  This is because there can be animations have a percent chance to play so one is selected at random.
-	 */
-	std::map<CDAnimationKey, std::list<CDAnimation>> animations;
+	std::vector<CDAnimations> GetEntries(void) const;
 };

dDatabase/Tables/CDBehaviorParameterTable.cpp

@@ -1,7 +1,7 @@
 #include "CDBehaviorParameterTable.h"
 #include "GeneralUtils.h"
 
-void CDBehaviorParameterTable::LoadValuesFromDatabase() {
+CDBehaviorParameterTable::CDBehaviorParameterTable(void) {
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM BehaviorParameter");
 	uint32_t uniqueParameterId = 0;
 	uint64_t hash = 0;
@@ -53,3 +53,4 @@ std::map<std::string, float> CDBehaviorParameterTable::GetParametersByBehaviorID
 	}
 	return returnInfo;
 }
+

dDatabase/Tables/CDBehaviorParameterTable.h

@@ -16,8 +16,7 @@ private:
 	std::unordered_map<uint64_t, CDBehaviorParameter> m_Entries;
 	std::unordered_map<std::string, uint32_t> m_ParametersList;
 public:
-	void LoadValuesFromDatabase();
-
+	CDBehaviorParameterTable();
 	float GetValue(const uint32_t behaviorID, const std::string& name, const float defaultValue = 0);
 
 	std::map<std::string, float> GetParametersByBehaviorID(uint32_t behaviorID);

dDatabase/Tables/CDBehaviorTemplateTable.cpp

@@ -1,6 +1,6 @@
 #include "CDBehaviorTemplateTable.h"
 
-void CDBehaviorTemplateTable::LoadValuesFromDatabase() {
+CDBehaviorTemplateTable::CDBehaviorTemplateTable(void) {
 
 	// First, get the size of the table
 	unsigned int size = 0;
@@ -48,7 +48,7 @@ std::vector<CDBehaviorTemplate> CDBehaviorTemplateTable::Query(std::function<boo
 	return data;
 }
 
-const std::vector<CDBehaviorTemplate>& CDBehaviorTemplateTable::GetEntries() const {
+std::vector<CDBehaviorTemplate> CDBehaviorTemplateTable::GetEntries(void) const {
 	return this->entries;
 }
 
@@ -64,3 +64,4 @@ const CDBehaviorTemplate CDBehaviorTemplateTable::GetByBehaviorID(uint32_t behav
 		return entry->second;
 	}
 }
+

dDatabase/Tables/CDBehaviorTemplateTable.h

@@ -19,12 +19,11 @@ private:
 	std::unordered_map<uint32_t, CDBehaviorTemplate> entriesMappedByBehaviorID;
 	std::unordered_set<std::string> m_EffectHandles;
 public:
-	void LoadValuesFromDatabase();
-
+	CDBehaviorTemplateTable();
 	// Queries the table with a custom "where" clause
 	std::vector<CDBehaviorTemplate> Query(std::function<bool(CDBehaviorTemplate)> predicate);
 
-	const std::vector<CDBehaviorTemplate>& GetEntries(void) const;
+	std::vector<CDBehaviorTemplate> GetEntries(void) const;
 
 	const CDBehaviorTemplate GetByBehaviorID(uint32_t behaviorID);
 };

dDatabase/Tables/CDBrickIDTableTable.cpp

@@ -1,6 +1,6 @@
 #include "CDBrickIDTableTable.h"
 
-void CDBrickIDTableTable::LoadValuesFromDatabase() {
+CDBrickIDTableTable::CDBrickIDTableTable(void) {
 
 	// First, get the size of the table
 	unsigned int size = 0;
@@ -39,7 +39,7 @@ std::vector<CDBrickIDTable> CDBrickIDTableTable::Query(std::function<bool(CDBric
 	return data;
 }
 
-const std::vector<CDBrickIDTable>& CDBrickIDTableTable::GetEntries() const {
+std::vector<CDBrickIDTable> CDBrickIDTableTable::GetEntries(void) const {
 	return this->entries;
 }
 

dDatabase/Tables/CDBrickIDTableTable.h

@@ -21,9 +21,9 @@ private:
 	std::vector<CDBrickIDTable> entries;
 
 public:
-	void LoadValuesFromDatabase();
+	CDBrickIDTableTable();
 	// Queries the table with a custom "where" clause
 	std::vector<CDBrickIDTable> Query(std::function<bool(CDBrickIDTable)> predicate);
 
-	const std::vector<CDBrickIDTable>& GetEntries() const;
+	std::vector<CDBrickIDTable> GetEntries(void) const;
 };

dDatabase/Tables/CDComponentsRegistryTable.cpp

@@ -1,7 +1,25 @@
 #include "CDComponentsRegistryTable.h"
 #include "eReplicaComponentType.h"
 
-void CDComponentsRegistryTable::LoadValuesFromDatabase() {
+#define CDCLIENT_CACHE_ALL
+
+CDComponentsRegistryTable::CDComponentsRegistryTable(void) {
+
+#ifdef CDCLIENT_CACHE_ALL
+	// First, get the size of the table
+	unsigned int size = 0;
+	auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM ComponentsRegistry");
+	while (!tableSize.eof()) {
+		size = tableSize.getIntField(0, 0);
+
+		tableSize.nextRow();
+	}
+
+	tableSize.finalize();
+
+	// Reserve the size
+	//this->entries.reserve(size);
+
 	// Now get the data
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM ComponentsRegistry");
 	while (!tableData.eof()) {
@@ -16,35 +34,60 @@ void CDComponentsRegistryTable::LoadValuesFromDatabase() {
 	}
 
 	tableData.finalize();
+#endif
 }
 
 int32_t CDComponentsRegistryTable::GetByIDAndType(uint32_t id, eReplicaComponentType componentType, int32_t defaultValue) {
-	auto iter = mappedEntries.find(((uint64_t)componentType) << 32 | ((uint64_t)id));
+	const auto& iter = this->mappedEntries.find(((uint64_t)componentType) << 32 | ((uint64_t)id));
 
 	if (iter == this->mappedEntries.end()) {
 		return defaultValue;
 	}
 
 	return iter->second;
-	// Now get the data
-	auto query = CDClientDatabase::CreatePreppedStmt("SELECT * FROM ComponentsRegistry WHERE id = ? AND component_type = ?;");
-	query.bind(1, static_cast<int32_t>(id));
-	query.bind(2, static_cast<int32_t>(componentType));
 
-	auto tableData = query.execQuery();
+#ifndef CDCLIENT_CACHE_ALL
+	// Now get the data
+	std::stringstream query;
+
+	query << "SELECT * FROM ComponentsRegistry WHERE id = " << std::to_string(id);
+
+	auto tableData = CDClientDatabase::ExecuteQuery(query.str());
 	while (!tableData.eof()) {
 		CDComponentsRegistry entry;
 		entry.id = tableData.getIntField("id", -1);
-		entry.component_type = static_cast<eReplicaComponentType>(tableData.getIntField("component_type", 0));
+		entry.component_type = tableData.getIntField("component_type", -1);
 		entry.component_id = tableData.getIntField("component_id", -1);
 
-		this->mappedEntries.insert_or_assign(((uint64_t)entry.component_type) << 32 | ((uint64_t)entry.id), entry.component_id);
+		//this->entries.push_back(entry);
+
+		//Darwin's stuff:
+		const auto& it = this->mappedEntries.find(entry.id);
+		if (it != mappedEntries.end()) {
+			const auto& iter = it->second.find(entry.component_type);
+			if (iter == it->second.end()) {
+				it->second.insert(std::make_pair(entry.component_type, entry.component_id));
+			}
+		} else {
+			std::map<unsigned int, unsigned int> map;
+			map.insert(std::make_pair(entry.component_type, entry.component_id));
+			this->mappedEntries.insert(std::make_pair(entry.id, map));
+		}
 
 		tableData.nextRow();
 	}
 
-	iter = this->mappedEntries.find(((uint64_t)componentType) << 32 | ((uint64_t)id));
+	tableData.finalize();
 
-	return iter == this->mappedEntries.end() ? defaultValue : iter->second;
+	const auto& it2 = this->mappedEntries.find(id);
+	if (it2 != mappedEntries.end()) {
+		const auto& iter = it2->second.find(componentType);
+		if (iter != it2->second.end()) {
+			return iter->second;
+		}
+	}
+
+	return defaultValue;
+#endif
 }
 

dDatabase/Tables/CDComponentsRegistryTable.h

@@ -16,6 +16,6 @@ private:
 	std::map<uint64_t, uint32_t> mappedEntries; //id, component_type, component_id
 
 public:
-	void LoadValuesFromDatabase();
+	CDComponentsRegistryTable();
 	int32_t GetByIDAndType(uint32_t id, eReplicaComponentType componentType, int32_t defaultValue = 0);
 };

dDatabase/Tables/CDCurrencyTableTable.cpp

@@ -1,7 +1,7 @@
 #include "CDCurrencyTableTable.h"
 
 //! Constructor
-void CDCurrencyTableTable::LoadValuesFromDatabase() {
+CDCurrencyTableTable::CDCurrencyTableTable(void) {
 
 	// First, get the size of the table
 	unsigned int size = 0;
@@ -43,7 +43,7 @@ std::vector<CDCurrencyTable> CDCurrencyTableTable::Query(std::function<bool(CDCu
 	return data;
 }
 
-const std::vector<CDCurrencyTable>& CDCurrencyTableTable::GetEntries() const {
+std::vector<CDCurrencyTable> CDCurrencyTableTable::GetEntries(void) const {
 	return this->entries;
 }
 

dDatabase/Tables/CDCurrencyTableTable.h

@@ -23,9 +23,9 @@ private:
 	std::vector<CDCurrencyTable> entries;
 
 public:
-	void LoadValuesFromDatabase();
+	CDCurrencyTableTable();
 	// Queries the table with a custom "where" clause
 	std::vector<CDCurrencyTable> Query(std::function<bool(CDCurrencyTable)> predicate);
 
-	const std::vector<CDCurrencyTable>& GetEntries() const;
+	std::vector<CDCurrencyTable> GetEntries(void) const;
 };

dDatabase/Tables/CDDestructibleComponentTable.cpp

@@ -1,6 +1,8 @@
 #include "CDDestructibleComponentTable.h"
 
-void CDDestructibleComponentTable::LoadValuesFromDatabase() {
+//! Constructor
+CDDestructibleComponentTable::CDDestructibleComponentTable(void) {
+
 	// First, get the size of the table
 	unsigned int size = 0;
 	auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM DestructibleComponent");
@@ -50,7 +52,7 @@ std::vector<CDDestructibleComponent> CDDestructibleComponentTable::Query(std::fu
 	return data;
 }
 
-const std::vector<CDDestructibleComponent>& CDDestructibleComponentTable::GetEntries() const {
+std::vector<CDDestructibleComponent> CDDestructibleComponentTable::GetEntries(void) const {
 	return this->entries;
 }
 

dDatabase/Tables/CDDestructibleComponentTable.h

@@ -25,9 +25,9 @@ private:
 	std::vector<CDDestructibleComponent> entries;
 
 public:
-	void LoadValuesFromDatabase();
+	CDDestructibleComponentTable();
 	// Queries the table with a custom "where" clause
 	std::vector<CDDestructibleComponent> Query(std::function<bool(CDDestructibleComponent)> predicate);
 
-	const std::vector<CDDestructibleComponent>& GetEntries(void) const;
+	std::vector<CDDestructibleComponent> GetEntries(void) const;
 };

dDatabase/Tables/CDEmoteTable.cpp

@@ -1,26 +1,40 @@
 #include "CDEmoteTable.h"
 
-void CDEmoteTableTable::LoadValuesFromDatabase() {
+//! Constructor
+CDEmoteTableTable::CDEmoteTableTable(void) {
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM Emotes");
 	while (!tableData.eof()) {
-		CDEmoteTable entry;
-		entry.ID = tableData.getIntField("id", -1);
-		entry.animationName = tableData.getStringField("animationName", "");
-		entry.iconFilename = tableData.getStringField("iconFilename", "");
-		entry.channel = tableData.getIntField("channel", -1);
-		entry.locked = tableData.getIntField("locked", -1) != 0;
-		entry.localize = tableData.getIntField("localize", -1) != 0;
-		entry.locState = tableData.getIntField("locStatus", -1);
-		entry.gateVersion = tableData.getStringField("gate_version", "");
+		CDEmoteTable* entry = new CDEmoteTable();
+		entry->ID = tableData.getIntField("id", -1);
+		entry->animationName = tableData.getStringField("animationName", "");
+		entry->iconFilename = tableData.getStringField("iconFilename", "");
+		entry->channel = tableData.getIntField("channel", -1);
+		entry->locked = tableData.getIntField("locked", -1) != 0;
+		entry->localize = tableData.getIntField("localize", -1) != 0;
+		entry->locState = tableData.getIntField("locStatus", -1);
+		entry->gateVersion = tableData.getStringField("gate_version", "");
 
-		entries.insert(std::make_pair(entry.ID, entry));
+		entries.insert(std::make_pair(entry->ID, entry));
 		tableData.nextRow();
 	}
 
 	tableData.finalize();
 }
 
-CDEmoteTable* CDEmoteTableTable::GetEmote(int id) {
-	auto itr = entries.find(id);
-	return itr != entries.end() ? &itr->second : nullptr;
+//! Destructor
+CDEmoteTableTable::~CDEmoteTableTable(void) {
+	for (auto e : entries) {
+		if (e.second) delete e.second;
+	}
+
+	entries.clear();
 }
+
+CDEmoteTable* CDEmoteTableTable::GetEmote(int id) {
+	for (auto e : entries) {
+		if (e.first == id) return e.second;
+	}
+
+	return nullptr;
+}
+

dDatabase/Tables/CDEmoteTable.h

@@ -28,10 +28,11 @@ struct CDEmoteTable {
 
 class CDEmoteTableTable : public CDTable<CDEmoteTableTable> {
 private:
-	std::map<int, CDEmoteTable> entries;
+	std::map<int, CDEmoteTable*> entries;
 
 public:
-	void LoadValuesFromDatabase();
+	CDEmoteTableTable();
+	~CDEmoteTableTable();
 	// Returns an emote by ID
 	CDEmoteTable* GetEmote(int id);
 };

dDatabase/Tables/CDFeatureGatingTable.cpp

@@ -1,6 +1,7 @@
 #include "CDFeatureGatingTable.h"
 
-void CDFeatureGatingTable::LoadValuesFromDatabase() {
+//! Constructor
+CDFeatureGatingTable::CDFeatureGatingTable(void) {
 
 	// First, get the size of the table
 	unsigned int size = 0;
@@ -52,7 +53,7 @@ bool CDFeatureGatingTable::FeatureUnlocked(const std::string& feature) const {
 	return false;
 }
 
-const std::vector<CDFeatureGating>& CDFeatureGatingTable::GetEntries() const {
+std::vector<CDFeatureGating> CDFeatureGatingTable::GetEntries(void) const {
 	return this->entries;
 }
 

dDatabase/Tables/CDFeatureGatingTable.h

@@ -16,12 +16,11 @@ private:
 	std::vector<CDFeatureGating> entries;
 
 public:
-	void LoadValuesFromDatabase();
-
+	CDFeatureGatingTable();
 	// Queries the table with a custom "where" clause
 	std::vector<CDFeatureGating> Query(std::function<bool(CDFeatureGating)> predicate);
 
 	bool FeatureUnlocked(const std::string& feature) const;
 
-	const std::vector<CDFeatureGating>& GetEntries(void) const;
+	std::vector<CDFeatureGating> GetEntries(void) const;
 };

dDatabase/Tables/CDInventoryComponentTable.cpp

@@ -1,6 +1,7 @@
 #include "CDInventoryComponentTable.h"
 
-void CDInventoryComponentTable::LoadValuesFromDatabase() {
+//! Constructor
+CDInventoryComponentTable::CDInventoryComponentTable(void) {
 
 	// First, get the size of the table
 	unsigned int size = 0;
@@ -41,7 +42,7 @@ std::vector<CDInventoryComponent> CDInventoryComponentTable::Query(std::function
 	return data;
 }
 
-const std::vector<CDInventoryComponent>& CDInventoryComponentTable::GetEntries() const {
+std::vector<CDInventoryComponent> CDInventoryComponentTable::GetEntries(void) const {
 	return this->entries;
 }
 

dDatabase/Tables/CDInventoryComponentTable.h

@@ -15,9 +15,9 @@ private:
 	std::vector<CDInventoryComponent> entries;
 
 public:
-	void LoadValuesFromDatabase();
+	CDInventoryComponentTable();
 	// Queries the table with a custom "where" clause
 	std::vector<CDInventoryComponent> Query(std::function<bool(CDInventoryComponent)> predicate);
 
-	const std::vector<CDInventoryComponent>& GetEntries() const;
+	std::vector<CDInventoryComponent> GetEntries(void) const;
 };

dDatabase/Tables/CDItemComponentTable.cpp

@@ -3,7 +3,11 @@
 
 CDItemComponent CDItemComponentTable::Default = {};
 
-void CDItemComponentTable::LoadValuesFromDatabase() {
+//! Constructor
+CDItemComponentTable::CDItemComponentTable(void) {
+	Default = CDItemComponent();
+
+#ifdef CDCLIENT_CACHE_ALL
 	// First, get the size of the table
 	unsigned int size = 0;
 	auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM ItemComponent");
@@ -51,13 +55,13 @@ void CDItemComponentTable::LoadValuesFromDatabase() {
 		entry.currencyLOT = tableData.getIntField("currencyLOT", -1);
 		entry.altCurrencyCost = tableData.getIntField("altCurrencyCost", -1);
 		entry.subItems = tableData.getStringField("subItems", "");
-		UNUSED_COLUMN(entry.audioEventUse = tableData.getStringField("audioEventUse", ""));
+		entry.audioEventUse = tableData.getStringField("audioEventUse", "");
 		entry.noEquipAnimation = tableData.getIntField("noEquipAnimation", -1) == 1 ? true : false;
 		entry.commendationLOT = tableData.getIntField("commendationLOT", -1);
 		entry.commendationCost = tableData.getIntField("commendationCost", -1);
-		UNUSED_COLUMN(entry.audioEquipMetaEventSet = tableData.getStringField("audioEquipMetaEventSet", ""));
+		entry.audioEquipMetaEventSet = tableData.getStringField("audioEquipMetaEventSet", "");
 		entry.currencyCosts = tableData.getStringField("currencyCosts", "");
-		UNUSED_COLUMN(entry.ingredientInfo = tableData.getStringField("ingredientInfo", ""));
+		entry.ingredientInfo = tableData.getStringField("ingredientInfo", "");
 		entry.locStatus = tableData.getIntField("locStatus", -1);
 		entry.forgeType = tableData.getIntField("forgeType", -1);
 		entry.SellMultiplier = tableData.getFloatField("SellMultiplier", -1.0f);
@@ -67,6 +71,7 @@ void CDItemComponentTable::LoadValuesFromDatabase() {
 	}
 
 	tableData.finalize();
+#endif
 }
 
 const CDItemComponent& CDItemComponentTable::GetItemComponentByID(unsigned int skillID) {
@@ -75,10 +80,12 @@ const CDItemComponent& CDItemComponentTable::GetItemComponentByID(unsigned int s
 		return it->second;
 	}
 
-	auto query = CDClientDatabase::CreatePreppedStmt("SELECT * FROM ItemComponent WHERE id = ?;");
-	query.bind(1, static_cast<int32_t>(skillID));
+#ifndef CDCLIENT_CACHE_ALL
+	std::stringstream query;
 
-	auto tableData = query.execQuery();
+	query << "SELECT * FROM ItemComponent WHERE id = " << std::to_string(skillID);
+
+	auto tableData = CDClientDatabase::ExecuteQuery(query.str());
 	if (tableData.eof()) {
 		entries.insert(std::make_pair(skillID, Default));
 		return Default;
@@ -137,6 +144,7 @@ const CDItemComponent& CDItemComponentTable::GetItemComponentByID(unsigned int s
 	if (it2 != this->entries.end()) {
 		return it2->second;
 	}
+#endif
 
 	return Default;
 }

dDatabase/Tables/CDItemComponentTable.h

@@ -54,7 +54,7 @@ private:
 	std::map<unsigned int, CDItemComponent> entries;
 
 public:
-	void LoadValuesFromDatabase();
+	CDItemComponentTable();
 	static std::map<LOT, uint32_t> ParseCraftingCurrencies(const CDItemComponent& itemComponent);
 
 	// Gets an entry by ID

dDatabase/Tables/CDItemSetSkillsTable.cpp

@@ -1,6 +1,7 @@
 #include "CDItemSetSkillsTable.h"
 
-void CDItemSetSkillsTable::LoadValuesFromDatabase() {
+//! Constructor
+CDItemSetSkillsTable::CDItemSetSkillsTable(void) {
 
 	// First, get the size of the table
 	unsigned int size = 0;
@@ -40,7 +41,7 @@ std::vector<CDItemSetSkills> CDItemSetSkillsTable::Query(std::function<bool(CDIt
 	return data;
 }
 
-const std::vector<CDItemSetSkills>& CDItemSetSkillsTable::GetEntries() const {
+std::vector<CDItemSetSkills> CDItemSetSkillsTable::GetEntries(void) const {
 	return this->entries;
 }
 

dDatabase/Tables/CDItemSetSkillsTable.h

@@ -14,11 +14,11 @@ private:
 	std::vector<CDItemSetSkills> entries;
 
 public:
-	void LoadValuesFromDatabase();
+	CDItemSetSkillsTable();
 	// Queries the table with a custom "where" clause
 	std::vector<CDItemSetSkills> Query(std::function<bool(CDItemSetSkills)> predicate);
 
-	const std::vector<CDItemSetSkills>& GetEntries() const;
+	std::vector<CDItemSetSkills> GetEntries(void) const;
 
 	std::vector<CDItemSetSkills> GetBySkillID(unsigned int SkillSetID);
 };

dDatabase/Tables/CDItemSetsTable.cpp

@@ -1,6 +1,7 @@
 #include "CDItemSetsTable.h"
 
-void CDItemSetsTable::LoadValuesFromDatabase() {
+//! Constructor
+CDItemSetsTable::CDItemSetsTable(void) {
 
 	// First, get the size of the table
 	unsigned int size = 0;
@@ -52,7 +53,7 @@ std::vector<CDItemSets> CDItemSetsTable::Query(std::function<bool(CDItemSets)> p
 	return data;
 }
 
-const std::vector<CDItemSets>& CDItemSetsTable::GetEntries() const {
+std::vector<CDItemSets> CDItemSetsTable::GetEntries(void) const {
 	return this->entries;
 }
 

dDatabase/Tables/CDItemSetsTable.h

@@ -26,10 +26,10 @@ private:
 	std::vector<CDItemSets> entries;
 
 public:
-	void LoadValuesFromDatabase();
+	CDItemSetsTable();
 	// Queries the table with a custom "where" clause
 	std::vector<CDItemSets> Query(std::function<bool(CDItemSets)> predicate);
 
-	const std::vector<CDItemSets>& GetEntries(void) const;
+	std::vector<CDItemSets> GetEntries(void) const;
 };
 

dDatabase/Tables/CDLevelProgressionLookupTable.cpp

@@ -1,6 +1,7 @@
 #include "CDLevelProgressionLookupTable.h"
 
-void CDLevelProgressionLookupTable::LoadValuesFromDatabase() {
+//! Constructor
+CDLevelProgressionLookupTable::CDLevelProgressionLookupTable(void) {
 
 	// First, get the size of the table
 	unsigned int size = 0;
@@ -31,6 +32,7 @@ void CDLevelProgressionLookupTable::LoadValuesFromDatabase() {
 	tableData.finalize();
 }
 
+//! Queries the table with a custom "where" clause
 std::vector<CDLevelProgressionLookup> CDLevelProgressionLookupTable::Query(std::function<bool(CDLevelProgressionLookup)> predicate) {
 
 	std::vector<CDLevelProgressionLookup> data = cpplinq::from(this->entries)
@@ -40,7 +42,8 @@ std::vector<CDLevelProgressionLookup> CDLevelProgressionLookupTable::Query(std::
 	return data;
 }
 
-const std::vector<CDLevelProgressionLookup>& CDLevelProgressionLookupTable::GetEntries() const {
+//! Gets all the entries in the table
+std::vector<CDLevelProgressionLookup> CDLevelProgressionLookupTable::GetEntries(void) const {
 	return this->entries;
 }
 

dDatabase/Tables/CDLevelProgressionLookupTable.h

@@ -14,10 +14,10 @@ private:
 	std::vector<CDLevelProgressionLookup> entries;
 
 public:
-	void LoadValuesFromDatabase();
-
+	CDLevelProgressionLookupTable();
 	// Queries the table with a custom "where" clause
 	std::vector<CDLevelProgressionLookup> Query(std::function<bool(CDLevelProgressionLookup)> predicate);
 
-	const std::vector<CDLevelProgressionLookup>& GetEntries() const;
+	// Gets all the entries in the table
+	std::vector<CDLevelProgressionLookup> GetEntries(void) const;
 };

dDatabase/Tables/CDLootMatrixTable.cpp

@@ -1,6 +1,7 @@
 #include "CDLootMatrixTable.h"
 
-void CDLootMatrixTable::LoadValuesFromDatabase() {
+//! Constructor
+CDLootMatrixTable::CDLootMatrixTable(void) {
 
 	// First, get the size of the table
 	unsigned int size = 0;
@@ -46,7 +47,7 @@ std::vector<CDLootMatrix> CDLootMatrixTable::Query(std::function<bool(CDLootMatr
 	return data;
 }
 
-const std::vector<CDLootMatrix>& CDLootMatrixTable::GetEntries() const {
+const std::vector<CDLootMatrix>& CDLootMatrixTable::GetEntries(void) const {
 	return this->entries;
 }
 

dDatabase/Tables/CDLootMatrixTable.h

@@ -20,10 +20,10 @@ private:
 	std::vector<CDLootMatrix> entries;
 
 public:
-	void LoadValuesFromDatabase();
+	CDLootMatrixTable();
 	// Queries the table with a custom "where" clause
 	std::vector<CDLootMatrix> Query(std::function<bool(CDLootMatrix)> predicate);
 
-	const std::vector<CDLootMatrix>& GetEntries() const;
+	const std::vector<CDLootMatrix>& GetEntries(void) const;
 };
 

dDatabase/Tables/CDLootTableTable.cpp

@@ -1,6 +1,7 @@
 #include "CDLootTableTable.h"
 
-void CDLootTableTable::LoadValuesFromDatabase() {
+//! Constructor
+CDLootTableTable::CDLootTableTable(void) {
 
 	// First, get the size of the table
 	unsigned int size = 0;
@@ -45,7 +46,7 @@ std::vector<CDLootTable> CDLootTableTable::Query(std::function<bool(CDLootTable)
 }
 
 //! Gets all the entries in the table
-const std::vector<CDLootTable>& CDLootTableTable::GetEntries() const {
+const std::vector<CDLootTable>& CDLootTableTable::GetEntries(void) const {
 	return this->entries;
 }
 

dDatabase/Tables/CDLootTableTable.h

@@ -16,10 +16,10 @@ private:
 	std::vector<CDLootTable> entries;
 
 public:
-	void LoadValuesFromDatabase();
+	CDLootTableTable();
 	// Queries the table with a custom "where" clause
 	std::vector<CDLootTable> Query(std::function<bool(CDLootTable)> predicate);
 
-	const std::vector<CDLootTable>& GetEntries() const;
+	const std::vector<CDLootTable>& GetEntries(void) const;
 };
 

dDatabase/Tables/CDMissionEmailTable.cpp

@@ -1,6 +1,7 @@
 #include "CDMissionEmailTable.h"
 
-void CDMissionEmailTable::LoadValuesFromDatabase() {
+//! Constructor
+CDMissionEmailTable::CDMissionEmailTable(void) {
 
 	// First, get the size of the table
 	unsigned int size = 0;
@@ -47,7 +48,7 @@ std::vector<CDMissionEmail> CDMissionEmailTable::Query(std::function<bool(CDMiss
 }
 
 //! Gets all the entries in the table
-const std::vector<CDMissionEmail>& CDMissionEmailTable::GetEntries() const {
+std::vector<CDMissionEmail> CDMissionEmailTable::GetEntries(void) const {
 	return this->entries;
 }
 

dDatabase/Tables/CDMissionEmailTable.h

@@ -20,9 +20,9 @@ private:
 	std::vector<CDMissionEmail> entries;
 
 public:
-	void LoadValuesFromDatabase();
+	CDMissionEmailTable();
 	// Queries the table with a custom "where" clause
 	std::vector<CDMissionEmail> Query(std::function<bool(CDMissionEmail)> predicate);
 
-	const std::vector<CDMissionEmail>& GetEntries() const;
+	std::vector<CDMissionEmail> GetEntries(void) const;
 };

dDatabase/Tables/CDMissionNPCComponentTable.cpp

@@ -1,6 +1,7 @@
 #include "CDMissionNPCComponentTable.h"
 
-void CDMissionNPCComponentTable::LoadValuesFromDatabase() {
+//! Constructor
+CDMissionNPCComponentTable::CDMissionNPCComponentTable(void) {
 
 	// First, get the size of the table
 	unsigned int size = 0;
@@ -44,7 +45,7 @@ std::vector<CDMissionNPCComponent> CDMissionNPCComponentTable::Query(std::functi
 }
 
 //! Gets all the entries in the table
-const std::vector<CDMissionNPCComponent>& CDMissionNPCComponentTable::GetEntries() const {
+std::vector<CDMissionNPCComponent> CDMissionNPCComponentTable::GetEntries(void) const {
 	return this->entries;
 }
 

dDatabase/Tables/CDMissionNPCComponentTable.h

@@ -16,12 +16,12 @@ private:
 	std::vector<CDMissionNPCComponent> entries;
 
 public:
-	void LoadValuesFromDatabase();
+	CDMissionNPCComponentTable();
 	// Queries the table with a custom "where" clause
 	std::vector<CDMissionNPCComponent> Query(std::function<bool(CDMissionNPCComponent)> predicate);
 
 	// Gets all the entries in the table
-	const std::vector<CDMissionNPCComponent>& GetEntries() const;
+	std::vector<CDMissionNPCComponent> GetEntries(void) const;
 
 };
 

dDatabase/Tables/CDMissionTasksTable.cpp

@@ -1,6 +1,7 @@
 #include "CDMissionTasksTable.h"
 
-void CDMissionTasksTable::LoadValuesFromDatabase() {
+//! Constructor
+CDMissionTasksTable::CDMissionTasksTable(void) {
 
 	// First, get the size of the table
 	unsigned int size = 0;
@@ -55,14 +56,16 @@ std::vector<CDMissionTasks*> CDMissionTasksTable::GetByMissionID(uint32_t missio
 
 	for (auto& entry : this->entries) {
 		if (entry.id == missionID) {
-			tasks.push_back(&entry);
+			CDMissionTasks* task = const_cast<CDMissionTasks*>(&entry);
+
+			tasks.push_back(task);
 		}
 	}
 
 	return tasks;
 }
 
-const std::vector<CDMissionTasks>& CDMissionTasksTable::GetEntries() const {
+const std::vector<CDMissionTasks>& CDMissionTasksTable::GetEntries(void) const {
 	return this->entries;
 }
 

dDatabase/Tables/CDMissionTasksTable.h

@@ -24,12 +24,12 @@ private:
 	std::vector<CDMissionTasks> entries;
 
 public:
-	void LoadValuesFromDatabase();
+	CDMissionTasksTable();
 	// Queries the table with a custom "where" clause
 	std::vector<CDMissionTasks> Query(std::function<bool(CDMissionTasks)> predicate);
 
 	std::vector<CDMissionTasks*> GetByMissionID(uint32_t missionID);
 
-	const std::vector<CDMissionTasks>& GetEntries() const;
+	const std::vector<CDMissionTasks>& GetEntries(void) const;
 };
 

dDatabase/Tables/CDMissionsTable.cpp

@@ -2,7 +2,8 @@
 
 CDMissions CDMissionsTable::Default = {};
 
-void CDMissionsTable::LoadValuesFromDatabase() {
+//! Constructor
+CDMissionsTable::CDMissionsTable(void) {
 
 	// First, get the size of the table
 	unsigned int size = 0;

dDatabase/Tables/CDMissionsTable.h

@@ -65,12 +65,12 @@ private:
 	std::vector<CDMissions> entries;
 
 public:
-	void LoadValuesFromDatabase();
+	CDMissionsTable();
 	// Queries the table with a custom "where" clause
 	std::vector<CDMissions> Query(std::function<bool(CDMissions)> predicate);
 
 	// Gets all the entries in the table
-	const std::vector<CDMissions>& GetEntries() const;
+	const std::vector<CDMissions>& GetEntries(void) const;
 
 	const CDMissions* GetPtrByMissionID(uint32_t missionID) const;
 

dDatabase/Tables/CDMovementAIComponentTable.cpp

@@ -1,6 +1,7 @@
 #include "CDMovementAIComponentTable.h"
 
-void CDMovementAIComponentTable::LoadValuesFromDatabase() {
+//! Constructor
+CDMovementAIComponentTable::CDMovementAIComponentTable(void) {
 
 	// First, get the size of the table
 	unsigned int size = 0;
@@ -36,6 +37,7 @@ void CDMovementAIComponentTable::LoadValuesFromDatabase() {
 	tableData.finalize();
 }
 
+//! Queries the table with a custom "where" clause
 std::vector<CDMovementAIComponent> CDMovementAIComponentTable::Query(std::function<bool(CDMovementAIComponent)> predicate) {
 
 	std::vector<CDMovementAIComponent> data = cpplinq::from(this->entries)
@@ -45,7 +47,8 @@ std::vector<CDMovementAIComponent> CDMovementAIComponentTable::Query(std::functi
 	return data;
 }
 
-const std::vector<CDMovementAIComponent>& CDMovementAIComponentTable::GetEntries(void) const {
+//! Gets all the entries in the table
+std::vector<CDMovementAIComponent> CDMovementAIComponentTable::GetEntries(void) const {
 	return this->entries;
 }
 

dDatabase/Tables/CDMovementAIComponentTable.h

@@ -19,10 +19,10 @@ private:
 	std::vector<CDMovementAIComponent> entries;
 
 public:
-	void LoadValuesFromDatabase();
+	CDMovementAIComponentTable();
 	// Queries the table with a custom "where" clause
 	std::vector<CDMovementAIComponent> Query(std::function<bool(CDMovementAIComponent)> predicate);
 
 	// Gets all the entries in the table
-	const std::vector<CDMovementAIComponent>& GetEntries() const;
+	std::vector<CDMovementAIComponent> GetEntries(void) const;
 };

dDatabase/Tables/CDObjectSkillsTable.cpp

@@ -1,6 +1,7 @@
 #include "CDObjectSkillsTable.h"
 
-void CDObjectSkillsTable::LoadValuesFromDatabase() {
+//! Constructor
+CDObjectSkillsTable::CDObjectSkillsTable(void) {
 
 	// First, get the size of the table
 	unsigned int size = 0;
@@ -32,6 +33,7 @@ void CDObjectSkillsTable::LoadValuesFromDatabase() {
 	tableData.finalize();
 }
 
+//! Queries the table with a custom "where" clause
 std::vector<CDObjectSkills> CDObjectSkillsTable::Query(std::function<bool(CDObjectSkills)> predicate) {
 
 	std::vector<CDObjectSkills> data = cpplinq::from(this->entries)
@@ -41,6 +43,7 @@ std::vector<CDObjectSkills> CDObjectSkillsTable::Query(std::function<bool(CDObje
 	return data;
 }
 
-const std::vector<CDObjectSkills>& CDObjectSkillsTable::GetEntries() const {
+//! Gets all the entries in the table
+std::vector<CDObjectSkills> CDObjectSkillsTable::GetEntries(void) const {
 	return this->entries;
 }

dDatabase/Tables/CDObjectSkillsTable.h

@@ -15,12 +15,12 @@ private:
 	std::vector<CDObjectSkills> entries;
 
 public:
-	void LoadValuesFromDatabase();
+	CDObjectSkillsTable();
 	// Queries the table with a custom "where" clause
 	std::vector<CDObjectSkills> Query(std::function<bool(CDObjectSkills)> predicate);
 
 	// Gets all the entries in the table
-	const std::vector<CDObjectSkills>& GetEntries() const;
+	std::vector<CDObjectSkills> GetEntries(void) const;
 
 };
 

dDatabase/Tables/CDObjectsTable.cpp

@@ -1,6 +1,8 @@
 #include "CDObjectsTable.h"
 
-void CDObjectsTable::LoadValuesFromDatabase() {
+//! Constructor
+CDObjectsTable::CDObjectsTable(void) {
+#ifdef CDCLIENT_CACHE_ALL
 	// First, get the size of the table
 	unsigned int size = 0;
 	auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM Objects");
@@ -18,24 +20,25 @@ void CDObjectsTable::LoadValuesFromDatabase() {
 		CDObjects entry;
 		entry.id = tableData.getIntField("id", -1);
 		entry.name = tableData.getStringField("name", "");
-		UNUSED_COLUMN(entry.placeable = tableData.getIntField("placeable", -1);)
+		entry.placeable = tableData.getIntField("placeable", -1);
 		entry.type = tableData.getStringField("type", "");
-		UNUSED_COLUMN(entry.description = tableData.getStringField("description", "");)
-		UNUSED_COLUMN(entry.localize = tableData.getIntField("localize", -1);)
-		UNUSED_COLUMN(entry.npcTemplateID = tableData.getIntField("npcTemplateID", -1);)
-		UNUSED_COLUMN(entry.displayName = tableData.getStringField("displayName", "");)
+		entry.description = tableData.getStringField("description", "");
+		entry.localize = tableData.getIntField("localize", -1);
+		entry.npcTemplateID = tableData.getIntField("npcTemplateID", -1);
+		entry.displayName = tableData.getStringField("displayName", "");
 		entry.interactionDistance = tableData.getFloatField("interactionDistance", -1.0f);
-		UNUSED_COLUMN(entry.nametag = tableData.getIntField("nametag", -1);)
-		UNUSED_COLUMN(entry._internalNotes = tableData.getStringField("_internalNotes", "");)
-		UNUSED_COLUMN(entry.locStatus = tableData.getIntField("locStatus", -1);)
-		UNUSED_COLUMN(entry.gate_version = tableData.getStringField("gate_version", "");)
-		UNUSED_COLUMN(entry.HQ_valid = tableData.getIntField("HQ_valid", -1);)
+		entry.nametag = tableData.getIntField("nametag", -1);
+		entry._internalNotes = tableData.getStringField("_internalNotes", "");
+		entry.locStatus = tableData.getIntField("locStatus", -1);
+		entry.gate_version = tableData.getStringField("gate_version", "");
+		entry.HQ_valid = tableData.getIntField("HQ_valid", -1);
 
 		this->entries.insert(std::make_pair(entry.id, entry));
 		tableData.nextRow();
 	}
 
 	tableData.finalize();
+#endif
 
 	m_default.id = 0;
 }
@@ -46,10 +49,12 @@ const CDObjects& CDObjectsTable::GetByID(unsigned int LOT) {
 		return it->second;
 	}
 
-	auto query = CDClientDatabase::CreatePreppedStmt("SELECT * FROM Objects WHERE id = ?;");
-	query.bind(1, static_cast<int32_t>(LOT));
+#ifndef CDCLIENT_CACHE_ALL
+	std::stringstream query;
 
-	auto tableData = query.execQuery();
+	query << "SELECT * FROM Objects WHERE id = " << std::to_string(LOT);
+
+	auto tableData = CDClientDatabase::ExecuteQuery(query.str());
 	if (tableData.eof()) {
 		this->entries.insert(std::make_pair(LOT, m_default));
 		return m_default;
@@ -83,6 +88,7 @@ const CDObjects& CDObjectsTable::GetByID(unsigned int LOT) {
 	if (it2 != entries.end()) {
 		return it2->second;
 	}
+#endif
 
 	return m_default;
 }

dDatabase/Tables/CDObjectsTable.h

@@ -26,7 +26,7 @@ private:
 	CDObjects m_default;
 
 public:
-	void LoadValuesFromDatabase();
+	CDObjectsTable();
 	// Gets an entry by ID
 	const CDObjects& GetByID(unsigned int LOT);
 };

dDatabase/Tables/CDPackageComponentTable.cpp

@@ -1,6 +1,7 @@
 #include "CDPackageComponentTable.h"
 
-void CDPackageComponentTable::LoadValuesFromDatabase() {
+//! Constructor
+CDPackageComponentTable::CDPackageComponentTable(void) {
 
 	// First, get the size of the table
 	unsigned int size = 0;
@@ -42,7 +43,7 @@ std::vector<CDPackageComponent> CDPackageComponentTable::Query(std::function<boo
 }
 
 //! Gets all the entries in the table
-const std::vector<CDPackageComponent>& CDPackageComponentTable::GetEntries() const {
+std::vector<CDPackageComponent> CDPackageComponentTable::GetEntries(void) const {
 	return this->entries;
 }
 

dDatabase/Tables/CDPackageComponentTable.h

@@ -14,9 +14,9 @@ private:
 	std::vector<CDPackageComponent> entries;
 
 public:
-	void LoadValuesFromDatabase();
+	CDPackageComponentTable(void);
 	// Queries the table with a custom "where" clause
 	std::vector<CDPackageComponent> Query(std::function<bool(CDPackageComponent)> predicate);
 
-	const std::vector<CDPackageComponent>& GetEntries() const;
+	std::vector<CDPackageComponent> GetEntries(void) const;
 };

dDatabase/Tables/CDPhysicsComponentTable.cpp

@@ -1,35 +1,46 @@
 #include "CDPhysicsComponentTable.h"
 
-void CDPhysicsComponentTable::LoadValuesFromDatabase() {
+CDPhysicsComponentTable::CDPhysicsComponentTable(void) {
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM PhysicsComponent");
 	while (!tableData.eof()) {
-		CDPhysicsComponent entry;
-		entry.id = tableData.getIntField("id", -1);
-		entry.bStatic = tableData.getIntField("static", -1) != 0;
-		entry.physicsAsset = tableData.getStringField("physics_asset", "");
+		CDPhysicsComponent* entry = new CDPhysicsComponent();
+		entry->id = tableData.getIntField("id", -1);
+		entry->bStatic = tableData.getIntField("static", -1) != 0;
+		entry->physicsAsset = tableData.getStringField("physics_asset", "");
 		UNUSED(entry->jump = tableData.getIntField("jump", -1) != 0);
 		UNUSED(entry->doublejump = tableData.getIntField("doublejump", -1) != 0);
-		entry.speed = tableData.getFloatField("speed", -1);
+		entry->speed = tableData.getFloatField("speed", -1);
 		UNUSED(entry->rotSpeed = tableData.getFloatField("rotSpeed", -1));
-		entry.playerHeight = tableData.getFloatField("playerHeight");
-		entry.playerRadius = tableData.getFloatField("playerRadius");
-		entry.pcShapeType = tableData.getIntField("pcShapeType");
-		entry.collisionGroup = tableData.getIntField("collisionGroup");
+		entry->playerHeight = tableData.getFloatField("playerHeight");
+		entry->playerRadius = tableData.getFloatField("playerRadius");
+		entry->pcShapeType = tableData.getIntField("pcShapeType");
+		entry->collisionGroup = tableData.getIntField("collisionGroup");
 		UNUSED(entry->airSpeed = tableData.getFloatField("airSpeed"));
 		UNUSED(entry->boundaryAsset = tableData.getStringField("boundaryAsset"));
 		UNUSED(entry->jumpAirSpeed = tableData.getFloatField("jumpAirSpeed"));
 		UNUSED(entry->friction = tableData.getFloatField("friction"));
 		UNUSED(entry->gravityVolumeAsset = tableData.getStringField("gravityVolumeAsset"));
 
-		m_entries.insert(std::make_pair(entry.id, entry));
+		m_entries.insert(std::make_pair(entry->id, entry));
 		tableData.nextRow();
 	}
 
 	tableData.finalize();
 }
 
-CDPhysicsComponent* CDPhysicsComponentTable::GetByID(unsigned int componentID) {
-	auto itr = m_entries.find(componentID);
-	return itr != m_entries.end() ? &itr->second : nullptr;
+CDPhysicsComponentTable::~CDPhysicsComponentTable() {
+	for (auto e : m_entries) {
+		if (e.second) delete e.second;
+	}
+
+	m_entries.clear();
+}
+
+CDPhysicsComponent* CDPhysicsComponentTable::GetByID(unsigned int componentID) {
+	for (auto e : m_entries) {
+		if (e.first == componentID) return e.second;
+	}
+
+	return nullptr;
 }
 

dDatabase/Tables/CDPhysicsComponentTable.h

@@ -23,11 +23,12 @@ struct CDPhysicsComponent {
 
 class CDPhysicsComponentTable : public CDTable<CDPhysicsComponentTable> {
 public:
-	void LoadValuesFromDatabase();
+	CDPhysicsComponentTable();
+	~CDPhysicsComponentTable();
 
 	static const std::string GetTableName() { return "PhysicsComponent"; };
 	CDPhysicsComponent* GetByID(unsigned int componentID);
 
 private:
-	std::map<unsigned int, CDPhysicsComponent> m_entries;
+	std::map<unsigned int, CDPhysicsComponent*> m_entries;
 };

dDatabase/Tables/CDPropertyEntranceComponentTable.cpp

@@ -1,6 +1,7 @@
+
 #include "CDPropertyEntranceComponentTable.h"
 
-void CDPropertyEntranceComponentTable::LoadValuesFromDatabase() {
+CDPropertyEntranceComponentTable::CDPropertyEntranceComponentTable() {
 
 	// First, get the size of the table
 	size_t size = 0;

dDatabase/Tables/CDPropertyEntranceComponentTable.h

@@ -11,12 +11,12 @@ struct CDPropertyEntranceComponent {
 
 class CDPropertyEntranceComponentTable : public CDTable<CDPropertyEntranceComponentTable> {
 public:
-	void LoadValuesFromDatabase();
+	CDPropertyEntranceComponentTable();
 	// Queries the table with a custom "where" clause
 	CDPropertyEntranceComponent GetByID(uint32_t id);
 
 	// Gets all the entries in the table
-	[[nodiscard]] const std::vector<CDPropertyEntranceComponent>& GetEntries() const { return entries; }
+	[[nodiscard]] std::vector<CDPropertyEntranceComponent> GetEntries() const { return entries; }
 private:
 	std::vector<CDPropertyEntranceComponent> entries{};
 	CDPropertyEntranceComponent defaultEntry{};

dDatabase/Tables/CDPropertyTemplateTable.cpp

@@ -1,6 +1,6 @@
 #include "CDPropertyTemplateTable.h"
 
-void CDPropertyTemplateTable::LoadValuesFromDatabase() {
+CDPropertyTemplateTable::CDPropertyTemplateTable() {
 
 	// First, get the size of the table
 	size_t size = 0;

dDatabase/Tables/CDPropertyTemplateTable.h

@@ -10,7 +10,7 @@ struct CDPropertyTemplate {
 
 class CDPropertyTemplateTable : public CDTable<CDPropertyTemplateTable> {
 public:
-	void LoadValuesFromDatabase();
+	CDPropertyTemplateTable();
 
 	static const std::string GetTableName() { return "PropertyTemplate"; };
 	CDPropertyTemplate GetByMapID(uint32_t mapID);

dDatabase/Tables/CDProximityMonitorComponentTable.cpp

@@ -1,6 +1,7 @@
 #include "CDProximityMonitorComponentTable.h"
 
-void CDProximityMonitorComponentTable::LoadValuesFromDatabase() {
+//! Constructor
+CDProximityMonitorComponentTable::CDProximityMonitorComponentTable(void) {
 
 	// First, get the size of the table
 	unsigned int size = 0;
@@ -32,6 +33,7 @@ void CDProximityMonitorComponentTable::LoadValuesFromDatabase() {
 	tableData.finalize();
 }
 
+//! Queries the table with a custom "where" clause
 std::vector<CDProximityMonitorComponent> CDProximityMonitorComponentTable::Query(std::function<bool(CDProximityMonitorComponent)> predicate) {
 
 	std::vector<CDProximityMonitorComponent> data = cpplinq::from(this->entries)
@@ -41,7 +43,8 @@ std::vector<CDProximityMonitorComponent> CDProximityMonitorComponentTable::Query
 	return data;
 }
 
-const std::vector<CDProximityMonitorComponent>& CDProximityMonitorComponentTable::GetEntries() const {
+//! Gets all the entries in the table
+std::vector<CDProximityMonitorComponent> CDProximityMonitorComponentTable::GetEntries(void) const {
 	return this->entries;
 }
 

dDatabase/Tables/CDProximityMonitorComponentTable.h

@@ -15,9 +15,9 @@ private:
 	std::vector<CDProximityMonitorComponent> entries;
 
 public:
-	void LoadValuesFromDatabase();
+	CDProximityMonitorComponentTable(void);
 	//! Queries the table with a custom "where" clause
 	std::vector<CDProximityMonitorComponent> Query(std::function<bool(CDProximityMonitorComponent)> predicate);
 
-	const std::vector<CDProximityMonitorComponent>& GetEntries() const;
+	std::vector<CDProximityMonitorComponent> GetEntries(void) const;
 };

dDatabase/Tables/CDRailActivatorComponent.cpp

@@ -1,7 +1,7 @@
 #include "CDRailActivatorComponent.h"
 #include "GeneralUtils.h"
 
-void CDRailActivatorComponentTable::LoadValuesFromDatabase() {
+CDRailActivatorComponentTable::CDRailActivatorComponentTable() {
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM RailActivatorComponent;");
 	while (!tableData.eof()) {
 		CDRailActivatorComponent entry;
@@ -52,7 +52,7 @@ CDRailActivatorComponent CDRailActivatorComponentTable::GetEntryByID(int32_t id)
 	return {};
 }
 
-const std::vector<CDRailActivatorComponent>& CDRailActivatorComponentTable::GetEntries() const {
+std::vector<CDRailActivatorComponent> CDRailActivatorComponentTable::GetEntries() const {
 	return m_Entries;
 }
 

dDatabase/Tables/CDRailActivatorComponent.h

@@ -22,10 +22,10 @@ struct CDRailActivatorComponent {
 
 class CDRailActivatorComponentTable : public CDTable<CDRailActivatorComponentTable> {
 public:
-	void LoadValuesFromDatabase();
+	CDRailActivatorComponentTable();
 	static const std::string GetTableName() { return "RailActivatorComponent"; };
 	[[nodiscard]] CDRailActivatorComponent GetEntryByID(int32_t id) const;
-	[[nodiscard]] const std::vector<CDRailActivatorComponent>& GetEntries() const;
+	[[nodiscard]] std::vector<CDRailActivatorComponent> GetEntries() const;
 private:
 	static std::pair<uint32_t, std::u16string> EffectPairFromString(std::string& str);
 	std::vector<CDRailActivatorComponent> m_Entries{};

dDatabase/Tables/CDRarityTableTable.cpp

@@ -1,16 +1,32 @@
 #include "CDRarityTableTable.h"
 
-void CDRarityTableTable::LoadValuesFromDatabase() {
+//! Constructor
+CDRarityTableTable::CDRarityTableTable(void) {
+
+	// First, get the size of the table
+	unsigned int size = 0;
+	auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM RarityTable");
+	while (!tableSize.eof()) {
+		size = tableSize.getIntField(0, 0);
+
+		tableSize.nextRow();
+	}
+
+	tableSize.finalize();
+
+	// Reserve the size
+	this->entries.reserve(size);
+
 	// Now get the data
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM RarityTable");
 	while (!tableData.eof()) {
 		CDRarityTable entry;
-		uint32_t id = tableData.getIntField("id", -1);
+		entry.id = tableData.getIntField("id", -1);
 		entry.randmax = tableData.getFloatField("randmax", -1);
 		entry.rarity = tableData.getIntField("rarity", -1);
 		entry.RarityTableIndex = tableData.getIntField("RarityTableIndex", -1);
 
-		this->entries.insert_or_assign(id, entry);
+		this->entries.push_back(entry);
 		tableData.nextRow();
 	}
 
@@ -18,7 +34,17 @@ void CDRarityTableTable::LoadValuesFromDatabase() {
 }
 
 //! Queries the table with a custom "where" clause
-const std::optional<CDRarityTable> CDRarityTableTable::Get(uint32_t id) {
-	auto it = this->entries.find(id);
-	return it != this->entries.end() ? std::make_optional(it->second) : std::nullopt;
+std::vector<CDRarityTable> CDRarityTableTable::Query(std::function<bool(CDRarityTable)> predicate) {
+
+	std::vector<CDRarityTable> data = cpplinq::from(this->entries)
+		>> cpplinq::where(predicate)
+		>> cpplinq::to_vector();
+
+	return data;
 }
+
+//! Gets all the entries in the table
+const std::vector<CDRarityTable>& CDRarityTableTable::GetEntries(void) const {
+	return this->entries;
+}
+

dDatabase/Tables/CDRarityTableTable.h

@@ -28,11 +28,13 @@ struct CDRarityTable {
 
 class CDRarityTableTable : public CDTable<CDRarityTableTable> {
 private:
-	std::unordered_map<uint32_t, CDRarityTable> entries;
+	std::vector<CDRarityTable> entries;
 
 public:
-	void LoadValuesFromDatabase();
+	CDRarityTableTable();
 	// Queries the table with a custom "where" clause
-	const std::optional<CDRarityTable> Get(uint32_t predicate);
+	std::vector<CDRarityTable> Query(std::function<bool(CDRarityTable)> predicate);
+
+	const std::vector<CDRarityTable>& GetEntries() const;
 };
 

dDatabase/Tables/CDRebuildComponentTable.cpp

@@ -1,11 +1,27 @@
 #include "CDRebuildComponentTable.h"
 
-void CDRebuildComponentTable::LoadValuesFromDatabase() {
+//! Constructor
+CDRebuildComponentTable::CDRebuildComponentTable(void) {
+
+	// First, get the size of the table
+	unsigned int size = 0;
+	auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM RebuildComponent");
+	while (!tableSize.eof()) {
+		size = tableSize.getIntField(0, 0);
+
+		tableSize.nextRow();
+	}
+
+	tableSize.finalize();
+
+	// Reserve the size
+	this->entries.reserve(size);
+
 	// Now get the data
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM RebuildComponent");
 	while (!tableData.eof()) {
 		CDRebuildComponent entry;
-		uint32_t id = tableData.getIntField("id", -1);
+		entry.id = tableData.getIntField("id", -1);
 		entry.reset_time = tableData.getFloatField("reset_time", -1.0f);
 		entry.complete_time = tableData.getFloatField("complete_time", -1.0f);
 		entry.take_imagination = tableData.getIntField("take_imagination", -1);
@@ -16,12 +32,25 @@ void CDRebuildComponentTable::LoadValuesFromDatabase() {
 		entry.post_imagination_cost = tableData.getIntField("post_imagination_cost", -1);
 		entry.time_before_smash = tableData.getFloatField("time_before_smash", -1.0f);
 
-		this->entries.insert_or_assign(id, entry);
+		this->entries.push_back(entry);
 		tableData.nextRow();
 	}
+
+	tableData.finalize();
 }
 
-const std::optional<CDRebuildComponent> CDRebuildComponentTable::Get(uint32_t componentId) {
-	auto it = this->entries.find(componentId);
-	return it != this->entries.end() ? std::make_optional(it->second) : std::nullopt;
+//! Queries the table with a custom "where" clause
+std::vector<CDRebuildComponent> CDRebuildComponentTable::Query(std::function<bool(CDRebuildComponent)> predicate) {
+
+	std::vector<CDRebuildComponent> data = cpplinq::from(this->entries)
+		>> cpplinq::where(predicate)
+		>> cpplinq::to_vector();
+
+	return data;
 }
+
+//! Gets all the entries in the table
+std::vector<CDRebuildComponent> CDRebuildComponentTable::GetEntries(void) const {
+	return this->entries;
+}
+

dDatabase/Tables/CDRebuildComponentTable.h

@@ -4,6 +4,7 @@
 #include "CDTable.h"
 
 struct CDRebuildComponent {
+	unsigned int id;                        //!< The component Id
 	float reset_time;               //!< The reset time
 	float complete_time;            //!< The complete time
 	unsigned int take_imagination;          //!< The amount of imagination it costs
@@ -17,11 +18,13 @@ struct CDRebuildComponent {
 
 class CDRebuildComponentTable : public CDTable<CDRebuildComponentTable> {
 private:
-	std::unordered_map<uint32_t, CDRebuildComponent> entries;
+	std::vector<CDRebuildComponent> entries;
 
 public:
-	void LoadValuesFromDatabase();
+	CDRebuildComponentTable();
 	// Queries the table with a custom "where" clause
-	const std::optional<CDRebuildComponent> Get(uint32_t componentId);
+	std::vector<CDRebuildComponent> Query(std::function<bool(CDRebuildComponent)> predicate);
+
+	std::vector<CDRebuildComponent> GetEntries() const;
 };
 

dDatabase/Tables/CDRewardsTable.cpp

@@ -1,27 +1,35 @@
 #include "CDRewardsTable.h"
 
-void CDRewardsTable::LoadValuesFromDatabase() {
+CDRewardsTable::CDRewardsTable(void) {
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM Rewards");
 	while (!tableData.eof()) {
-		CDRewards entry;
-		uint32_t id = tableData.getIntField("id", -1);
-		entry.levelID = tableData.getIntField("LevelID", -1);
-		entry.missionID = tableData.getIntField("MissionID", -1);
-		entry.rewardType = tableData.getIntField("RewardType", -1);
-		entry.value = tableData.getIntField("value", -1);
-		entry.count = tableData.getIntField("count", -1);
+		CDRewards* entry = new CDRewards();
+		entry->id = tableData.getIntField("id", -1);
+		entry->levelID = tableData.getIntField("LevelID", -1);
+		entry->missionID = tableData.getIntField("MissionID", -1);
+		entry->rewardType = tableData.getIntField("RewardType", -1);
+		entry->value = tableData.getIntField("value", -1);
+		entry->count = tableData.getIntField("count", -1);
 
-		m_entries.push_back(entry);
+		m_entries.insert(std::make_pair(entry->id, entry));
 		tableData.nextRow();
 	}
 
 	tableData.finalize();
 }
 
-std::vector<CDRewards> CDRewardsTable::GetByLevelID(uint32_t levelID) {
-	std::vector<CDRewards> result;
-	for (const auto& levelData : m_entries) {
-		if (levelData.levelID == levelID) result.push_back(levelData);
+CDRewardsTable::~CDRewardsTable(void) {
+	for (auto e : m_entries) {
+		if (e.second) delete e.second;
+	}
+
+	m_entries.clear();
+}
+
+std::vector<CDRewards*> CDRewardsTable::GetByLevelID(uint32_t levelID) {
+	std::vector<CDRewards*> result{};
+	for (const auto& e : m_entries) {
+		if (e.second->levelID == levelID) result.push_back(e.second);
 	}
 
 	return result;

dDatabase/Tables/CDRewardsTable.h

@@ -3,6 +3,7 @@
 #include <string>
 
 struct CDRewards {
+	int32_t id;
 	int32_t levelID;
 	int32_t missionID;
 	int32_t rewardType;
@@ -12,8 +13,12 @@ struct CDRewards {
 
 class CDRewardsTable : public CDTable<CDRewardsTable> {
 public:
-	void LoadValuesFromDatabase();
-	std::vector<CDRewards> GetByLevelID(uint32_t levelID);
+	CDRewardsTable();
+	~CDRewardsTable();
+
+	static const std::string GetTableName() { return "Rewards"; };
+	std::vector<CDRewards*> GetByLevelID(uint32_t levelID);
+
 private:
-	std::vector<CDRewards> m_entries;
+	std::map<uint32_t, CDRewards*> m_entries;
 };

dDatabase/Tables/CDScriptComponentTable.cpp

@@ -1,21 +1,40 @@
 #include "CDScriptComponentTable.h"
 
-void CDScriptComponentTable::LoadValuesFromDatabase() {
+//! Constructor
+CDScriptComponentTable::CDScriptComponentTable(void) {
+
+	// First, get the size of the table
+	unsigned int size = 0;
+	auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM ScriptComponent");
+	while (!tableSize.eof()) {
+		size = tableSize.getIntField(0, 0);
+
+		tableSize.nextRow();
+	}
+
+	tableSize.finalize();
+
 	// Now get the data
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM ScriptComponent");
 	while (!tableData.eof()) {
 		CDScriptComponent entry;
-		uint32_t id = tableData.getIntField("id", -1);
+		entry.id = tableData.getIntField("id", -1);
 		entry.script_name = tableData.getStringField("script_name", "");
 		entry.client_script_name = tableData.getStringField("client_script_name", "");
 
-		this->entries.insert_or_assign(id, entry);
+		this->entries.insert(std::make_pair(entry.id, entry));
 		tableData.nextRow();
 	}
+
+	tableData.finalize();
 }
 
-const std::optional<CDScriptComponent> CDScriptComponentTable::GetByID(unsigned int id) {
-	auto it = this->entries.find(id);
-	return (it != this->entries.end()) ? std::make_optional<CDScriptComponent>(it->second) : std::nullopt;
+const CDScriptComponent& CDScriptComponentTable::GetByID(unsigned int id) {
+	std::map<unsigned int, CDScriptComponent>::iterator it = this->entries.find(id);
+	if (it != this->entries.end()) {
+		return it->second;
+	}
+
+	return m_ToReturnWhenNoneFound;
 }
 

dDatabase/Tables/CDScriptComponentTable.h

@@ -4,16 +4,19 @@
 #include "CDTable.h"
 
 struct CDScriptComponent {
-	std::string script_name;           		//!< The script name
-	std::string client_script_name;   		//!< The client script name
+	unsigned int id;                        //!< The component ID
+	std::string script_name;           //!< The script name
+	std::string client_script_name;    //!< The client script name
 };
 
 class CDScriptComponentTable : public CDTable<CDScriptComponentTable> {
 private:
-	std::unordered_map<unsigned int, CDScriptComponent> entries;
+	std::map<unsigned int, CDScriptComponent> entries;
+	CDScriptComponent m_ToReturnWhenNoneFound;
+
 public:
-	void LoadValuesFromDatabase();
+	CDScriptComponentTable();
 	// Gets an entry by scriptID
-	const std::optional<CDScriptComponent> GetByID(unsigned int id);
+	const CDScriptComponent& GetByID(unsigned int id);
 };
 

dDatabase/Tables/CDSkillBehaviorTable.cpp

@@ -1,10 +1,29 @@
 #include "CDSkillBehaviorTable.h"
+//#include "Logger.hpp"
 
-void CDSkillBehaviorTable::LoadValuesFromDatabase() {
+//! Constructor
+CDSkillBehaviorTable::CDSkillBehaviorTable(void) {
+	m_empty = CDSkillBehavior();
+
+	// First, get the size of the table
+	unsigned int size = 0;
+	auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM SkillBehavior");
+	while (!tableSize.eof()) {
+		size = tableSize.getIntField(0, 0);
+
+		tableSize.nextRow();
+	}
+
+	tableSize.finalize();
+
+	// Reserve the size
+	//this->entries.reserve(size);
+
+	// Now get the data
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM SkillBehavior");
 	while (!tableData.eof()) {
 		CDSkillBehavior entry;
-		uint32_t skillID = tableData.getIntField("skillID", -1);
+		entry.skillID = tableData.getIntField("skillID", -1);
 		UNUSED(entry.locStatus = tableData.getIntField("locStatus", -1));
 		entry.behaviorID = tableData.getIntField("behaviorID", -1);
 		entry.imaginationcost = tableData.getIntField("imaginationcost", -1);
@@ -24,13 +43,27 @@ void CDSkillBehaviorTable::LoadValuesFromDatabase() {
 		UNUSED(entry.gate_version = tableData.getStringField("gate_version", ""));
 		UNUSED(entry.cancelType = tableData.getIntField("cancelType", -1));
 
-		this->entries.insert_or_assign(skillID, entry);
+		this->entries.insert(std::make_pair(entry.skillID, entry));
+		//this->entries.push_back(entry);
 		tableData.nextRow();
 	}
+
+	tableData.finalize();
 }
 
-const std::optional<CDSkillBehavior> CDSkillBehaviorTable::GetSkillByID(unsigned int skillID) {
-	auto it = this->entries.find(skillID);
-	return it != this->entries.end() ? std::make_optional(it->second) : std::nullopt;
+//! Queries the table with a custom "where" clause
+std::vector<CDSkillBehavior> CDSkillBehaviorTable::Query(std::function<bool(CDSkillBehavior)> predicate) {
+	std::vector<CDSkillBehavior> data; //So MSVC shuts up
+	return data;
+}
+
+//! Gets an entry by ID
+const CDSkillBehavior& CDSkillBehaviorTable::GetSkillByID(unsigned int skillID) {
+	std::map<unsigned int, CDSkillBehavior>::iterator it = this->entries.find(skillID);
+	if (it != this->entries.end()) {
+		return it->second;
+	}
+
+	return m_empty;
 }
 

dDatabase/Tables/CDSkillBehaviorTable.h

@@ -4,6 +4,7 @@
 #include "CDTable.h"
 
 struct CDSkillBehavior {
+	unsigned int skillID;               //!< The Skill ID of the skill
 	UNUSED(unsigned int locStatus);             //!< ??
 	unsigned int behaviorID;            //!< The Behavior ID of the skill
 	unsigned int imaginationcost;       //!< The imagination cost of the skill
@@ -26,11 +27,15 @@ struct CDSkillBehavior {
 
 class CDSkillBehaviorTable : public CDTable<CDSkillBehaviorTable> {
 private:
-	std::unordered_map<uint32_t, CDSkillBehavior> entries;
+	std::map<unsigned int, CDSkillBehavior> entries;
+	CDSkillBehavior m_empty;
+
 public:
-	void LoadValuesFromDatabase();
+	CDSkillBehaviorTable();
+	// Queries the table with a custom "where" clause
+	std::vector<CDSkillBehavior> Query(std::function<bool(CDSkillBehavior)> predicate);
 
 	// Gets an entry by skillID
-	const std::optional<CDSkillBehavior> GetSkillByID(unsigned int skillID);
+	const CDSkillBehavior& GetSkillByID(unsigned int skillID);
 };
 

dDatabase/Tables/CDTable.h

@@ -2,10 +2,8 @@
 
 #include "CDClientDatabase.h"
 #include "Singleton.h"
-#include "DluAssert.h"
 
 #include <functional>
-#include <optional>
 #include <string>
 #include <vector>
 #include <map>
@@ -17,12 +15,6 @@
 #endif
 #include "cpplinq.hpp"
 
-// Used for legacy
-#define UNUSED(x)
-
-// Enable this to skip some unused columns in some tables
-#define UNUSED_COLUMN(v)
-
 #pragma warning (disable : 4244) //Disable double to float conversion warnings
 #pragma warning (disable : 4715) //Disable "not all control paths return a value"
 
@@ -31,15 +23,3 @@ class CDTable : public Singleton<Table> {
 protected:
 	virtual ~CDTable() = default;
 };
-
-template<class T>
-class LookupResult {
-	typedef std::pair<T, bool> DataType;
-public:
-	LookupResult() { m_data.first = T(); m_data.second = false; };
-	LookupResult(T& data) { m_data.first = data; m_data.second = true; };
-	inline const T& Data() { return m_data.first; };
-	inline const bool& FoundData() { return m_data.second; };
-private:
-	DataType m_data;
-};

dDatabase/Tables/CDVendorComponentTable.cpp

@@ -1,22 +1,51 @@
 #include "CDVendorComponentTable.h"
 
-void CDVendorComponentTable::LoadValuesFromDatabase() {
+//! Constructor
+CDVendorComponentTable::CDVendorComponentTable(void) {
+
+	// First, get the size of the table
+	unsigned int size = 0;
+	auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM VendorComponent");
+	while (!tableSize.eof()) {
+		size = tableSize.getIntField(0, 0);
+
+		tableSize.nextRow();
+	}
+
+	tableSize.finalize();
+
+	// Reserve the size
+	this->entries.reserve(size);
+
 	// Now get the data
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM VendorComponent");
 	while (!tableData.eof()) {
 		CDVendorComponent entry;
-		uint32_t id = tableData.getIntField("id", -1);
+		entry.id = tableData.getIntField("id", -1);
 		entry.buyScalar = tableData.getFloatField("buyScalar", -1.0f);
 		entry.sellScalar = tableData.getFloatField("sellScalar", -1.0f);
 		entry.refreshTimeSeconds = tableData.getFloatField("refreshTimeSeconds", -1.0f);
 		entry.LootMatrixIndex = tableData.getIntField("LootMatrixIndex", -1);
 
-		this->entries.insert_or_assign(id, entry);
+		this->entries.push_back(entry);
 		tableData.nextRow();
 	}
+
+	tableData.finalize();
 }
 
-const std::optional<CDVendorComponent> CDVendorComponentTable::Query(uint32_t id) {
-	const auto& iter = entries.find(id);
-	return iter != entries.end() ? std::make_optional(iter->second) : std::nullopt;
+//! Queries the table with a custom "where" clause
+std::vector<CDVendorComponent> CDVendorComponentTable::Query(std::function<bool(CDVendorComponent)> predicate) {
+
+	std::vector<CDVendorComponent> data = cpplinq::from(this->entries)
+		>> cpplinq::where(predicate)
+		>> cpplinq::to_vector();
+
+	return data;
 }
+
+//! Gets all the entries in the table
+std::vector<CDVendorComponent> CDVendorComponentTable::GetEntries(void) const {
+	return this->entries;
+}
+

dDatabase/Tables/CDVendorComponentTable.h

@@ -4,6 +4,7 @@
 #include "CDTable.h"
 
 struct CDVendorComponent {
+	unsigned int id;           //!< The Component ID
 	float buyScalar;            //!< Buy Scalar (what does that mean?)
 	float sellScalar;          //!< Sell Scalar (what does that mean?)
 	float refreshTimeSeconds;  //!< The refresh time
@@ -12,11 +13,13 @@ struct CDVendorComponent {
 
 class CDVendorComponentTable : public CDTable<CDVendorComponentTable> {
 private:
-	std::unordered_map<uint32_t, CDVendorComponent> entries;
+	std::vector<CDVendorComponent> entries;
 
 public:
-	void LoadValuesFromDatabase();
+	CDVendorComponentTable();
 	// Queries the table with a custom "where" clause
-	const std::optional<CDVendorComponent> Query(uint32_t id);
+	std::vector<CDVendorComponent> Query(std::function<bool(CDVendorComponent)> predicate);
+
+	std::vector<CDVendorComponent> GetEntries(void) const;
 };
 

dDatabase/Tables/CDZoneTableTable.cpp

@@ -1,6 +1,19 @@
 #include "CDZoneTableTable.h"
 
-void CDZoneTableTable::LoadValuesFromDatabase() {
+//! Constructor
+CDZoneTableTable::CDZoneTableTable(void) {
+
+	// First, get the size of the table
+	unsigned int size = 0;
+	auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM ZoneTable");
+	while (!tableSize.eof()) {
+		size = tableSize.getIntField(0, 0);
+
+		tableSize.nextRow();
+	}
+
+	tableSize.finalize();
+
 	// Now get the data
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM ZoneTable");
 	while (!tableData.eof()) {
@@ -36,11 +49,18 @@ void CDZoneTableTable::LoadValuesFromDatabase() {
 		this->m_Entries.insert(std::make_pair(entry.zoneID, entry));
 		tableData.nextRow();
 	}
+
+	tableData.finalize();
 }
 
 //! Queries the table with a zoneID to find.
-const std::optional<CDZoneTable> CDZoneTableTable::Query(unsigned int zoneID) {
+const CDZoneTable* CDZoneTableTable::Query(unsigned int zoneID) {
 	const auto& iter = m_Entries.find(zoneID);
-	return iter != m_Entries.end() ? std::make_optional(iter->second) : std::nullopt;
+
+	if (iter != m_Entries.end()) {
+		return &iter->second;
+	}
+
+	return nullptr;
 }
 

dDatabase/Tables/CDZoneTableTable.h

@@ -1,5 +1,6 @@
 #pragma once
 
+// Custom Classes
 #include "CDTable.h"
 
 struct CDZoneTable {
@@ -34,11 +35,11 @@ struct CDZoneTable {
 
 class CDZoneTableTable : public CDTable<CDZoneTableTable> {
 private:
-	std::unordered_map<uint32_t, CDZoneTable> m_Entries;
+	std::map<unsigned int, CDZoneTable> m_Entries;
 
 public:
-	void LoadValuesFromDatabase();
+	CDZoneTableTable();
 
 	// Queries the table with a zoneID to find.
-	const std::optional<CDZoneTable> Query(unsigned int zoneID);
+	const CDZoneTable* Query(unsigned int zoneID);
 };

dGame/Character.cpp

@@ -241,7 +241,7 @@ void Character::DoQuickXMLDataParse() {
 		//To try and fix the AG landing into:
 		if (m_ZoneID == 1000 && Game::server->GetZoneID() == 1100) {
 			//sneakily insert our position:
-			auto pos = Game::zoneManager->GetZone()->GetSpawnPos();
+			auto pos = dZoneManager::Instance()->GetZone()->GetSpawnPos();
 			character->SetAttribute("lzx", pos.x);
 			character->SetAttribute("lzy", pos.y);
 			character->SetAttribute("lzz", pos.z);
@@ -290,13 +290,13 @@ void Character::DoQuickXMLDataParse() {
 
 void Character::UnlockEmote(int emoteID) {
 	m_UnlockedEmotes.push_back(emoteID);
-	GameMessages::SendSetEmoteLockState(Game::entityManager->GetEntity(m_ObjectID), false, emoteID);
+	GameMessages::SendSetEmoteLockState(EntityManager::Instance()->GetEntity(m_ObjectID), false, emoteID);
 }
 
 void Character::SetBuildMode(bool buildMode) {
 	m_BuildMode = buildMode;
 
-	auto* controller = Game::zoneManager->GetZoneControlObject();
+	auto* controller = dZoneManager::Instance()->GetZoneControlObject();
 
 	controller->OnFireEventServerSide(m_OurEntity, buildMode ? "OnBuildModeEnter" : "OnBuildModeLeave");
 }
@@ -312,7 +312,7 @@ void Character::SaveXMLToDatabase() {
 		character->SetAttribute("gm", static_cast<uint32_t>(m_GMLevel));
 		character->SetAttribute("cc", m_Coins);
 
-		auto zoneInfo = Game::zoneManager->GetZone()->GetZoneID();
+		auto zoneInfo = dZoneManager::Instance()->GetZone()->GetZoneID();
 		// lzid garbage, binary concat of zoneID, zoneInstance and zoneClone
 		if (zoneInfo.GetMapID() != 0 && zoneInfo.GetCloneID() == 0) {
 			uint64_t lzidConcat = zoneInfo.GetCloneID();
@@ -418,13 +418,13 @@ void Character::WriteToDatabase() {
 	delete printer;
 }
 
-void Character::SetPlayerFlag(const uint32_t flagId, const bool value) {
+void Character::SetPlayerFlag(const int32_t flagId, const bool value) {
 	// If the flag is already set, we don't have to recalculate it
 	if (GetPlayerFlag(flagId) == value) return;
 
 	if (value) {
 		// Update the mission component:
-		auto* player = Game::entityManager->GetEntity(m_ObjectID);
+		auto* player = EntityManager::Instance()->GetEntity(m_ObjectID);
 
 		if (player != nullptr) {
 			auto* missionComponent = player->GetComponent<MissionComponent>();
@@ -465,7 +465,7 @@ void Character::SetPlayerFlag(const uint32_t flagId, const bool value) {
 	GameMessages::SendNotifyClientFlagChange(m_ObjectID, flagId, value, m_ParentUser->GetSystemAddress());
 }
 
-bool Character::GetPlayerFlag(const uint32_t flagId) const {
+bool Character::GetPlayerFlag(const int32_t flagId) const {
 	// Calculate the index first
 	const auto flagIndex = uint32_t(std::floor(flagId / 64));
 
@@ -602,7 +602,7 @@ void Character::SetCoins(int64_t newCoins, eLootSourceType lootSource) {
 
 	m_Coins = newCoins;
 
-	GameMessages::SendSetCurrency(Game::entityManager->GetEntity(m_ObjectID), m_Coins, 0, 0, 0, 0, true, lootSource);
+	GameMessages::SendSetCurrency(EntityManager::Instance()->GetEntity(m_ObjectID), m_Coins, 0, 0, 0, 0, true, lootSource);
 }
 
 bool Character::HasBeenToWorld(LWOMAPID mapID) const {

dGame/Character.h

@@ -415,14 +415,14 @@ public:
 	 * @param flagId the ID of the flag to set
 	 * @param value the value to set for the flag
 	 */
-	void SetPlayerFlag(uint32_t flagId, bool value);
+	void SetPlayerFlag(int32_t flagId, bool value);
 
 	/**
 	 * Gets the value for a certain character flag
 	 * @param flagId the ID of the flag to get a value for
 	 * @return the value of the flag given the ID (the default is false, obviously)
 	 */
-	bool GetPlayerFlag(uint32_t flagId) const;
+	bool GetPlayerFlag(int32_t flagId) const;
 
 	/**
 	 * Notifies the character that they're now muted