Merge branch 'main' into Log-Line-Cleaning

.github/ISSUE_TEMPLATE/bug_report.yaml

@@ -7,6 +7,7 @@ body:
   - type: checkboxes
     id: checks
     attributes:
+      label: "Make sure you've done the following:"
       options:
         - label: >
             I have checked that this issue has not already been reported.

.github/ISSUE_TEMPLATE/documentation_improvement.yaml

@@ -5,7 +5,9 @@ labels: ["docs", "triage"]
 
 body:
   - type: checkboxes
+    id: checks
     attributes:
+      label: "Make sure you've done the following:"
       options:
         - label: >
             I have checked that this issue has not already been reported.

.github/ISSUE_TEMPLATE/installation_issue.yaml

@@ -7,6 +7,7 @@ body:
   - type: checkboxes
     id: checks
     attributes:
+      label: "Make sure you've done the following:"
       options:
         - label: >
             I have read the [installation guide](https://github.com/DarkflameUniverse/DarkflameServer/blob/main/README.md).

.github/ISSUE_TEMPLATE/performance_issue.yaml

@@ -7,6 +7,7 @@ body:
   - type: checkboxes
     id: checks
     attributes:
+      label: "Make sure you've done the following:"
       options:
         - label: >
             I have checked that this issue has not already been reported.

.github/workflows/build.yml

@@ -0,0 +1,33 @@
+name: Cmake CI
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+      with:
+        submodules: true
+    - name: cmake
+      uses: lukka/run-cmake@v10
+      with:
+        configurePreset: 'default'
+        buildPreset: 'default'
+    - name: artifacts
+      uses: actions/upload-artifact@v2
+      with:
+        name: linux-build
+        path: |
+          build
+          !build/CMakeCache.txt
+          !build/build.ninja
+          !build/_deps
+          !build/cmake_install.cmake
+          !build/*.a

CMakeLists.txt

@@ -123,6 +123,9 @@ make_directory(${CMAKE_BINARY_DIR}/res)
 # Create a /locale directory
 make_directory(${CMAKE_BINARY_DIR}/locale)
 
+# Create a /logs directory
+make_directory(${CMAKE_BINARY_DIR}/logs)
+
 # Copy ini files on first build
 if (NOT EXISTS ${PROJECT_BINARY_DIR}/authconfig.ini)
     configure_file(

CMakePresets.json

@@ -0,0 +1,26 @@
+{
+  "version": 3,
+  "cmakeMinimumRequired": {
+    "major": 3,
+    "minor": 12,
+    "patch": 0
+  },
+  "configurePresets": [
+    {
+      "name": "default",
+      "displayName": "Default Configure Settings",
+      "description": "Sets build and install directories",
+      "binaryDir": "${sourceDir}/build",
+      "generator": "Unix Makefiles"
+    }
+  ],
+  "buildPresets": [
+    {
+      "name": "default",
+      "configurePreset": "default",
+      "displayName": "Default Build",
+      "description": "Default Build",
+      "jobs": 2
+    }
+  ]
+}

README.md

@@ -289,10 +289,10 @@ Here is a summary of the commands available in-game. All commands are prefixed b
   </tr>
   <tr>
     <td>
-      instance-info
+      instanceinfo
     </td>
     <td>
-      /instance-info
+      /instanceinfo
     </td>
     <td>
       Displays in the chat the current zone, clone, and instance id. 

dAuthServer/AuthServer.cpp

@@ -45,6 +45,7 @@ int main(int argc, char** argv) {
 	dConfig config("authconfig.ini");
 	Game::config = &config;
 	Game::logger->SetLogToConsole(bool(std::stoi(config.GetValue("log_to_console"))));
+	Game::logger->SetLogDebugStatements(config.GetValue("log_debug_statements") == "1");
 
 	//Connect to the MySQL Database
 	std::string mysql_host = config.GetValue("mysql_host");
@@ -152,11 +153,13 @@ int main(int argc, char** argv) {
 dLogger * SetupLogger() {
 	std::string logPath = "./logs/AuthServer_" + std::to_string(time(nullptr)) + ".log";
 	bool logToConsole = false;
+	bool logDebugStatements = false;
 #ifdef _DEBUG
 	logToConsole = true;
+	logDebugStatements = true;
 #endif
 
-	return new dLogger(logPath, logToConsole);
+	return new dLogger(logPath, logToConsole, logDebugStatements);
 }
 
 void HandlePacket(Packet* packet) {

dChatServer/ChatPacketHandler.cpp

@@ -351,6 +351,13 @@ void ChatPacketHandler::HandleTeamInvite(Packet* packet)
 		return;
 	}
 
+	if (team->memberIDs.size() > 3) {
+		// no more teams greater than 4
+
+		Game::logger->Log("ChatPacketHandler", "Someone tried to invite a 5th player to a team");
+		return;
+	}
+
 	SendTeamInvite(other, player);
 
 	Game::logger->Log("ChatPacketHandler", "Got team invite: %llu -> %s\n", playerID, invitedPlayer.c_str());

dChatServer/ChatServer.cpp

@@ -48,6 +48,7 @@ int main(int argc, char** argv) {
 	dConfig config("chatconfig.ini");
 	Game::config = &config;
 	Game::logger->SetLogToConsole(bool(std::stoi(config.GetValue("log_to_console"))));
+	Game::logger->SetLogDebugStatements(config.GetValue("log_debug_statements") == "1");
 
 	//Connect to the MySQL Database
 	std::string mysql_host = config.GetValue("mysql_host");
@@ -159,11 +160,13 @@ int main(int argc, char** argv) {
 dLogger * SetupLogger() {
 	std::string logPath = "./logs/ChatServer_" + std::to_string(time(nullptr)) + ".log";
 	bool logToConsole = false;
+	bool logDebugStatements = false;
 #ifdef _DEBUG
 	logToConsole = true;
+	logDebugStatements = true;
 #endif
 
-	return new dLogger(logPath, logToConsole);
+	return new dLogger(logPath, logToConsole, logDebugStatements);
 }
 
 void HandlePacket(Packet* packet) {

dCommon/dLogger.cpp

@@ -1,7 +1,8 @@
 #include "dLogger.h"
 
-dLogger::dLogger(const std::string& outpath, bool logToConsole) {
+dLogger::dLogger(const std::string& outpath, bool logToConsole, bool logDebugStatements) {
 	m_logToConsole = logToConsole;
+	m_logDebugStatements = logDebugStatements;
 	m_outpath = outpath;
 
 #ifdef _WIN32
@@ -24,39 +25,25 @@ dLogger::~dLogger() {
 #endif
 }
 
-void dLogger::LogBasic(const std::string & message) {
+void dLogger::vLog(const char* format, va_list args) {
-	LogBasic(message.c_str());
-}
-
-void dLogger::LogBasic(const char * format, ...) {
 #ifdef _WIN32
 	time_t t = time(NULL);
 	struct tm time;
 	localtime_s(&time, &t);
-
 	char timeStr[70];
-	
 	strftime(timeStr, sizeof(timeStr), "%d-%m-%y %H:%M:%S", &time);
-
 	char message[2048];
-	va_list args;
-	va_start(args, format);
 	vsprintf_s(message, format, args);
-	va_end(args);
 
-	if (m_logToConsole) std::cout << "[" << "time machine broke" << "] " << message;
+	if (m_logToConsole) std::cout << "[" << timeStr << "] " << message;
-	mFile << "[" << "time" << "] " << message;
+	mFile << "[" << timeStr << "] " << message;
 #else
 	time_t t = time(NULL);
     struct tm * time = localtime(&t);
     char timeStr[70];
     strftime(timeStr, sizeof(timeStr), "%d-%m-%y %H:%M:%S", time);
-	
 	char message[2048];
-    va_list args;
-    va_start(args, format);
     vsprintf(message, format, args);
-    va_end(args);
     
     if (m_logToConsole) {
 		fputs("[", stdout);
@@ -76,62 +63,42 @@ void dLogger::LogBasic(const char * format, ...) {
 #endif
 }
 
+void dLogger::LogBasic(const char * format, ...) {
+	va_list args;
+	va_start(args, format);
+	vLog(format, args);
+	va_end(args);
+}
+
+void dLogger::LogBasic(const std::string & message) {
+	LogBasic(message.c_str());
+}
+
 void dLogger::Log(const char * className, const char * format, ...) {
-#ifdef _WIN32
-	time_t t = time(NULL);
-	struct tm time;
-	localtime_s(&time, &t);
-
-	char timeStr[70];
-	strftime(timeStr, sizeof(timeStr), "%d-%m-%y %H:%M:%S", &time);
-
-	char message[2048];
 	va_list args;
+	std::string log = "[" + std::string(className) + "] " + std::string(format);
 	va_start(args, format);
-	vsprintf_s(message, format, args);
+	vLog(log.c_str(), args);
-
 	va_end(args);
-
-	if (m_logToConsole) std::cout << "[" << timeStr << "] [" << className << "]: " << message;
-	mFile << "[" << timeStr << "] [" << className << "]: " << message;
-#else
-	time_t t = time(NULL);
-    struct tm * time = localtime(&t);
-    char timeStr[70];
-    strftime(timeStr, sizeof(timeStr), "%d-%m-%y %H:%M:%S", time);
-	
-	char message[2048];
-    va_list args;
-    va_start(args, format);
-    vsprintf(message, format, args);
-    va_end(args);
-    
-    if (m_logToConsole) {
-		fputs("[", stdout);
-		fputs(timeStr, stdout);
-		fputs("] ", stdout);
-		fputs("[", stdout);
-		fputs(className, stdout);
-		fputs("]: ", stdout);
-		fputs(message, stdout);
-    }
-    
-    if (fp != NULL) {
-		fputs("[", fp);
-		fputs(timeStr, fp);
-		fputs("] ", fp);
-		fputs("[", fp);
-		fputs(className, fp);
-		fputs("]: ", fp);
-		fputs(message, fp);
-    }
-#endif
 }
 
 void dLogger::Log(const std::string & className, const std::string & message) {
 	Log(className.c_str(), message.c_str());
 }
 
+void dLogger::LogDebug(const char * className, const char * format, ...) {
+	if (!m_logDebugStatements) return;
+	va_list args;
+	std::string log = "[" + std::string(className) + "] " + std::string(format);
+	va_start(args, format);
+	vLog(log.c_str(), args);
+	va_end(args);
+}
+
+void dLogger::LogDebug(const std::string & className, const std::string & message) {
+	LogDebug(className.c_str(), message.c_str());
+}
+
 void dLogger::Flush() {
 #ifdef _WIN32
 	mFile.flush();

dCommon/dLogger.h

@@ -7,21 +7,26 @@
 
 class dLogger {
 public:
-	dLogger(const std::string& outpath, bool logToConsole);
+	dLogger(const std::string& outpath, bool logToConsole, bool logDebugStatements);
 	~dLogger();
 
 	void SetLogToConsole(bool logToConsole) { m_logToConsole = logToConsole; }
+	void SetLogDebugStatements(bool logDebugStatements) { m_logDebugStatements = logDebugStatements; }
+	void vLog(const char* format, va_list args);
 
 	void LogBasic(const std::string& message);
 	void LogBasic(const char* format, ...);
 	void Log(const char* className, const char* format, ...);
 	void Log(const std::string& className, const std::string& message);
+	void LogDebug(const std::string& className, const std::string& message);
+	void LogDebug(const char* className, const char* format, ...);
 
 	void Flush();
 
 	const bool GetIsLoggingToConsole() const { return m_logToConsole; }
 
 private:
+	bool m_logDebugStatements;
 	bool m_logToConsole;
 	std::string m_outpath;
 	std::ofstream mFile;

dDatabase/Tables/CDLootMatrixTable.cpp

@@ -57,6 +57,6 @@ std::vector<CDLootMatrix> CDLootMatrixTable::Query(std::function<bool(CDLootMatr
 }
 
 //! Gets all the entries in the table
-std::vector<CDLootMatrix> CDLootMatrixTable::GetEntries(void) const {
+const std::vector<CDLootMatrix>& CDLootMatrixTable::GetEntries(void) const {
     return this->entries;
 }

dDatabase/Tables/CDLootMatrixTable.h

@@ -50,7 +50,7 @@ public:
     /*!
       \return The entries
      */
-    std::vector<CDLootMatrix> GetEntries(void) const;
+    const std::vector<CDLootMatrix>& GetEntries(void) const;
     
 };
 

dDatabase/Tables/CDLootTableTable.cpp

@@ -54,6 +54,6 @@ std::vector<CDLootTable> CDLootTableTable::Query(std::function<bool(CDLootTable)
 }
 
 //! Gets all the entries in the table
-std::vector<CDLootTable> CDLootTableTable::GetEntries(void) const {
+const std::vector<CDLootTable>& CDLootTableTable::GetEntries(void) const {
     return this->entries;
 }

dDatabase/Tables/CDLootTableTable.h

@@ -46,7 +46,7 @@ public:
     /*!
       \return The entries
      */
-    std::vector<CDLootTable> GetEntries(void) const;
+    const std::vector<CDLootTable>& GetEntries(void) const;
     
 };
 

dDatabase/Tables/CDRarityTableTable.cpp

@@ -52,6 +52,6 @@ std::vector<CDRarityTable> CDRarityTableTable::Query(std::function<bool(CDRarity
 }
 
 //! Gets all the entries in the table
-std::vector<CDRarityTable> CDRarityTableTable::GetEntries(void) const {
+const std::vector<CDRarityTable>& CDRarityTableTable::GetEntries(void) const {
     return this->entries;
 }

dDatabase/Tables/CDRarityTableTable.h

@@ -66,7 +66,7 @@ public:
     /*!
       \return The entries
      */
-    std::vector<CDRarityTable> GetEntries(void) const;
+    const std::vector<CDRarityTable>& GetEntries(void) const;
 
 };
 

dGame/dBehaviors/AreaOfEffectBehavior.cpp

@@ -74,7 +74,7 @@ void AreaOfEffectBehavior::Calculate(BehaviorContext* context, RakNet::BitStream
 		includeFaction = 1;
 	}
 
-	for (auto validTarget : context->GetValidTargets(m_ignoreFaction , includeFaction))
+	for (auto validTarget : context->GetValidTargets(m_ignoreFaction , includeFaction, m_TargetSelf == 1))
 	{
 		auto* entity = EntityManager::Instance()->GetEntity(validTarget);
 
@@ -155,4 +155,6 @@ void AreaOfEffectBehavior::Load()
 	this->m_ignoreFaction = GetInt("ignore_faction");
 
 	this->m_includeFaction = GetInt("include_faction");
+
+        this->m_TargetSelf = GetInt("target_self");
 }

dGame/dBehaviors/AreaOfEffectBehavior.h

@@ -14,6 +14,8 @@ public:
 
 	int32_t m_includeFaction;
 
+        int32_t m_TargetSelf;
+	
 	/*
 	 * Inherited
 	 */

dGame/dBehaviors/BehaviorContext.cpp

@@ -325,7 +325,7 @@ void BehaviorContext::Reset()
 	this->scheduledUpdates.clear();
 }
 
-std::vector<LWOOBJID> BehaviorContext::GetValidTargets(int32_t ignoreFaction, int32_t includeFaction) const
+std::vector<LWOOBJID> BehaviorContext::GetValidTargets(int32_t ignoreFaction, int32_t includeFaction, bool targetSelf) const
 {
 	auto* entity = EntityManager::Instance()->GetEntity(this->caster);
 
@@ -353,7 +353,7 @@ std::vector<LWOOBJID> BehaviorContext::GetValidTargets(int32_t ignoreFaction, in
 		}
 	}
 
-	if (ignoreFaction || includeFaction || (!entity->HasComponent(COMPONENT_TYPE_PHANTOM_PHYSICS) && !entity->HasComponent(COMPONENT_TYPE_CONTROLLABLE_PHYSICS) && targets.empty()))
+	if (ignoreFaction || includeFaction || (!entity->HasComponent(COMPONENT_TYPE_PHANTOM_PHYSICS) && targets.empty()))
 	{
                 DestroyableComponent* destroyableComponent;
 		if (!entity->TryGetComponent(COMPONENT_TYPE_DESTROYABLE, destroyableComponent))
@@ -362,12 +362,11 @@ std::vector<LWOOBJID> BehaviorContext::GetValidTargets(int32_t ignoreFaction, in
 		}
 		
 		auto entities = EntityManager::Instance()->GetEntitiesByComponent(COMPONENT_TYPE_CONTROLLABLE_PHYSICS);
-
 		for (auto* candidate : entities)
 		{
 			const auto id = candidate->GetObjectID();
 			
-			if (destroyableComponent->CheckValidity(id, ignoreFaction || includeFaction))
+			if ((id != entity->GetObjectID() || targetSelf) && destroyableComponent->CheckValidity(id, ignoreFaction || includeFaction))
 			{
 				targets.push_back(id);
 			}

dGame/dBehaviors/BehaviorContext.h

@@ -102,7 +102,7 @@ struct BehaviorContext
 
 	void Reset();
 
-	std::vector<LWOOBJID> GetValidTargets(int32_t ignoreFaction = 0, int32_t includeFaction = 0) const;
+	std::vector<LWOOBJID> GetValidTargets(int32_t ignoreFaction = 0, int32_t includeFaction = 0, const bool targetSelf = false) const;
 	
 	explicit BehaviorContext(LWOOBJID originator, bool calculation = false);
 

dGame/dBehaviors/ForceMovementBehavior.cpp

@@ -1,44 +1,81 @@
 #include "ForceMovementBehavior.h"
-
 #include "BehaviorBranchContext.h"
 #include "BehaviorContext.h"
+#include "ControllablePhysicsComponent.h"
+#include "EntityManager.h"
 
-void ForceMovementBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bitStream, const BehaviorBranchContext branch)
+void ForceMovementBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bitStream, const BehaviorBranchContext branch) {
-{
+    if (this->m_hitAction->m_templateId == BehaviorTemplates::BEHAVIOR_EMPTY && this->m_hitEnemyAction->m_templateId == BehaviorTemplates::BEHAVIOR_EMPTY && this->m_hitFactionAction->m_templateId == BehaviorTemplates::BEHAVIOR_EMPTY) {
-	if (this->m_hitAction->m_templateId == BehaviorTemplates::BEHAVIOR_EMPTY && this->m_hitEnemyAction->m_templateId == BehaviorTemplates::BEHAVIOR_EMPTY && this->m_hitFactionAction->m_templateId == BehaviorTemplates::BEHAVIOR_EMPTY)
-	{
         return;
     }
 
     uint32_t handle;
-
     bitStream->Read(handle);
-
     context->RegisterSyncBehavior(handle, this, branch);
 }
 
 void ForceMovementBehavior::Sync(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch)
 {
     uint32_t next;
-
     bitStream->Read(next);
 
     LWOOBJID target;
-
     bitStream->Read(target);
 
-	auto* behavior = CreateBehavior(next);
-
     branch.target = target;
-
+    auto* behavior = CreateBehavior(next);
     behavior->Handle(context, bitStream, branch);
 }
 
+void ForceMovementBehavior::Calculate(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) {
+    if (this->m_hitAction->m_templateId == BehaviorTemplates::BEHAVIOR_EMPTY && this->m_hitEnemyAction->m_templateId == BehaviorTemplates::BEHAVIOR_EMPTY && this->m_hitFactionAction->m_templateId == BehaviorTemplates::BEHAVIOR_EMPTY) {
+        return;
+    }
+
+    auto* casterEntity = EntityManager::Instance()->GetEntity(context->caster);
+    if (casterEntity != nullptr) {
+        auto* controllablePhysicsComponent = casterEntity->GetComponent<ControllablePhysicsComponent>();
+        if (controllablePhysicsComponent != nullptr) {
+
+            if (m_Forward == 1) {
+                controllablePhysicsComponent->SetVelocity(controllablePhysicsComponent->GetRotation().GetForwardVector() * 25);
+            }
+
+            EntityManager::Instance()->SerializeEntity(casterEntity);
+        }
+    }
+
+    const auto skillHandle = context->GetUniqueSkillId();
+    bitStream->Write(skillHandle);
+
+    context->SyncCalculation(skillHandle, this->m_Duration, this, branch);
+}
+
 void ForceMovementBehavior::Load()
 {
     this->m_hitAction = GetAction("hit_action");
-
     this->m_hitEnemyAction = GetAction("hit_action_enemy");
-
     this->m_hitFactionAction = GetAction("hit_action_faction");
+    this->m_Duration = GetFloat("duration");
+    this->m_Forward = GetFloat("forward");
+    this->m_Left = GetFloat("left");
+    this->m_Yaw = GetFloat("yaw");
+}
+
+void ForceMovementBehavior::SyncCalculation(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) {
+    auto* casterEntity = EntityManager::Instance()->GetEntity(context->caster);
+    if (casterEntity != nullptr) {
+        auto* controllablePhysicsComponent = casterEntity->GetComponent<ControllablePhysicsComponent>();
+        if (controllablePhysicsComponent != nullptr) {
+
+            controllablePhysicsComponent->SetPosition(controllablePhysicsComponent->GetPosition() + controllablePhysicsComponent->GetVelocity() * m_Duration);
+            controllablePhysicsComponent->SetVelocity({});
+
+            EntityManager::Instance()->SerializeEntity(casterEntity);
+        }
+    }
+
+    this->m_hitAction->Calculate(context, bitStream, branch);
+    this->m_hitEnemyAction->Calculate(context, bitStream, branch);
+    this->m_hitEnemyAction->Calculate(context, bitStream, branch);
 }

dGame/dBehaviors/ForceMovementBehavior.h

@@ -10,6 +10,11 @@ public:
 
 	Behavior* m_hitFactionAction;
 
+        float_t  m_Duration;
+        float_t m_Forward;
+        float_t m_Left;
+        float_t m_Yaw;
+	
 	/*
 	 * Inherited
 	 */
@@ -18,8 +23,12 @@ public:
 	{
 	}
 
+        void Calculate(BehaviorContext *context, RakNet::BitStream *bitStream, BehaviorBranchContext branch) override;
+
 	void Handle(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) override;
 
+        void SyncCalculation(BehaviorContext *context, RakNet::BitStream *bitStream, BehaviorBranchContext branch) override;
+
 	void Sync(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) override;
 	
 	void Load() override;

dGame/dComponents/BaseCombatAIComponent.cpp

@@ -129,6 +129,9 @@ BaseCombatAIComponent::BaseCombatAIComponent(Entity* parent, const uint32_t id)
 BaseCombatAIComponent::~BaseCombatAIComponent() {
 	if (m_dpEntity)
 		dpWorld::Instance().RemoveEntity(m_dpEntity);
+
+	if (m_dpEntityEnemy)
+		dpWorld::Instance().RemoveEntity(m_dpEntityEnemy);
 }
 
 void BaseCombatAIComponent::Update(const float deltaTime) {

dGame/dComponents/DestroyableComponent.cpp

@@ -769,26 +769,33 @@ void DestroyableComponent::Smash(const LWOOBJID source, const eKillType killType
 			if (team != nullptr && m_Parent->GetComponent<BaseCombatAIComponent>() != nullptr)
 			{
 				LWOOBJID specificOwner = LWOOBJID_EMPTY;
+				auto* scriptedActivityComponent = m_Parent->GetComponent<ScriptedActivityComponent>();
+				uint32_t teamSize = team->members.size();
+				uint32_t lootMatrixId = GetLootMatrixID();
 
-				if (team->lootOption == 0) // Round robin
+				if (scriptedActivityComponent) {
-				{
+					lootMatrixId = scriptedActivityComponent->GetLootMatrixForTeamSize(teamSize);
-					specificOwner = TeamManager::Instance()->GetNextLootOwner(team);
 				}
 
-				for (const auto memberId : team->members)
+				if (team->lootOption == 0) { // Round robin
-				{
+					specificOwner = TeamManager::Instance()->GetNextLootOwner(team);
-					if (specificOwner != LWOOBJID_EMPTY && memberId != specificOwner) continue;
 
+					auto* member = EntityManager::Instance()->GetEntity(specificOwner);
+
+                    if (member) LootGenerator::Instance().DropLoot(member, m_Parent, lootMatrixId, GetMinCoins(), GetMaxCoins());
+				} 
+				else {
+					for (const auto memberId : team->members) { // Free for all
 						auto* member = EntityManager::Instance()->GetEntity(memberId);
 
 						if (member == nullptr) continue;
 
-					Loot::DropLoot(member, m_Parent, GetLootMatrixID(), GetMinCoins(), GetMaxCoins());
+						LootGenerator::Instance().DropLoot(member, m_Parent, lootMatrixId, GetMinCoins(), GetMaxCoins()); 
 					}
 				}
-			else
+			}
-			{
+			else { // drop loot for non team user
-				Loot::DropLoot(owner, m_Parent, GetLootMatrixID(), GetMinCoins(), GetMaxCoins());
+				LootGenerator::Instance().DropLoot(owner, m_Parent, GetLootMatrixID(), GetMinCoins(), GetMaxCoins());
 			}
 		}
 	}
@@ -815,7 +822,7 @@ void DestroyableComponent::Smash(const LWOOBJID source, const eKillType killType
 
 			coinsTotal -= coinsToLoose;
 		
-			Loot::DropLoot(m_Parent, m_Parent, -1, coinsToLoose, coinsToLoose);
+			LootGenerator::Instance().DropLoot(m_Parent, m_Parent, -1, coinsToLoose, coinsToLoose);
 		}
 
 		character->SetCoins(coinsTotal);

dGame/dComponents/RacingControlComponent.cpp

@@ -317,7 +317,9 @@ void RacingControlComponent::OnRequestDie(Entity *player) {
             return;
         }
 
+        if (!racingPlayer.noSmashOnReload) {
             racingPlayer.smashedTimes++;
+        }
 
         // Reset player to last checkpoint
         GameMessages::SendRacingSetPlayerResetInfo(
@@ -390,7 +392,7 @@ void RacingControlComponent::HandleMessageBoxResponse(Entity *player,
         // Calculate the score, different loot depending on player count
         const auto score = m_LoadedPlayers * 10 + data->finished;
 
-        Loot::GiveActivityLoot(player, m_Parent, m_ActivityID, score);
+        LootGenerator::Instance().GiveActivityLoot(player, m_Parent, m_ActivityID, score);
 
         // Giving rewards
         GameMessages::SendNotifyRacingClient(

dGame/dComponents/RebuildComponent.cpp

@@ -452,7 +452,7 @@ void RebuildComponent::CompleteRebuild(Entity* user) {
 			missionComponent->Progress(MissionTaskType::MISSION_TASK_TYPE_ACTIVITY, m_ActivityId);
 		}
 
-		Loot::DropActivityLoot(builder, m_Parent, m_ActivityId, 1);
+		LootGenerator::Instance().DropActivityLoot(builder, m_Parent, m_ActivityId, 1);
 	}
 
 	m_Builder = LWOOBJID_EMPTY;

dGame/dComponents/ScriptedActivityComponent.cpp

@@ -16,6 +16,7 @@
 #include "GeneralUtils.h"
 #include "dZoneManager.h"
 #include "dConfig.h"
+#include "DestroyableComponent.h"
 
 ScriptedActivityComponent::ScriptedActivityComponent(Entity* parent, int activityID) : Component(parent)
 {
@@ -43,6 +44,31 @@ ScriptedActivityComponent::ScriptedActivityComponent(Entity* parent, int activit
 			}
 		}
 	}
+
+	auto* destroyableComponent = m_Parent->GetComponent<DestroyableComponent>();
+
+	if (destroyableComponent) {
+		// check for LMIs and set the loot LMIs
+		CDActivityRewardsTable* activityRewardsTable = CDClientManager::Instance()->GetTable<CDActivityRewardsTable>("ActivityRewards");
+		std::vector<CDActivityRewards> activityRewards = activityRewardsTable->Query([=](CDActivityRewards entry) {return (entry.LootMatrixIndex == destroyableComponent->GetLootMatrixID()); });
+
+		uint32_t startingLMI = 0;
+
+		if (activityRewards.size() > 0) {
+			startingLMI = activityRewards[0].LootMatrixIndex;
+		}
+
+		if (startingLMI > 0) {
+			// now time for bodge :)
+
+			std::vector<CDActivityRewards> objectTemplateActivities = activityRewardsTable->Query([=](CDActivityRewards entry) {return (activityRewards[0].objectTemplate == entry.objectTemplate); });
+			for (const auto& item : objectTemplateActivities) {
+				if (item.activityRating > 0 && item.activityRating < 5) {
+					m_ActivityLootMatrices.insert({ item.activityRating, item.LootMatrixIndex });
+				}
+			}
+		}
+	}
 }
 
 ScriptedActivityComponent::~ScriptedActivityComponent()
@@ -524,7 +550,7 @@ void ActivityInstance::RewardParticipant(Entity* participant) {
 			maxCoins = currencyTable[0].maxvalue;
 		}
 
-		Loot::DropLoot(participant, m_Parent, activityRewards[0].LootMatrixIndex, minCoins, maxCoins);
+		LootGenerator::Instance().DropLoot(participant, m_Parent, activityRewards[0].LootMatrixIndex, minCoins, maxCoins);
 	}
 }
 

dGame/dComponents/ScriptedActivityComponent.h

@@ -328,6 +328,13 @@ public:
      * @param mapID the map ID to set
      */
 	void SetInstanceMapID(uint32_t mapID) { m_ActivityInfo.instanceMapID = mapID; };
+
+    /**
+     * Returns the LMI that this activity points to for a team size
+     * @param teamSize the team size to get the LMI for
+     * @return the LMI that this activity points to for a team size
+     */
+    uint32_t GetLootMatrixForTeamSize(uint32_t teamSize) { return m_ActivityLootMatrices[teamSize]; }
 private:
 
     /**
@@ -349,6 +356,11 @@ private:
      * All the activity score for the players in this activity
      */
 	std::vector<ActivityPlayer*> m_ActivityPlayers;
+
+    /**
+     * LMIs for team sizes
+     */
+    std::unordered_map<uint32_t, uint32_t> m_ActivityLootMatrices;
 };
 
 #endif // SCRIPTEDACTIVITYCOMPONENT_H

dGame/dInventory/Item.cpp

@@ -333,14 +333,14 @@ bool Item::UseNonEquip()
 		{
 			std::unordered_map<LOT, int32_t> result {};
 
-			Loot::CalculateLootMatrix(pack.LootMatrixIndex, entityParent, result);
+			result = LootGenerator::Instance().RollLootMatrix(entityParent, pack.LootMatrixIndex);
 
 			if (!inventory->GetComponent()->HasSpaceForLoot(result))
 			{
 				return false;
 			}
 
-			Loot::GiveLoot(inventory->GetComponent()->GetParent(), result);
+			LootGenerator::Instance().GiveLoot(inventory->GetComponent()->GetParent(), result);
 		}
 
 		inventory->GetComponent()->RemoveItem(lot, 1);

dGame/dUtilities/Loot.cpp

@@ -1,82 +1,348 @@
-#include "Loot.h"
-#include "GameMessages.h"
-
-#include "CDClientManager.h"
-#include "CDLootMatrixTable.h"
-#include "CDLootTableTable.h"
-
-#include "SimplePhysicsComponent.h"
-#include "ControllablePhysicsComponent.h"
-#include "DestroyableComponent.h"
-#include "MissionComponent.h"
-#include "CharacterComponent.h"
-#include "TeamManager.h"
-
 #include <algorithm>
 
-std::vector<CDLootTable> Loot::GetLootOfRarity(const std::vector<CDLootTable> &lootTable, uint32_t rarity) {
+#include "Loot.h"
-	std::vector<CDLootTable> refinedLoot;
+
-	for (auto loot : lootTable) {
+#include "CDComponentsRegistryTable.h"
-		CDItemComponent item = Inventory::FindItemComponent(loot.itemid);
+#include "CDItemComponentTable.h"
-		if (item.rarity == rarity) {
+#include "CDLootMatrixTable.h"
-			refinedLoot.push_back(loot);
+#include "CDLootTableTable.h"
+#include "CDRarityTableTable.h"
+#include "Character.h"
+#include "Entity.h"
+#include "GameMessages.h"
+#include "GeneralUtils.h"
+#include "InventoryComponent.h"
+#include "MissionComponent.h"
+
+LootGenerator::LootGenerator() {
+    CDLootTableTable* lootTableTable = CDClientManager::Instance()->GetTable<CDLootTableTable>("LootTable");
+    CDComponentsRegistryTable* componentsRegistryTable = CDClientManager::Instance()->GetTable<CDComponentsRegistryTable>("ComponentsRegistry");
+    CDItemComponentTable* itemComponentTable = CDClientManager::Instance()->GetTable<CDItemComponentTable>("ItemComponent");
+    CDLootMatrixTable* lootMatrixTable = CDClientManager::Instance()->GetTable<CDLootMatrixTable>("LootMatrix");
+    CDRarityTableTable* rarityTableTable = CDClientManager::Instance()->GetTable<CDRarityTableTable>("RarityTable");
+
+    // ==============================
+    // Cache Item Rarities
+    // ==============================
+
+    std::vector<uint32_t> uniqueItems;
+
+    for (const CDLootTable& loot : lootTableTable->GetEntries()) {
+        uniqueItems.push_back(loot.itemid);
     }
-		else if (item.rarity == 0) {
+
-			refinedLoot.push_back(loot); // powerups
+    // filter out duplicates
+    std::sort(uniqueItems.begin(), uniqueItems.end());
+    uniqueItems.erase(std::unique(uniqueItems.begin(), uniqueItems.end()), uniqueItems.end());
+
+    for (const uint32_t itemID : uniqueItems) {
+        uint32_t itemComponentID = componentsRegistryTable->GetByIDAndType(itemID, COMPONENT_TYPE_ITEM);
+        const CDItemComponent& item = itemComponentTable->GetItemComponentByID(itemComponentID);
+
+        m_ItemRarities.insert({itemID, item.rarity});
+    }
+
+    // ==============================
+    // Cache Rarity Tables
+    // ==============================
+
+    std::vector<uint32_t> uniqueRarityIndices;
+
+    for (const CDRarityTable& rarity : rarityTableTable->GetEntries()) {
+        uniqueRarityIndices.push_back(rarity.RarityTableIndex);
+    }
+
+    // filter out duplicates
+    std::sort(uniqueRarityIndices.begin(), uniqueRarityIndices.end());
+    uniqueRarityIndices.erase(std::unique(uniqueRarityIndices.begin(), uniqueRarityIndices.end()), uniqueRarityIndices.end());
+
+    for (const uint32_t index : uniqueRarityIndices) {
+        std::vector<CDRarityTable> table = rarityTableTable->Query([index](const CDRarityTable& entry) { return entry.RarityTableIndex == index; });
+
+        RarityTable rarityTable;
+
+        for (const CDRarityTable& entry : table) {
+            RarityTableEntry rarity{entry.rarity, entry.randmax};
+            rarityTable.push_back(rarity);
+        }
+
+        // sort in descending order based on randMax
+        std::sort(rarityTable.begin(), rarityTable.end(), [](const RarityTableEntry& x, const RarityTableEntry& y) { return x.randMax > y.randMax; });
+
+        m_RarityTables.insert({index, rarityTable});
+    }
+
+    // ==============================
+    // Cache Loot Matrices
+    // ==============================
+
+    std::vector<uint32_t> uniqueMatrixIndices;
+
+    for (const CDLootMatrix& matrix : lootMatrixTable->GetEntries()) {
+        uniqueMatrixIndices.push_back(matrix.LootMatrixIndex);
+    }
+
+    // filter out duplicates
+    std::sort(uniqueMatrixIndices.begin(), uniqueMatrixIndices.end());
+    uniqueMatrixIndices.erase(std::unique(uniqueMatrixIndices.begin(), uniqueMatrixIndices.end()), uniqueMatrixIndices.end());
+
+    for (const uint32_t index : uniqueMatrixIndices) {
+        std::vector<CDLootMatrix> matrix = lootMatrixTable->Query([index](const CDLootMatrix& entry) { return entry.LootMatrixIndex == index; });
+
+        LootMatrix lootMatrix;
+
+        for (const CDLootMatrix& entry : matrix) {
+            LootMatrixEntry matrixEntry{entry.LootTableIndex, entry.RarityTableIndex, entry.percent, entry.minToDrop, entry.maxToDrop};
+            lootMatrix.push_back(matrixEntry);
+        }
+
+        m_LootMatrices.insert({index, lootMatrix});
+    }
+
+    // ==============================
+    // Cache Loot Tables
+    // ==============================
+
+    std::vector<uint32_t> uniqueTableIndices;
+
+    for (const CDLootTable& entry : lootTableTable->GetEntries()) {
+        uniqueTableIndices.push_back(entry.LootTableIndex);
+    }
+
+    // filter out duplicates
+    std::sort(uniqueTableIndices.begin(), uniqueTableIndices.end());
+    uniqueTableIndices.erase(std::unique(uniqueTableIndices.begin(), uniqueTableIndices.end()), uniqueTableIndices.end());
+
+    for (const uint32_t index : uniqueTableIndices) {
+        std::vector<CDLootTable> entries = lootTableTable->Query([index](const CDLootTable& entry) { return entry.LootTableIndex == index; });
+
+        LootTable lootTable;
+
+        for (const CDLootTable& entry : entries) {
+            LootTableEntry tableEntry{(LOT)entry.itemid, entry.MissionDrop};
+            lootTable.push_back(tableEntry);
+        }
+
+        // sort by item rarity descending
+        std::sort(lootTable.begin(), lootTable.end(), [&](const LootTableEntry& x, const LootTableEntry& y) {
+            return m_ItemRarities[x.itemID] > m_ItemRarities[y.itemID];
+        });
+
+        m_LootTables.insert({index, lootTable});
     }
 }
 
-	return refinedLoot;
+std::unordered_map<LOT, int32_t> LootGenerator::RollLootMatrix(Entity* player, uint32_t matrixIndex) {
+    auto* missionComponent = player->GetComponent<MissionComponent>();
+
+    std::unordered_map<LOT, int32_t> drops;
+
+    if (missionComponent == nullptr) {
+        return drops;
     }
 
-void Loot::GiveLoot(Entity* user, uint32_t lootMatrixID) {
+    const LootMatrix& matrix = m_LootMatrices[matrixIndex];
-	user = user->GetOwner(); // If the owner is overwritten, we collect that here
 
-	std::unordered_map<LOT, int32_t> result {};
+    for (const LootMatrixEntry& entry : matrix) {
+        if (GeneralUtils::GenerateRandomNumber<float>(0, 1) < entry.percent) {
+            const LootTable& lootTable = m_LootTables[entry.lootTableIndex];
+            const RarityTable& rarityTable = m_RarityTables[entry.rarityTableIndex];
 
-	CalculateLootMatrix(lootMatrixID, user, result);
+            uint32_t dropCount = GeneralUtils::GenerateRandomNumber<uint32_t>(entry.minDrop, entry.maxDrop);
+            for (uint32_t i = 0; i < dropCount; ++i) {
+                uint32_t maxRarity = 1;
 
-	GiveLoot(user, result);
+                float rarityRoll = GeneralUtils::GenerateRandomNumber<float>(0, 1);
+
+                for (const RarityTableEntry& rarity : rarityTable) {
+                    if (rarity.randMax >= rarityRoll) {
+                        maxRarity = rarity.rarity;
+                    } else {
+                        break;
+                    }
                 }
 
-void Loot::DropLoot(Entity* user, Entity* killedObject, uint32_t lootMatrixID, uint32_t minCoins, uint32_t maxCoins) {
+                bool rarityFound = false;
-	user = user->GetOwner(); // If the owner is overwritten, we collect that here
+                std::vector<LootTableEntry> possibleDrops;
 
-	auto* inventoryComponent = user->GetComponent<InventoryComponent>();
+                for (const LootTableEntry& loot : lootTable) {
+                    uint32_t rarity = m_ItemRarities[loot.itemID];
 
-	if (inventoryComponent == nullptr) {
+                    if (rarity == maxRarity) {
+                        possibleDrops.push_back(loot);
+                        rarityFound = true;
+                    } else if (rarity < maxRarity && !rarityFound) {
+                        possibleDrops.push_back(loot);
+                        maxRarity = rarity;
+                    }
+                }
+
+                if (possibleDrops.size() > 0) {
+                    LootTableEntry drop = possibleDrops[GeneralUtils::GenerateRandomNumber<uint32_t>(0, possibleDrops.size() - 1)];
+
+                    // filter out uneeded mission items
+                    if (drop.isMissionDrop && !missionComponent->RequiresItem(drop.itemID))
+                        continue;
+
+                    // convert faction token proxy
+                    if (drop.itemID == 13763) {
+                        if (missionComponent->GetMissionState(545) == MissionState::MISSION_STATE_COMPLETE)
+                            drop.itemID = 8318; // "Assembly Token"
+                        else if (missionComponent->GetMissionState(556) == MissionState::MISSION_STATE_COMPLETE)
+                            drop.itemID = 8321; // "Venture League Token"
+                        else if (missionComponent->GetMissionState(567) == MissionState::MISSION_STATE_COMPLETE)
+                            drop.itemID = 8319; // "Sentinels Token"
+                        else if (missionComponent->GetMissionState(578) == MissionState::MISSION_STATE_COMPLETE)
+                            drop.itemID = 8320; // "Paradox Token"
+                    }
+
+                    if (drop.itemID == 13763) {
+                        continue;
+                    } // check if we aren't in faction
+
+                    if (drops.find(drop.itemID) == drops.end()) {
+                        drops.insert({drop.itemID, 1});
+                    } else {
+                        ++drops[drop.itemID];
+                    }
+                }
+            }
+        }
+    }
+
+    return drops;
+}
+
+std::unordered_map<LOT, int32_t> LootGenerator::RollLootMatrix(uint32_t matrixIndex) {
+    std::unordered_map<LOT, int32_t> drops;
+
+    const LootMatrix& matrix = m_LootMatrices[matrixIndex];
+
+    for (const LootMatrixEntry& entry : matrix) {
+        if (GeneralUtils::GenerateRandomNumber<float>(0, 1) < entry.percent) {
+            const LootTable& lootTable = m_LootTables[entry.lootTableIndex];
+            const RarityTable& rarityTable = m_RarityTables[entry.rarityTableIndex];
+
+            uint32_t dropCount = GeneralUtils::GenerateRandomNumber<uint32_t>(entry.minDrop, entry.maxDrop);
+            for (uint32_t i = 0; i < dropCount; ++i) {
+                uint32_t maxRarity = 1;
+
+                float rarityRoll = GeneralUtils::GenerateRandomNumber<float>(0, 1);
+
+                for (const RarityTableEntry& rarity : rarityTable) {
+                    if (rarity.randMax >= rarityRoll) {
+                        maxRarity = rarity.rarity;
+                    } else {
+                        break;
+                    }
+                }
+
+                bool rarityFound = false;
+                std::vector<LootTableEntry> possibleDrops;
+
+                for (const LootTableEntry& loot : lootTable) {
+                    uint32_t rarity = m_ItemRarities[loot.itemID];
+
+                    if (rarity == maxRarity) {
+                        possibleDrops.push_back(loot);
+                        rarityFound = true;
+                    } else if (rarity < maxRarity && !rarityFound) {
+                        possibleDrops.push_back(loot);
+                        maxRarity = rarity;
+                    }
+                }
+
+                if (possibleDrops.size() > 0) {
+                    const LootTableEntry& drop = possibleDrops[GeneralUtils::GenerateRandomNumber<uint32_t>(0, possibleDrops.size() - 1)];
+
+                    if (drops.find(drop.itemID) == drops.end()) {
+                        drops.insert({drop.itemID, 1});
+                    } else {
+                        ++drops[drop.itemID];
+                    }
+                }
+            }
+        }
+    }
+
+    return drops;
+}
+
+void LootGenerator::GiveLoot(Entity* player, uint32_t matrixIndex) {
+    player = player->GetOwner(); // If the owner is overwritten, we collect that here
+
+    std::unordered_map<LOT, int32_t> result = RollLootMatrix(player, matrixIndex);
+
+    GiveLoot(player, result);
+}
+
+void LootGenerator::GiveLoot(Entity* player, std::unordered_map<LOT, int32_t>& result) {
+    player = player->GetOwner(); // if the owner is overwritten, we collect that here
+
+    auto* inventoryComponent = player->GetComponent<InventoryComponent>();
+
+    if (!inventoryComponent)
         return;
-	}
-
-	std::unordered_map<LOT, int32_t> result {};
-
-	CalculateLootMatrix(lootMatrixID, user, result);
-
-	DropLoot(user, killedObject, result, minCoins, maxCoins);
-}
-
-void Loot::GiveLoot(Entity* user, std::unordered_map<LOT, int32_t>& result) {
-	user = user->GetOwner(); // If the owner is overwritten, we collect that here
-
-	auto* inventoryComponent = user->GetComponent<InventoryComponent>();
-
-	if (inventoryComponent == nullptr) {
-		return;
-	}
 
     for (const auto& pair : result) {
         inventoryComponent->AddItem(pair.first, pair.second);
     }
 }
 
-void Loot::DropLoot(Entity* user, Entity* killedObject, std::unordered_map<LOT, int32_t>& result, uint32_t minCoins, uint32_t maxCoins) {
+void LootGenerator::GiveActivityLoot(Entity* player, Entity* source, uint32_t activityID, int32_t rating) {
-	user = user->GetOwner(); // If the owner is overwritten, we collect that here
+    CDActivityRewardsTable* activityRewardsTable = CDClientManager::Instance()->GetTable<CDActivityRewardsTable>("ActivityRewards");
+    std::vector<CDActivityRewards> activityRewards = activityRewardsTable->Query([activityID](CDActivityRewards entry) { return (entry.objectTemplate == activityID); });
 
-	auto* inventoryComponent = user->GetComponent<InventoryComponent>();
+    const CDActivityRewards* selectedReward = nullptr;
-
+    for (const auto& activityReward : activityRewards) {
-	if (inventoryComponent == nullptr) {
+        if (activityReward.activityRating <= rating && (selectedReward == nullptr || activityReward.activityRating > selectedReward->activityRating)) {
-		return;
+            selectedReward = &activityReward;
         }
+    }
+
+    if (!selectedReward)
+        return;
+
+    uint32_t minCoins = 0;
+    uint32_t maxCoins = 0;
+
+    CDCurrencyTableTable* currencyTableTable = CDClientManager::Instance()->GetTable<CDCurrencyTableTable>("CurrencyTable");
+    std::vector<CDCurrencyTable> currencyTable = currencyTableTable->Query([selectedReward](CDCurrencyTable entry) { return (entry.currencyIndex == selectedReward->CurrencyIndex && entry.npcminlevel == 1); });
+
+    if (currencyTable.size() > 0) {
+        minCoins = currencyTable[0].minvalue;
+        maxCoins = currencyTable[0].maxvalue;
+    }
+
+    GiveLoot(player, selectedReward->LootMatrixIndex);
+
+    uint32_t coins = (int)(minCoins + GeneralUtils::GenerateRandomNumber<float>(0, 1) * (maxCoins - minCoins));
+
+    auto* character = player->GetCharacter();
+
+    character->SetCoins(character->GetCoins() + coins);
+}
+
+void LootGenerator::DropLoot(Entity* player, Entity* killedObject, uint32_t matrixIndex, uint32_t minCoins, uint32_t maxCoins) {
+    player = player->GetOwner(); // if the owner is overwritten, we collect that here
+
+    auto* inventoryComponent = player->GetComponent<InventoryComponent>();
+
+    if (!inventoryComponent)
+        return;
+
+    std::unordered_map<LOT, int32_t> result = RollLootMatrix(player, matrixIndex);
+
+    DropLoot(player, killedObject, result, minCoins, maxCoins);
+}
+
+void LootGenerator::DropLoot(Entity* player, Entity* killedObject, std::unordered_map<LOT, int32_t>& result, uint32_t minCoins, uint32_t maxCoins) {
+    player = player->GetOwner(); // if the owner is overwritten, we collect that here
+
+    auto* inventoryComponent = player->GetComponent<InventoryComponent>();
+
+    if (!inventoryComponent)
+        return;
 
     const auto spawnPosition = killedObject->GetPosition();
 
@@ -84,31 +350,27 @@ void Loot::DropLoot(Entity* user, Entity* killedObject, std::unordered_map<LOT,
 
     for (const auto& pair : result) {
         for (int i = 0; i < pair.second; ++i) {
-			GameMessages::SendDropClientLoot(user, source, pair.first, 0, spawnPosition, 1);
+            GameMessages::SendDropClientLoot(player, source, pair.first, 0, spawnPosition, 1);
         }
     }
 
     uint32_t coins = (int)(minCoins + GeneralUtils::GenerateRandomNumber<float>(0, 1) * (maxCoins - minCoins));
 
-	GameMessages::SendDropClientLoot(user, source, LOT_NULL, coins, spawnPosition);
+    GameMessages::SendDropClientLoot(player, source, LOT_NULL, coins, spawnPosition);
 }
 
-void Loot::DropActivityLoot(Entity* user, Entity* source, uint32_t activityID, int32_t rating)
+void LootGenerator::DropActivityLoot(Entity* player, Entity* source, uint32_t activityID, int32_t rating) {
-{
     CDActivityRewardsTable* activityRewardsTable = CDClientManager::Instance()->GetTable<CDActivityRewardsTable>("ActivityRewards");
-	std::vector<CDActivityRewards> activityRewards = activityRewardsTable->Query([=](CDActivityRewards entry) { return (entry.objectTemplate == activityID); });
+    std::vector<CDActivityRewards> activityRewards = activityRewardsTable->Query([activityID](CDActivityRewards entry) { return (entry.objectTemplate == activityID); });
 
     const CDActivityRewards* selectedReward = nullptr;
-	for (const auto& activityReward : activityRewards)
+    for (const auto& activityReward : activityRewards) {
-	{
+        if (activityReward.activityRating <= rating && (selectedReward == nullptr || activityReward.activityRating > selectedReward->activityRating)) {
-		if (activityReward.activityRating <= rating && (selectedReward == nullptr || activityReward.activityRating > selectedReward->activityRating))
-		{
             selectedReward = &activityReward;
         }
     }
 
-	if (selectedReward == nullptr)
+    if (selectedReward == nullptr) {
-	{
         return;
     }
 
@@ -116,269 +378,12 @@ void Loot::DropActivityLoot(Entity* user, Entity* source, uint32_t activityID, i
     uint32_t maxCoins = 0;
 
     CDCurrencyTableTable* currencyTableTable = CDClientManager::Instance()->GetTable<CDCurrencyTableTable>("CurrencyTable");
-	std::vector<CDCurrencyTable> currencyTable = currencyTableTable->Query([=](CDCurrencyTable entry) { return (entry.currencyIndex == selectedReward->CurrencyIndex && entry.npcminlevel == 1); });
+    std::vector<CDCurrencyTable> currencyTable = currencyTableTable->Query([selectedReward](CDCurrencyTable entry) { return (entry.currencyIndex == selectedReward->CurrencyIndex && entry.npcminlevel == 1); });
 
     if (currencyTable.size() > 0) {
         minCoins = currencyTable[0].minvalue;
         maxCoins = currencyTable[0].maxvalue;
     }
 
-	Loot::DropLoot(user, source, selectedReward->LootMatrixIndex, minCoins, maxCoins);
+    DropLoot(player, source, selectedReward->LootMatrixIndex, minCoins, maxCoins);
-}
-
-void Loot::GiveActivityLoot(Entity* user, Entity* source, uint32_t activityID, int32_t rating) 
-{
-	CDActivityRewardsTable* activityRewardsTable = CDClientManager::Instance()->GetTable<CDActivityRewardsTable>("ActivityRewards");
-	std::vector<CDActivityRewards> activityRewards = activityRewardsTable->Query([=](CDActivityRewards entry) { return (entry.objectTemplate == activityID); });
-
-	const CDActivityRewards* selectedReward = nullptr;
-	for (const auto& activityReward : activityRewards)
-	{
-		if (activityReward.activityRating <= rating && (selectedReward == nullptr || activityReward.activityRating > selectedReward->activityRating))
-		{
-			selectedReward = &activityReward;
-		}
-	}
-
-	if (selectedReward == nullptr)
-	{
-		return;
-	}
-
-	uint32_t minCoins = 0;
-	uint32_t maxCoins = 0;
-
-	CDCurrencyTableTable* currencyTableTable = CDClientManager::Instance()->GetTable<CDCurrencyTableTable>("CurrencyTable");
-	std::vector<CDCurrencyTable> currencyTable = currencyTableTable->Query([=](CDCurrencyTable entry) { return (entry.currencyIndex == selectedReward->CurrencyIndex && entry.npcminlevel == 1); });
-
-	if (currencyTable.size() > 0) {
-		minCoins = currencyTable[0].minvalue;
-		maxCoins = currencyTable[0].maxvalue;
-	}
-
-	Loot::GiveLoot(user, selectedReward->LootMatrixIndex);
-
-	uint32_t coins = (int)(minCoins + GeneralUtils::GenerateRandomNumber<float>(0, 1) * (maxCoins - minCoins));
-
-	auto* charactert = user->GetCharacter();
-
-	charactert->SetCoins(charactert->GetCoins() + coins);
-}
-
-void Loot::CalculateLootMatrix(uint32_t lootMatrixID, Entity* user, std::unordered_map<LOT, int32_t>& result) 
-{
-	user = user->GetOwner();
-
-	auto* missionComponent = user->GetComponent<MissionComponent>();
-
-	// Get our loot for this LOT's lootMatrixID:
-	CDLootMatrixTable* lootMatrixTable = CDClientManager::Instance()->GetTable<CDLootMatrixTable>("LootMatrix");
-	CDLootTableTable* lootTableTable = CDClientManager::Instance()->GetTable<CDLootTableTable>("LootTable");
-	CDRarityTableTable* rarityTableTable = CDClientManager::Instance()->GetTable<CDRarityTableTable>("RarityTable");
-
-	std::vector<CDLootMatrix> lootMatrix = lootMatrixTable->Query([lootMatrixID](CDLootMatrix entry) { return (entry.LootMatrixIndex == lootMatrixID); });
-
-	// Now, loop through each entry
-	for (uint32_t i = 0; i < lootMatrix.size(); ++i) {
-		// Now, determine whether or not we should drop this
-		float chanceToDrop = 1.0 - lootMatrix[i].percent;
-		float shouldDrop = GeneralUtils::GenerateRandomNumber<float>(0, 1);
-
-		const auto rarityTableIndex = lootMatrix[i].RarityTableIndex;
-
-		std::vector<CDRarityTable> rarityTable = rarityTableTable->Query([rarityTableIndex](CDRarityTable entry) { return (entry.RarityTableIndex == rarityTableIndex); });
-		
-		std::sort(rarityTable.begin(), rarityTable.end());
-
-		if (shouldDrop < chanceToDrop) {
-			// We are not able to drop this item, so continue
-			continue;
-		}
-
-		// If we reached here, we are able to drop the item
-		uint32_t minToDrop = lootMatrix[i].minToDrop;
-		uint32_t maxToDrop = lootMatrix[i].maxToDrop;
-
-		// Now determine the number we will drop of items from this table
-		uint32_t numToDrop = GeneralUtils::GenerateRandomNumber<uint32_t>(minToDrop, maxToDrop);
-
-		// Now, query the loot matrix index
-		const auto lootTableIndex = lootMatrix[i].LootTableIndex;
-
-		std::vector<CDLootTable> lootTable = lootTableTable->Query([lootTableIndex](CDLootTable entry) { return (entry.LootTableIndex == lootTableIndex); });
-
-		// Now randomize these entries
-		if (lootTable.size() > 1) {
-			std::shuffle(std::begin(lootTable), std::end(lootTable), Game::randomEngine);
-		}
-
-		uint32_t addedItems = 0;
-
-		if (lootTable.empty()) continue;
-
-		while (addedItems < numToDrop) {
-			addedItems++;
-			
-			float rarityRoll = GeneralUtils::GenerateRandomNumber<float>(0, 1);
-
-			// im sorry
-			uint32_t highestRarity = 1; // LOOT_COMMON
-			float highestRandMax = 0.0f;
-			for (const auto& rarity : rarityTable) {
-				if (rarityRoll > rarity.randmax && rarity.randmax > highestRandMax) {
-					highestRandMax = rarity.randmax;
-					highestRarity = rarity.rarity + 1;
-				}
-			}
-
-			std::vector<CDLootTable> refinedLoot;
-
-			if (lootTable.size() == 1)
-			{
-				refinedLoot = lootTable;
-			}
-			else
-			{
-				refinedLoot = GetLootOfRarity(lootTable, highestRarity);
-
-				bool continueLoop = false;
-				while (refinedLoot.empty())
-				{
-					if (highestRarity == 1)
-					{
-						continueLoop = true;
-						break;
-					}
-
-					highestRarity -= 1;
-
-					refinedLoot = GetLootOfRarity(lootTable, highestRarity);
-
-					if (!refinedLoot.empty())
-					{
-						break;
-					}
-				}
-
-				if (continueLoop) continue;
-			}
-			
-			int randomTable = GeneralUtils::GenerateRandomNumber<int>(0, refinedLoot.size() - 1);
-
-			const auto& selectedTable = refinedLoot[randomTable];
-
-			uint32_t itemLOT = selectedTable.itemid;
-			bool isMissionItem = selectedTable.MissionDrop;
-
-			if (isMissionItem && missionComponent != nullptr)
-			{
-                // TODO: this executes a query in a hot path, might be worth refactoring away
-				if (!missionComponent->RequiresItem(itemLOT))
-				{
-					continue;
-				}
-			}
-
-			if (lootTable.size() > numToDrop)
-			{
-				for (size_t i = 0; i < lootTable.size(); i++)
-				{
-					if (lootTable[i].id == selectedTable.id)
-					{
-						lootTable.erase(lootTable.begin() + i);
-
-						break;
-					}
-				}
-			}
-
-			const auto& it = result.find(itemLOT);
-			if (it != result.end()) {
-				it->second++;
-			}
-			else {
-				result.emplace(itemLOT, 1);
-			}
-		}
-	}
-
-	int32_t tokenCount = 0;
-
-	const auto& tokens = result.find(13763);
-
-	if (tokens != result.end()) {
-		tokenCount = tokens->second;
-
-		result.erase(tokens);
-	}
-
-	if (tokenCount == 0 || user == nullptr) {
-		return;
-	}
-
-	if (missionComponent == nullptr) {
-		return;
-	}
-
-	LOT tokenId = -1;
-
-	if (missionComponent->GetMissionState(545) == MissionState::MISSION_STATE_COMPLETE) // "Join Assembly!"
-	{
-		tokenId = 8318; // "Assembly Token"
-	}
-
-	if (missionComponent->GetMissionState(556) == MissionState::MISSION_STATE_COMPLETE) // "Join Venture League!"
-	{
-		tokenId = 8321; // "Venture League Token"
-	}
-
-	if (missionComponent->GetMissionState(567) == MissionState::MISSION_STATE_COMPLETE) // "Join The Sentinels!"
-	{
-		tokenId = 8319; // "Sentinels Token"
-	}
-
-	if (missionComponent->GetMissionState(578) == MissionState::MISSION_STATE_COMPLETE) // "Join Paradox!"
-	{
-		tokenId = 8320; // "Paradox Token"
-	}
-
-	if (tokenId != -1)
-	{
-		result.emplace(tokenId, tokenCount);
-	}
-}
-
-void Loot::DropItem(Entity* user, Entity* sourceObject, LOT item, int32_t currency, int32_t count, bool useTeam, bool freeForAll) 
-{
-	if (sourceObject == nullptr)
-	{
-		return;
-	}
-
-	const auto sourceID = sourceObject->GetObjectID();
-	const auto sourcePosition = sourceObject->GetPosition();
-
-	// If useTeam, drop the item once for each team member.
-	auto* team = TeamManager::Instance()->GetTeam(user->GetObjectID());
-
-	if (team != nullptr && useTeam)
-	{
-		for (const auto& memberID : team->members)
-		{
-			// Get the team member from its ID.
-			auto* member = EntityManager::Instance()->GetEntity(memberID);
-
-			if (member == nullptr) 
-			{
-				continue;
-			}
-
-			// Drop the item.
-			GameMessages::SendDropClientLoot(member, sourceID, item, currency, sourcePosition, count);
-		}
-
-		return;
-	}
-
-	GameMessages::SendDropClientLoot(user, sourceID, item, currency, sourcePosition, count);
 }

dGame/dUtilities/Loot.h

@@ -1,31 +1,62 @@
 #pragma once
+
 #include "dCommonVars.h"
+#include <unordered_map>
+#include "Singleton.h"
 #include <vector>
-#include "CDClientManager.h"
+
 class Entity;
 
+struct RarityTableEntry {
+    uint32_t rarity;
+    float randMax;
+};
+
+typedef std::vector<RarityTableEntry> RarityTable;
+
+struct LootMatrixEntry {
+    uint32_t lootTableIndex;
+    uint32_t rarityTableIndex;
+    float percent;
+    uint32_t minDrop;
+    uint32_t maxDrop;
+};
+
+typedef std::vector<LootMatrixEntry> LootMatrix;
+
+struct LootTableEntry {
+    LOT itemID;
+    bool isMissionDrop;
+};
+
+typedef std::vector<LootTableEntry> LootTable;
+
+// used for glue code with Entity and Player classes
 namespace Loot {
     struct Info {
         LWOOBJID id;
         LOT lot;
         uint32_t count;
     };
+}
 
-	std::vector<CDLootTable> GetLootOfRarity(const std::vector<CDLootTable> &lootTable, uint32_t rarity);
 
-	void DropActivityLoot(Entity* user, Entity* source, uint32_t activityID, int32_t rating = 0);
+class LootGenerator : public Singleton<LootGenerator> {
+  public:
+    LootGenerator();
 
-	void GiveActivityLoot(Entity* user, Entity* source, uint32_t activityID, int32_t rating = 0);
+    std::unordered_map<LOT, int32_t> RollLootMatrix(Entity* player, uint32_t matrixIndex);
+    std::unordered_map<LOT, int32_t> RollLootMatrix(uint32_t matrixIndex);
+    void GiveLoot(Entity* player, uint32_t matrixIndex);
+    void GiveLoot(Entity* player, std::unordered_map<LOT, int32_t>& result);
+    void GiveActivityLoot(Entity* player, Entity* source, uint32_t activityID, int32_t rating = 0);
+    void DropLoot(Entity* player, Entity* killedObject, uint32_t matrixIndex, uint32_t minCoins, uint32_t maxCoins);
+    void DropLoot(Entity* player, Entity* killedObject, std::unordered_map<LOT, int32_t>& result, uint32_t minCoins, uint32_t maxCoins);
+    void DropActivityLoot(Entity* player, Entity* source, uint32_t activityID, int32_t rating = 0);
 
-	void CalculateLootMatrix(uint32_t lootMatrixID, Entity* user, std::unordered_map<LOT, int32_t>& result);
+  private:
-
+    std::unordered_map<uint32_t, uint8_t> m_ItemRarities;
-	void GiveLoot(Entity* user, uint32_t lootMatrixID);
+    std::unordered_map<uint32_t, RarityTable> m_RarityTables;
-
+    std::unordered_map<uint32_t, LootMatrix> m_LootMatrices;
-	void DropLoot(Entity* user, Entity* killedObject, uint32_t lootMatrixID, uint32_t minCoins, uint32_t maxCoins);
+    std::unordered_map<uint32_t, LootTable> m_LootTables;
-
-	void GiveLoot(Entity* user, std::unordered_map<LOT, int32_t>& result);
-
-	void DropLoot(Entity* user, Entity* killedObject, std::unordered_map<LOT, int32_t>& result, uint32_t minCoins, uint32_t maxCoins);
-
-	void DropItem(Entity* user, Entity* sourceObject, LOT item, int32_t currency, int32_t count, bool useTeam = false, bool freeForAll = false);
 };

dGame/dUtilities/SlashCommandHandler.cpp

@@ -407,7 +407,7 @@ void SlashCommandHandler::HandleChatCommand(const std::u16string& command, Entit
     stmt->execute();
     delete stmt;
 	
-	if (chatCommand == "setMinifig" && args.size() == 2 && entity->GetGMLevel() >= GAME_MASTER_LEVEL_FORUM_MODERATOR) { // could break characters so only allow if GM > 0
+	if (chatCommand == "setminifig" && args.size() == 2 && entity->GetGMLevel() >= GAME_MASTER_LEVEL_FORUM_MODERATOR) { // could break characters so only allow if GM > 0
 		int32_t minifigItemId;
 		if (!GeneralUtils::TryParse(args[1], minifigItemId)) {
 			ChatPackets::SendSystemMessage(sysAddr, u"Invalid Minifig Item Id ID.");
@@ -434,7 +434,7 @@ void SlashCommandHandler::HandleChatCommand(const std::u16string& command, Entit
 			charComp->m_Character->SetMouth(minifigItemId);
 		} else if (lowerName == "righthand") {
 			charComp->m_Character->SetRightHand(minifigItemId);
-		} else if (lowerName == "shirt") {
+		} else if (lowerName == "shirtcolor") {
 			charComp->m_Character->SetShirtColor(minifigItemId);
 		} else if (lowerName == "hands") {
 			charComp->m_Character->SetLeftHand(minifigItemId);
@@ -1691,6 +1691,43 @@ void SlashCommandHandler::HandleChatCommand(const std::u16string& command, Entit
 		return;
 	}
 
+	if (chatCommand == "rollloot" && entity->GetGMLevel() >= GAME_MASTER_LEVEL_OPERATOR && args.size() >= 3) {
+		uint32_t lootMatrixIndex = 0;
+		uint32_t targetLot = 0;
+		uint32_t loops = 1;
+
+		if (!GeneralUtils::TryParse(args[0], lootMatrixIndex)) return;
+		if (!GeneralUtils::TryParse(args[1], targetLot)) return;
+		if (!GeneralUtils::TryParse(args[2], loops)) return;
+
+		uint64_t totalRuns = 0;
+
+		for (uint32_t i = 0; i < loops; i++) {
+			while (true) {
+				auto lootRoll = LootGenerator::Instance().RollLootMatrix(lootMatrixIndex);
+				totalRuns += 1;
+				bool doBreak = false;
+				for (const auto& kv : lootRoll) {
+					if ((uint32_t)kv.first == targetLot) {
+						doBreak = true;
+					}
+				}
+				if (doBreak) break;
+			}
+		}
+
+		std::u16string message = u"Ran loot drops looking for "
+			+ GeneralUtils::to_u16string(targetLot) 
+			+ u", " 
+			+ GeneralUtils::to_u16string(loops) 
+			+ u" times. It ran " 
+			+ GeneralUtils::to_u16string(totalRuns) 
+			+ u" times. Averaging out at "
+			+ GeneralUtils::to_u16string((float) totalRuns / loops);
+
+		ChatPackets::SendSystemMessage(sysAddr, message);
+	}
+
 	if (chatCommand == "inspect" && entity->GetGMLevel() >= GAME_MASTER_LEVEL_DEVELOPER && args.size() >= 1)
 	{
 		Entity* closest = nullptr;

dMasterServer/InstanceManager.cpp

@@ -43,7 +43,8 @@ Instance * InstanceManager::GetInstance(LWOMAPID mapID, bool isFriendTransfer, L
 		maxPlayers = GetHardCap(mapID);
 	}
 
-    instance = new Instance(mExternalIP, ++m_LastPort, mapID, ++m_LastInstanceID, cloneID, softCap, maxPlayers);
+    uint32_t port = GetFreePort();
+    instance = new Instance(mExternalIP, port, mapID, ++m_LastInstanceID, cloneID, softCap, maxPlayers);
 
     //Start the actual process:
 #ifdef _WIN32
@@ -59,7 +60,7 @@ Instance * InstanceManager::GetInstance(LWOMAPID mapID, bool isFriendTransfer, L
 
     cmd.append(std::to_string(mapID));
     cmd.append(" -port ");
-    cmd.append(std::to_string(m_LastPort));
+    cmd.append(std::to_string(port));
     cmd.append(" -instance ");
     cmd.append(std::to_string(m_LastInstanceID));
     cmd.append(" -maxclients ");
@@ -74,8 +75,6 @@ Instance * InstanceManager::GetInstance(LWOMAPID mapID, bool isFriendTransfer, L
 
     system(cmd.c_str());
 
-    m_LastPort++; //Increment it again because the next port is for World<->Server comm.
-    m_LastPort++; //Increment it again because the next port is for World<->Chat comm.
     m_Instances.push_back(instance);
 
     if (instance) {
@@ -97,6 +96,25 @@ bool InstanceManager::IsPortInUse(uint32_t port) {
 	return false;
 }
 
+uint32_t InstanceManager::GetFreePort() {
+    uint32_t port = m_LastPort;
+    std::vector<uint32_t> usedPorts;
+    for (Instance* i : m_Instances) {
+        usedPorts.push_back(i->GetPort());
+    }
+    
+    std::sort(usedPorts.begin(), usedPorts.end());
+
+    int portIdx = 0;
+    while (portIdx < usedPorts.size() && port == usedPorts[portIdx]) {
+        //increment by 3 since each instance uses 3 ports (instance, world-server, world-chat)
+        port += 3;
+        portIdx++;
+    }
+
+    return port;
+}
+
 void InstanceManager::AddPlayer(SystemAddress systemAddr, LWOMAPID mapID, LWOINSTANCEID instanceID) {
 	Instance* inst = FindInstance(mapID, instanceID);
 	if (inst) {
@@ -291,7 +309,8 @@ Instance* InstanceManager::CreatePrivateInstance(LWOMAPID mapID, LWOCLONEID clon
 
 	int maxPlayers = 999;
 	
-	instance = new Instance(mExternalIP, ++m_LastPort, mapID, ++m_LastInstanceID, cloneID, maxPlayers, maxPlayers, true, password);
+	uint32_t port = GetFreePort();
+	instance = new Instance(mExternalIP, port, mapID, ++m_LastInstanceID, cloneID, maxPlayers, maxPlayers, true, password);
 
     //Start the actual process:
     std::string cmd = "start ./WorldServer.exe -zone ";
@@ -302,7 +321,7 @@ Instance* InstanceManager::CreatePrivateInstance(LWOMAPID mapID, LWOCLONEID clon
 
     cmd.append(std::to_string(mapID));
     cmd.append(" -port ");
-    cmd.append(std::to_string(m_LastPort));
+    cmd.append(std::to_string(port));
     cmd.append(" -instance ");
     cmd.append(std::to_string(m_LastInstanceID));
     cmd.append(" -maxclients ");
@@ -317,8 +336,6 @@ Instance* InstanceManager::CreatePrivateInstance(LWOMAPID mapID, LWOCLONEID clon
 
     system(cmd.c_str());
 
-	m_LastPort++; //Increment it again because the next port is for World<->Server comm.
-	m_LastPort++; //Increment it again because the next port is for World<->Chat comm.
 	m_Instances.push_back(instance);
 
 	if (instance) return instance;

dMasterServer/InstanceManager.h

@@ -102,6 +102,7 @@ public:
 
 	Instance* GetInstance(LWOMAPID mapID, bool isFriendTransfer, LWOCLONEID cloneID); //Creates an instance if none found
 	bool IsPortInUse(uint32_t port);
+	uint32_t GetFreePort();
 	
 	void AddPlayer(SystemAddress systemAddr, LWOMAPID mapID, LWOINSTANCEID instanceID);
 	void RemovePlayer(SystemAddress systemAddr, LWOMAPID mapID, LWOINSTANCEID instanceID);

dMasterServer/MasterServer.cpp

@@ -47,9 +47,12 @@ namespace Game {
 bool shutdownSequenceStarted = false;
 void ShutdownSequence();
 dLogger* SetupLogger();
+void StartAuthServer();
+void StartChatServer();
 void HandlePacket(Packet* packet);
 std::map<uint32_t, std::string> activeSessions;
 bool shouldShutdown = false;
+SystemAddress chatServerMasterPeerSysAddr;
 
 int main(int argc, char** argv) {
 	Diagnostics::SetProcessName("Master");
@@ -72,6 +75,7 @@ int main(int argc, char** argv) {
 	dConfig config("masterconfig.ini");
 	Game::config = &config;
 	Game::logger->SetLogToConsole(bool(std::stoi(config.GetValue("log_to_console"))));
+	Game::logger->SetLogDebugStatements(config.GetValue("log_debug_statements") == "1");
 
 	//Connect to CDClient
 	try {
@@ -181,35 +185,12 @@ int main(int argc, char** argv) {
 
 	//Depending on the config, start up servers:
 	if (config.GetValue("prestart_servers") != "" && config.GetValue("prestart_servers") == "1") {
-#ifdef __APPLE__
+		StartChatServer();
-		//macOS doesn't need sudo to run on ports < 1024
-		system("./ChatServer&");
-#elif _WIN32
-		system("start ./ChatServer.exe");
-#else
-		if (std::atoi(Game::config->GetValue("use_sudo_chat").c_str())) {
-			system("sudo ./ChatServer&");
-		}
-		else {
-			system("./ChatServer&");
-		}
-#endif
 
 		Game::im->GetInstance(0, false, 0)->SetIsReady(true);
 		Game::im->GetInstance(1000, false, 0)->SetIsReady(true);
 
-#ifdef __APPLE__
+		StartAuthServer();
-		system("./AuthServer&");
-#elif _WIN32
-		system("start ./AuthServer.exe");
-#else
-		if (std::atoi(Game::config->GetValue("use_sudo_auth").c_str())) {
-			system("sudo ./AuthServer&");
-		}
-		else {
-			system("./AuthServer&");
-		}
-#endif
 	}
 
 	auto t = std::chrono::high_resolution_clock::now();
@@ -320,11 +301,13 @@ dLogger* SetupLogger() {
 	std::string logPath =
 		"./logs/MasterServer_" + std::to_string(time(nullptr)) + ".log";
 	bool logToConsole = false;
+	bool logDebugStatements = false;
 #ifdef _DEBUG
 	logToConsole = true;
+	logDebugStatements = true;
 #endif
 
-	return new dLogger(logPath, logToConsole);
+	return new dLogger(logPath, logToConsole, logDebugStatements);
 }
 
 void HandlePacket(Packet* packet) {
@@ -338,6 +321,10 @@ void HandlePacket(Packet* packet) {
 		if (instance) {
 			Game::im->RemoveInstance(instance); //Delete the old
 		}
+
+		if (packet->systemAddress == chatServerMasterPeerSysAddr && !shouldShutdown) {
+			StartChatServer();
+		}
 	}
 
 	if (packet->data[0] == ID_CONNECTION_LOST) {
@@ -350,6 +337,10 @@ void HandlePacket(Packet* packet) {
 			Game::im->RemoveInstance(instance); //Delete the old
 			//Game::im->GetInstance(zoneID.GetMapID(), false, 0); //Create the new
 		}
+
+		if (packet->systemAddress == chatServerMasterPeerSysAddr && !shouldShutdown) {
+			StartChatServer();
+		}
 	}
 
 	if (packet->data[1] == MASTER) {
@@ -438,6 +429,14 @@ void HandlePacket(Packet* packet) {
 				}
 			}
 
+			if (theirServerType == ServerType::Chat) {
+				SystemAddress copy;
+				copy.binaryAddress = packet->systemAddress.binaryAddress;
+				copy.port = packet->systemAddress.port;
+
+				chatServerMasterPeerSysAddr = copy;
+			}
+
 			Game::logger->Log("MasterServer", "Received server info, instance: %i port: %i\n", theirInstanceID, theirPort);
 
 			break;
@@ -657,6 +656,37 @@ void HandlePacket(Packet* packet) {
 	}
 }
 
+void StartChatServer() {
+#ifdef __APPLE__
+		//macOS doesn't need sudo to run on ports < 1024
+		system("./ChatServer&");
+#elif _WIN32
+		system("start ./ChatServer.exe");
+#else
+		if (std::atoi(Game::config->GetValue("use_sudo_chat").c_str())) {
+			system("sudo ./ChatServer&");
+		}
+		else {
+			system("./ChatServer&");
+		}
+#endif
+}
+
+void StartAuthServer() {
+#ifdef __APPLE__
+		system("./AuthServer&");
+#elif _WIN32
+		system("start ./AuthServer.exe");
+#else
+		if (std::atoi(Game::config->GetValue("use_sudo_auth").c_str())) {
+			system("sudo ./AuthServer&");
+		}
+		else {
+			system("./AuthServer&");
+		}
+#endif
+}
+
 void ShutdownSequence() {
 	if (shutdownSequenceStarted) {
 		return;

dScripts/ActivityManager.cpp

@@ -70,7 +70,7 @@ void ActivityManager::StopActivity(Entity *self, const LWOOBJID playerID, const
         SetActivityValue(self, playerID, 1, value1);
         SetActivityValue(self, playerID, 2, value2);
 
-        Loot::GiveActivityLoot(player, self, gameID, CalculateActivityRating(self, playerID));
+        LootGenerator::Instance().GiveActivityLoot(player, self, gameID, CalculateActivityRating(self, playerID));
 
         // Save the new score to the leaderboard and show the leaderboard to the player
         LeaderboardManager::SaveScore(playerID, gameID, score, value1);

dScripts/AgPicnicBlanket.cpp

@@ -8,7 +8,7 @@ void AgPicnicBlanket::OnUse(Entity *self, Entity *user) {
     self->SetVar<bool>(u"active", true);
 
     auto lootTable = std::unordered_map<LOT, int32_t> {{935, 3}};
-    Loot::DropLoot(user, self, lootTable, 0, 0);
+    LootGenerator::Instance().DropLoot(user, self, lootTable, 0, 0);
 
     self->AddCallbackTimer(5.0f, [self]() {
         self->SetVar<bool>(u"active", false);

dScripts/BaseInteractDropLootServer.cpp

@@ -25,7 +25,7 @@ void BaseInteractDropLootServer::BaseUse(Entity* self, Entity* user)
 
     self->SetNetworkVar(u"bInUse", true);
 
-    Loot::DropLoot(user, self, lootMatrix, 0, 0);
+    LootGenerator::Instance().DropLoot(user, self, lootMatrix, 0, 0);
 
     self->AddCallbackTimer(cooldownTime, [this, self] () {
         self->SetNetworkVar(u"bInUse", false);

dScripts/BaseRandomServer.cpp

@@ -91,7 +91,7 @@ void BaseRandomServer::SetSpawnerNetwork(Entity* self, const std::string& spawne
 
     if (spawnerName == "Named_Enemies")
     {
-        //spawner->Reset();
+        spawner->SoftReset();
     }
 
     spawner->Activate();

dScripts/BootyDigServer.cpp

@@ -41,7 +41,7 @@ BootyDigServer::OnFireEventServerSide(Entity *self, Entity *sender, std::string
                 if (renderComponent != nullptr)
                     renderComponent->PlayEffect(7730, u"cast", "bootyshine");
 
-                Loot::DropLoot(player, self, 231, 75, 75);
+                LootGenerator::Instance().DropLoot(player, self, 231, 75, 75);
             }
         }
     } else if (args == "ChestDead") {

dScripts/BuccaneerValiantShip.cpp

@@ -0,0 +1,19 @@
+#include "BuccaneerValiantShip.h"
+#include "SkillComponent.h"
+#include "dLogger.h"
+
+void BuccaneerValiantShip::OnStartup(Entity* self) {
+    self->AddCallbackTimer(1.0F, [self]() {
+        auto* skillComponent = self->GetComponent<SkillComponent>();
+        auto* owner = self->GetOwner();
+
+        if (skillComponent != nullptr && owner != nullptr) {
+            skillComponent->CalculateBehavior(982, 20577, LWOOBJID_EMPTY, true, false, owner->GetObjectID());
+
+            // Kill self if missed
+            self->AddCallbackTimer(1.1F, [self]() {
+                self->Kill();
+            });
+        }
+    });
+}

dScripts/BuccaneerValiantShip.h

@@ -0,0 +1,6 @@
+#pragma once
+#include "CppScripts.h"
+
+class BuccaneerValiantShip : public CppScripts::Script {
+    void OnStartup(Entity *self) override;
+};

dScripts/CppScripts.cpp

@@ -261,6 +261,8 @@
 #include "PersonalFortress.h"
 #include "PropertyDevice.h"
 #include "ImaginationBackpackHealServer.h"
+#include "LegoDieRoll.h"
+#include "BuccaneerValiantShip.h"
 
 // Survival scripts
 #include "AgSurvivalStromling.h"
@@ -774,6 +776,10 @@ CppScripts::Script* CppScripts::GetScript(Entity* parent, const std::string& scr
 	    script = new PropertyDevice();
 	else if (scriptName == "scripts\\02_server\\Map\\General\\L_IMAG_BACKPACK_HEALS_SERVER.lua")
 	    script = new ImaginationBackpackHealServer();
+	else if (scriptName == "scripts\\ai\\GENERAL\\L_LEGO_DIE_ROLL.lua")
+		script = new LegoDieRoll();
+  	else if (scriptName == "scripts\\EquipmentScripts\\BuccaneerValiantShip.lua")
+    	script = new BuccaneerValiantShip();
 
 	//Ignore these scripts:
 	else if (scriptName == "scripts\\02_server\\Enemy\\General\\L_SUSPEND_LUA_AI.lua")
@@ -782,7 +788,8 @@ CppScripts::Script* CppScripts::GetScript(Entity* parent, const std::string& scr
 		script = invalidToReturn;
 	else if (script == invalidToReturn) {
 		if (scriptName.length() > 0)
-			Game::logger->Log("CppScripts", "Attempted to load CppScript for '" + scriptName + "', but returned InvalidScript.\n");
+			Game::logger->LogDebug("CppScripts", "Attempted to load CppScript for '" + scriptName + "', but returned InvalidScript.\n");
+			// information not really needed for sys admins but is for developers
 
 		script = invalidToReturn;
 	}

dScripts/CppScripts.h

@@ -6,6 +6,7 @@
 #include "MissionState.h"
 #include "Game.h"
 #include "dLogger.h"
+#include "Loot.h"
 
 class User;
 class Entity;

dScripts/GrowingFlower.cpp

@@ -10,7 +10,7 @@ void GrowingFlower::OnSkillEventFired(Entity *self, Entity *target, const std::s
         const auto mission1 = self->GetVar<int32_t>(u"missionID");
         const auto mission2 = self->GetVar<int32_t>(u"missionID2");
 
-        Loot::DropActivityLoot(target, self, self->GetLOT(), 0);
+        LootGenerator::Instance().DropActivityLoot(target, self, self->GetLOT(), 0);
 
         auto* missionComponent = target->GetComponent<MissionComponent>();
         if (missionComponent != nullptr) {

dScripts/LegoDieRoll.cpp

@@ -0,0 +1,55 @@
+#include "LegoDieRoll.h"
+#include "Entity.h"
+#include "dLogger.h"
+#include "GameMessages.h"
+
+void LegoDieRoll::OnStartup(Entity* self) {
+    self->AddTimer("DoneRolling", 10.0f);
+    self->AddTimer("ThrowDice", LegoDieRoll::animTime);
+}
+
+void LegoDieRoll::OnTimerDone(Entity* self, std::string timerName) {
+    if (timerName == "DoneRolling") {
+        self->Smash(self->GetObjectID(), SILENT);
+    } 
+    else if (timerName == "ThrowDice") {
+        int dieRoll = GeneralUtils::GenerateRandomNumber<int>(1, 6);
+
+        switch (dieRoll)
+        {
+        case 1:
+		    GameMessages::SendPlayAnimation(self, u"roll-die-1");
+            break;
+        case 2:
+		    GameMessages::SendPlayAnimation(self, u"roll-die-2");
+            break;
+        case 3:
+		    GameMessages::SendPlayAnimation(self, u"roll-die-3");
+            break;
+        case 4:
+		    GameMessages::SendPlayAnimation(self, u"roll-die-4");
+            break;
+        case 5:
+		    GameMessages::SendPlayAnimation(self, u"roll-die-5");
+            break;
+        case 6:
+            {
+		    GameMessages::SendPlayAnimation(self, u"roll-die-6");
+            // tracking the It's Truly Random Achievement 
+            auto* owner = self->GetOwner();
+            auto* missionComponent = owner->GetComponent<MissionComponent>();
+
+            if (missionComponent != nullptr) {
+                const auto rollMissionState = missionComponent->GetMissionState(756);
+                if (rollMissionState == MissionState::MISSION_STATE_ACTIVE) {
+                    missionComponent->ForceProgress(756, 1103, 1);
+                }
+            }
+            break;
+            }
+        default:
+	        Game::logger->LogDebug("LegoDieRoll", "Invalid animation: roll-die-%i\n", dieRoll);
+            break;
+        }
+    }
+}

dScripts/LegoDieRoll.h

@@ -0,0 +1,11 @@
+#pragma once
+#include "CppScripts.h"
+
+class LegoDieRoll : public CppScripts::Script {
+public:
+	void OnStartup(Entity* self);
+	void OnTimerDone(Entity* self, std::string timerName);
+private:
+    constexpr static const float animTime = 2.0f;
+};
+

dScripts/MinigameTreasureChestServer.cpp

@@ -18,14 +18,24 @@ void MinigameTreasureChestServer::OnUse(Entity *self, Entity *user) {
         UpdatePlayer(self, user->GetObjectID());
 
     auto* team = TeamManager::Instance()->GetTeam(user->GetObjectID());
+    uint32_t activityRating = 0;
     if (team != nullptr) {
         for (const auto& teamMemberID : team->members) {
             auto* teamMember = EntityManager::Instance()->GetEntity(teamMemberID);
-            if (teamMember != nullptr)
+            if (teamMember != nullptr) {
-                Loot::DropActivityLoot(teamMember, self, sac->GetActivityID(), CalculateActivityRating(self, teamMemberID));
+                activityRating = CalculateActivityRating(self, teamMemberID);
+
+                if (self->GetLOT() == frakjawChestId) activityRating = team->members.size();
+
+                LootGenerator::Instance().DropActivityLoot(teamMember, self, sac->GetActivityID(), activityRating);
+            }
         }
     } else {
-        Loot::DropActivityLoot(user, self, sac->GetActivityID(), CalculateActivityRating(self, user->GetObjectID()));
+        activityRating = CalculateActivityRating(self, user->GetObjectID());
+
+        if (self->GetLOT() == frakjawChestId) activityRating = 1;
+        
+        LootGenerator::Instance().DropActivityLoot(user, self, sac->GetActivityID(), activityRating);
     }
 
     sac->PlayerRemove(user->GetObjectID());

dScripts/MinigameTreasureChestServer.h

@@ -2,7 +2,10 @@
 #include "ActivityManager.h"
 
 class MinigameTreasureChestServer : public ActivityManager {
+public:
     void OnStartup(Entity* self) override;
     void OnUse(Entity* self, Entity* user) override;
     uint32_t CalculateActivityRating(Entity *self, LWOOBJID playerID) override;
+private:
+    const uint32_t frakjawChestId = 16486;
 };

dScripts/NjDragonEmblemChestServer.cpp

@@ -10,6 +10,6 @@ void NjDragonEmblemChestServer::OnUse(Entity *self, Entity *user) {
 
     auto* destroyable = self->GetComponent<DestroyableComponent>();
     if (destroyable != nullptr) {
-        Loot::DropLoot(user, self, destroyable->GetLootMatrixID(), 0, 0);
+        LootGenerator::Instance().DropLoot(user, self, destroyable->GetLootMatrixID(), 0, 0);
     }
 }

dScripts/SGCannon.cpp

@@ -423,7 +423,7 @@ void SGCannon::SpawnNewModel(Entity *self) {
 
             if (lootMatrix != 0) {
                 std::unordered_map<LOT, int32_t> toDrop = {};
-                Loot::CalculateLootMatrix(lootMatrix, player, toDrop);
+                toDrop = LootGenerator::Instance().RollLootMatrix(player, lootMatrix);
 
                 for (auto drop : toDrop) {
                     rewardModel->OnFireEventServerSide(self, ModelToBuildEvent, drop.first);
@@ -581,7 +581,7 @@ void SGCannon::StopGame(Entity *self, bool cancel) {
             );
         }
 
-        Loot::GiveActivityLoot(player, self, GetGameID(self), self->GetVar<uint32_t>(TotalScoreVariable));
+        LootGenerator::Instance().GiveActivityLoot(player, self, GetGameID(self), self->GetVar<uint32_t>(TotalScoreVariable));
 
         StopActivity(self, player->GetObjectID(), self->GetVar<uint32_t>(TotalScoreVariable),
                 self->GetVar<uint32_t>(MaxStreakVariable), percentage);

dScripts/ScriptedPowerupSpawner.cpp

@@ -24,7 +24,7 @@ void ScriptedPowerupSpawner::OnTimerDone(Entity *self, std::string message) {
                     renderComponent->PlayEffect(0, u"cast", "N_cast");
                 }
 
-                Loot::DropItem(owner, self, itemLOT, 0, 1, true, true);
+                LootGenerator::Instance().DropLoot(owner, self, itemLOT, 0, 1);
             }
 
             // Increment the current cycle

dScripts/TreasureChestDragonServer.cpp

@@ -39,12 +39,12 @@ void TreasureChestDragonServer::OnUse(Entity* self, Entity* user)
 
             if (memberObject == nullptr) continue;
 
-            Loot::DropActivityLoot(memberObject, self, scriptedActivityComponent->GetActivityID(), rating);
+            LootGenerator::Instance().DropActivityLoot(memberObject, self, scriptedActivityComponent->GetActivityID(), rating);
         }
     }
     else
     {
-        Loot::DropActivityLoot(user, self, scriptedActivityComponent->GetActivityID(), rating);
+        LootGenerator::Instance().DropActivityLoot(user, self, scriptedActivityComponent->GetActivityID(), rating);
     }
 
     self->Smash(self->GetObjectID());

dScripts/VeMissionConsole.cpp

@@ -4,7 +4,7 @@
 #include "GameMessages.h"
 
 void VeMissionConsole::OnUse(Entity *self, Entity *user) {
-    Loot::DropActivityLoot(user, self, 12551);
+    LootGenerator::Instance().DropActivityLoot(user, self, 12551);
 
     auto* inventoryComponent = user->GetComponent<InventoryComponent>();
     if (inventoryComponent != nullptr) {

dScripts/WishingWellServer.cpp

@@ -24,7 +24,7 @@ void WishingWellServer::OnUse(Entity* self, Entity* user)
         GameMessages::SendPlayNDAudioEmitter(self, user->GetSystemAddress(), audio);
     }
 
-    Loot::DropActivityLoot(
+    LootGenerator::Instance().DropActivityLoot(
         user,
         self,
         static_cast<uint32_t>(scriptedActivity->GetActivityID()),

dWorldServer/WorldServer.cpp

@@ -73,6 +73,7 @@ namespace Game {
 }
 
 bool chatDisabled = false;
+bool chatConnected = false;
 bool worldShutdownSequenceStarted = false;
 bool worldShutdownSequenceComplete = false;
 void WorldShutdownSequence();
@@ -89,6 +90,7 @@ struct tempSessionInfo {
 std::map<std::string, tempSessionInfo> m_PendingUsers;
 int instanceID = 0;
 int g_CloneID = 0;
+std::string databaseChecksum = "";
 
 int main(int argc, char** argv) {
 	Diagnostics::SetProcessName("World");
@@ -136,6 +138,7 @@ int main(int argc, char** argv) {
 	dConfig config("worldconfig.ini");
 	Game::config = &config;
 	Game::logger->SetLogToConsole(bool(std::stoi(config.GetValue("log_to_console"))));
+	Game::logger->SetLogDebugStatements(config.GetValue("log_debug_statements") == "1");
 	if (config.GetValue("disable_chat") == "1") chatDisabled = true;
 
 	// Connect to CDClient
@@ -185,6 +188,7 @@ int main(int argc, char** argv) {
 
 	ObjectIDManager::Instance()->Initialize();
 	UserManager::Instance()->Initialize();
+	LootGenerator::Instance();
 	Game::chatFilter = new dChatFilter("./res/chatplus_en_us", bool(std::stoi(config.GetValue("dont_generate_dcf"))));
 
 	Game::server = new dServer(masterIP, ourPort, instanceID, maxClients, false, true, Game::logger, masterIP, masterPort, ServerType::World, zoneID);
@@ -209,6 +213,7 @@ int main(int argc, char** argv) {
 	Packet* packet = nullptr;
 	int framesSinceLastFlush = 0;
 	int framesSinceMasterDisconnect = 0;
+	int framesSinceChatDisconnect = 0;
 	int framesSinceLastUsersSave = 0;
 	int framesSinceLastSQLPing = 0;
 	int framesSinceLastUser = 0;
@@ -234,6 +239,47 @@ int main(int argc, char** argv) {
 		Game::physicsWorld = &dpWorld::Instance(); //just in case some old code references it
 		dZoneManager::Instance()->Initialize(LWOZONEID(zoneID, instanceID, cloneID));
 		g_CloneID = cloneID;
+
+		// pre calculate the FDB checksum
+		if (Game::config->GetValue("check_fdb") == "1") {
+				std::ifstream fileStream;
+
+				static const std::vector<std::string> aliases = {
+					"res/CDServers.fdb",
+					"res/cdserver.fdb",
+					"res/CDClient.fdb",
+					"res/cdclient.fdb",
+				};
+				
+				for (const auto& file : aliases) {
+					fileStream.open(file, std::ios::binary | std::ios::in);
+					if (fileStream.is_open()) {
+						break;
+					}
+				}
+
+				const int bufferSize = 1024;
+				MD5* md5 = new MD5();
+				
+				char fileStreamBuffer[1024] = {};
+
+				while (!fileStream.eof()) {
+					memset(fileStreamBuffer, 0, bufferSize);
+					fileStream.read(fileStreamBuffer, bufferSize);
+					md5->update(fileStreamBuffer, fileStream.gcount());
+				}
+
+				fileStream.close();
+
+				const char* nullTerminateBuffer = "\0";
+				md5->update(nullTerminateBuffer, 1); // null terminate the data
+				md5->finalize();
+				databaseChecksum = md5->hexdigest();
+			
+				delete md5;
+
+				Game::logger->Log("WorldServer", "FDB Checksum calculated as: %s\n", databaseChecksum.c_str());
+			}
 	}
 
 	while (true) {
@@ -275,6 +321,19 @@ int main(int argc, char** argv) {
 		}
 		else framesSinceMasterDisconnect = 0;
 
+		// Check if we're still connected to chat:
+		if (!chatConnected) {
+			framesSinceChatDisconnect++;
+
+			// Attempt to reconnect every 30 seconds.
+			if (framesSinceChatDisconnect >= 2000) {
+				framesSinceChatDisconnect = 0;
+
+				Game::chatServer->Connect(masterIP.c_str(), chatPort, "3.25 ND1", 8);
+			}
+		}
+		else framesSinceChatDisconnect = 0;
+
 		//In world we'd update our other systems here.
 
 		if (zoneID != 0 && deltaTime > 0.0f) {
@@ -503,21 +562,27 @@ int main(int argc, char** argv) {
 dLogger * SetupLogger(int zoneID, int instanceID) {
 	std::string logPath = "./logs/WorldServer_" + std::to_string(zoneID) + "_" + std::to_string(instanceID) + "_" + std::to_string(time(nullptr)) + ".log";
 	bool logToConsole = false;
+	bool logDebugStatements = false;
 #ifdef _DEBUG
 	logToConsole = true;
+	logDebugStatements = true;
 #endif
 
-	return new dLogger(logPath, logToConsole);
+	return new dLogger(logPath, logToConsole, logDebugStatements);
 }
 
 void HandlePacketChat(Packet* packet) {
 	if (packet->data[0] == ID_DISCONNECTION_NOTIFICATION || packet->data[0] == ID_CONNECTION_LOST) {
         Game::logger->Log("WorldServer", "Lost our connection to chat, zone(%i), instance(%i)\n", Game::server->GetZoneID(), Game::server->GetInstanceID());
+		
+		chatConnected = false;
 	}
 
 	if (packet->data[0] == ID_CONNECTION_REQUEST_ACCEPTED) {
 		Game::logger->Log("WorldServer", "Established connection to chat, zone(%i), instance (%i)\n",Game::server -> GetZoneID(), Game::server -> GetInstanceID());
 		Game::chatSysAddr = packet->systemAddress;
+
+		chatConnected = true;
 	}
 
 	if (packet->data[0] == ID_USER_PACKET_ENUM) {
@@ -838,6 +903,32 @@ void HandlePacket(Packet* packet) {
 		case MSG_WORLD_CLIENT_VALIDATION: {
 			std::string username = PacketUtils::ReadString(0x08, packet, true);
 			std::string sessionKey = PacketUtils::ReadString(74, packet, true);
+			std::string clientDatabaseChecksum = PacketUtils::ReadString(packet->length - 33, packet, false);
+
+			// sometimes client puts a null terminator at the end of the checksum and sometimes doesn't, weird
+			clientDatabaseChecksum = clientDatabaseChecksum.substr(0, 32);
+
+			// If the check is turned on, validate the client's database checksum.
+			if (Game::config->GetValue("check_fdb") == "1" && !databaseChecksum.empty()) {
+				uint32_t gmLevel = 0;
+				auto* stmt = Database::CreatePreppedStmt("SELECT gm_level FROM accounts WHERE name=? LIMIT 1;");
+				stmt->setString(1, username.c_str());
+				
+				auto* res = stmt->executeQuery();
+				while (res->next()) {
+					gmLevel = res->getInt(1);
+				}
+
+				delete stmt;
+				delete res;
+
+				// Developers may skip this check
+				if (gmLevel < 8 && clientDatabaseChecksum != databaseChecksum) {
+					Game::logger->Log("WorldServer", "Client's database checksum does not match the server's, aborting connection.\n");
+					Game::server->Disconnect(packet->systemAddress, SERVER_DISCON_KICK);
+					return;
+				}
+			}
 			
 			//Request the session info from Master:
 			CBITSTREAM;

dZoneManager/Level.cpp

@@ -11,6 +11,8 @@
 #include "GeneralUtils.h"
 #include "Entity.h"
 #include "EntityManager.h"
+#include "CDFeatureGatingTable.h"
+#include "CDClientManager.h"
 
 Level::Level(Zone* parentZone, const std::string& filepath) {
     m_ParentZone = parentZone;

resources/authconfig.ini

@@ -19,6 +19,9 @@ max_clients=999
 # 0 or 1, should log to console
 log_to_console=1
 
+# 0 or 1, should log debug (developer only) statements to console for debugging, not needed for normal operation
+log_debug_statements=0
+
 # 0 or 1, should ignore playkeys
 # If 1 everyone with an account will be able to login, regardless of if they have a key or not
 dont_use_keys=0

resources/chatconfig.ini

@@ -19,5 +19,8 @@ max_clients=999
 # 0 or 1, should log to console
 log_to_console=1
 
+# 0 or 1, should log debug (developer only) statements to console for debugging, not needed for normal operation
+log_debug_statements=0
+
 # 0 or 1, should not compile chat hash map to file
 dont_generate_dcf=0

resources/masterconfig.ini

@@ -32,5 +32,8 @@ max_clients=999
 # 0 or 1, should log to console
 log_to_console=1
 
+# 0 or 1, should log debug (developer only) statements to console for debugging, not needed for normal operation
+log_debug_statements=0
+
 # 0 or 1, should autostart auth, chat, and char servers
 prestart_servers=1

resources/worldconfig.ini

@@ -20,6 +20,9 @@ max_clients=999
 # 0 or 1, should log to console
 log_to_console=1
 
+# 0 or 1, should log debug (developer only) statements to console for debugging, not needed for normal operation
+log_debug_statements=0
+
 # 0 or 1, should not compile chat hash map to file
 dont_generate_dcf=0
 
@@ -47,3 +50,6 @@ solo_racing=0
 
 # Disables the anti-speedhack system. If you get kicked randomly you might want to disable this, as it might just be lag
 disable_anti_speedhack=0
+
+# 0 or 1, check server fdb (res/CDServer.fdb) against clients
+check_fdb=0