source/LoginServer/LWorld.h

@@ -7,7 +7,7 @@
 #ifndef LWORLD_H
 #define LWORLD_H
 
-#include "../common/mutex.h"
+#include "../common/Mutex.h"
 
 #define ERROR_BADPASSWORD		"Bad password"
 #define	INVALID_ACCOUNT			"Invalid Server Account."

source/LoginServer/LoginDatabase.h

@@ -21,7 +21,7 @@
 #include "../common/types.h"
 #include "../common/MiscFunctions.h"
 #include "../common/servertalk.h"
-#include "../common/mutex.h"
+#include "../common/Mutex.h"
 #include "PacketHeaders.h"
 #include "LoginAccount.h"
 #include "LWorld.h"

source/LoginServer/net.cpp

@@ -35,7 +35,7 @@
 #include "../common/ConfigReader.h"
 #include "../common/Log.h"
 #include "../common/JsonParser.h"
-#include "../common/defines.h"
+#include "../common/Common_Defines.h"
 
 #ifdef WIN32
 	#define snprintf	_snprintf

source/WorldServer/Achievements/Achievements.h

@@ -22,7 +22,7 @@ along with EQ2Emulator.  If not, see <http://www.gnu.org/licenses/>.
 #define ACHIEVEMENTS_H_
 
 #include "../../common/types.h"
-#include "../../common/mutex.h"
+#include "../../common/Mutex.h"
 #include "../Items/Items.h"
 #include <map>
 #include <vector>

source/WorldServer/Chat/Chat.h

@@ -6,7 +6,7 @@
 #include <vector>
 #include "../../common/types.h"
 #include "../../common/EQPacket.h"
-#include "../../common/mutex.h"
+#include "../../common/Mutex.h"
 #include "../client.h"
 #include "ChatChannel.h"
 

source/WorldServer/Collections/Collections.h

@@ -2,7 +2,7 @@
 #define COLLECTIONS_H_
 
 #include "../../common/types.h"
-#include "../../common/mutex.h"
+#include "../../common/Mutex.h"
 #include "../Items/Items.h"
 #include <map>
 #include <vector>

source/WorldServer/Entity.h

@@ -20,7 +20,7 @@
 #ifndef __EQ2_ENTITY__
 #define __EQ2_ENTITY__
 #include "Spawn.h"
-#include "../common/mutex.h"
+#include "../common/Mutex.h"
 #include "Skills.h"
 #include "MutexList.h"
 #include "MutexVector.h"

source/WorldServer/Factions.h

@@ -4,7 +4,7 @@
 #define EQ2_FACTIONS
 
 #include "../common/ConfigReader.h"
-#include "../common/mutex.h"
+#include "../common/Mutex.h"
 
 struct Faction {
 	int32	id;
@@ -119,3 +119,4 @@ private:
 	map<int32, int8>		faction_percent;
 };
 #endif
+

source/WorldServer/GroundSpawn.h

@@ -5,7 +5,7 @@
 
 #include "Spawn.h"
 #include "client.h"
-#include "../common/mutex.h"
+#include "../common/Mutex.h"
 
 class GroundSpawn : public Spawn {
 public:
@@ -66,3 +66,4 @@ private:
 	bool 	randomize_heading;
 };
 #endif
+

source/WorldServer/Guilds/Guild.h

@@ -7,7 +7,7 @@
 #include <vector>
 #include <deque>
 #include <map>
-#include "../../common/mutex.h"
+#include "../../common/Mutex.h"
 #include "../MutexMap.h"
 using namespace std;
 

source/WorldServer/LoginServer.h

@@ -7,7 +7,7 @@
 #include "../common/linked_list.h"
 #include "../common/timer.h"
 #include "../common/queue.h"
-#include "../common/mutex.h"
+#include "../common/Mutex.h"
 #include "../common/TCPConnection.h"
 #include <deque>
 #include "MutexMap.h"

source/WorldServer/LuaInterface.h

@@ -27,7 +27,7 @@
 
 #include "Spawn.h"
 #include "Spells.h"
-#include "../common/mutex.h"
+#include "../common/Mutex.h"
 #include "Quests.h"
 #include "zoneserver.h"
 #include "client.h"

source/WorldServer/MutexHelper.h

@@ -4,7 +4,7 @@
 #define MUTEXHELPER_H
 
 #include "../common/timer.h"
-#include "../common/mutex.h"
+#include "../common/Mutex.h"
 #include <list>
 #include <map>
 

source/WorldServer/Recipes/Recipe.h

@@ -21,7 +21,7 @@
 #define RECIPE_H_
 
 #include "../../common/types.h"
-#include "../../common/mutex.h"
+#include "../../common/Mutex.h"
 #include "../classes.h"
 
 #include <string.h>

source/WorldServer/Rules/Rules.h

@@ -22,7 +22,7 @@
 
 #include <string.h>
 #include <map>
-#include "../../common/mutex.h"
+#include "../../common/Mutex.h"
 #include "../../common/types.h"
 
 using namespace std;

source/WorldServer/Spawn.h

@@ -38,7 +38,7 @@
 #include "Zone/map.h"
 #include "Zone/region_map.h"
 #include "Zone/region_map_v1.h"
-#include "../common/mutex.h"
+#include "../common/Mutex.h"
 #include "MutexList.h"
 #include <deque>
 #include <memory> // needed for LS to compile properly on linux
@@ -1594,3 +1594,4 @@ private:
 };
 
 #endif
+

source/WorldServer/Spells.h

@@ -11,7 +11,7 @@
 #include "../common/MiscFunctions.h"
 #include "client.h"
 #include "classes.h"
-#include "../common/mutex.h"
+#include "../common/Mutex.h"
 #include "AltAdvancement/AltAdvancement.h"
 
 #include <lua.hpp>
@@ -435,3 +435,4 @@ private:
 	int32 max_spell_id;
 };
 #endif
+

source/WorldServer/Titles.h

@@ -6,7 +6,7 @@
 #include <string>
 #include <map>
 #include <vector>
-#include "../common/mutex.h"
+#include "../common/Mutex.h"
 #include "../common/types.h"
 
 using namespace std;

source/WorldServer/Tradeskills/Tradeskills.h

@@ -4,7 +4,7 @@
 #define __EQ2_TRADESKILLS__
 
 #include "../../common/types.h"
-#include "../../common/mutex.h"
+#include "../../common/Mutex.h"
 #include "../Items/Items.h"
 #include <map>
 class Player;

source/WorldServer/Traits/Traits.h

@@ -23,7 +23,7 @@ along with EQ2Emulator.  If not, see <http://www.gnu.org/licenses/>.
 
 #include <vector>
 #include <map>
-#include "../../common/mutex.h"
+#include "../../common/Mutex.h"
 #include "../../common/types.h"
 #include "../../common/EQPacket.h"
 

source/WorldServer/WorldDatabase.h

@@ -34,7 +34,7 @@
 #include "../common/database.h"
 #include "../common/types.h"
 #include "../common/MiscFunctions.h"
-#include "../common/mutex.h"
+#include "../common/Mutex.h"
 #include "../common/DatabaseNew.h"
 #include "client.h"
 #include "Object.h"
@@ -686,3 +686,4 @@ private:
 	std::map<int32, int8>	zone_instance_types;
 };
 #endif
+

source/WorldServer/Zone/ChestTrap.h

@@ -1,7 +1,7 @@
 #include <string>
 #include <map>
 #include <list>
-#include "../../common/mutex.h"
+#include "../../common/Mutex.h"
 #include "../../common/types.h"
 #pragma once
 

source/WorldServer/Zone/map.h

@@ -24,7 +24,7 @@
 
 #include "../../common/types.h"
 #include "../../common/MiscFunctions.h"
-#include "../../common/mutex.h"
+#include "../../common/Mutex.h"
 #include "position.h"
 #include <stdio.h>
 

source/WorldServer/Zone/mob_movement_manager.h

@@ -1,7 +1,7 @@
 #pragma once
 #include <memory>
 #include "../Entity.h"
-#include "../../common/mutex.h"
+#include "../../common/Mutex.h"
 class Mob;
 class Client;
 

source/WorldServer/net.cpp

@@ -44,8 +44,9 @@ using namespace std;
 #include "../common/version.h"
 #include "../common/EQEMuError.h"
 #include "../common/opcodemgr.h"
-#include "../common/defines.h"
+#include "../common/Common_Defines.h"
 #include "../common/JsonParser.h"
+#include "../common/Common_Defines.h"
 
 #include "LoginServer.h"
 #include "Commands/Commands.h"

source/WorldServer/zoneserver.h

@@ -30,7 +30,7 @@
 #include "../common/servertalk.h"
 #include "../common/TCPConnection.h"
 #include "WorldTCPConnection.h"
-#include "../common/mutex.h"
+#include "../common/Mutex.h"
 #include "../common/DataBuffer.h"
 #include "net.h"
 #include "Player.h"

source/common/Common_Defines.h

@@ -0,0 +1,15 @@
+// Copyright (C) 2007-2025 EQ2EMulator
+// Licensed under GPL v3
+#define BASEDIR			"./"
+
+#ifndef DB_INI_FILE
+	#ifdef LOGIN
+		#define DB_INI_FILE		BASEDIR "login_db.ini"
+	#else
+		#define DB_INI_FILE		BASEDIR "world_db.ini"
+	#endif
+#endif
+
+#ifndef MAIN_CONFIG_FILE
+  #define MAIN_CONFIG_FILE		BASEDIR "server_config.json"
+#endif

source/common/ConfigReader.h

@@ -8,7 +8,7 @@
 #include <string>
 #include <vector>
 #include "xmlParser.h"
-#include "mutex.h"
+#include "Mutex.h"
 
 using namespace std;
 
@@ -32,3 +32,4 @@ private:
 	//vector<PacketStruct*> structs;
 };
 #endif
+

source/common/EQEMuError.cpp

@@ -6,7 +6,7 @@
 #endif
 #include "EQEMuError.h"
 #include "linked_list.h"
-#include "mutex.h"
+#include "Mutex.h"
 #include "MiscFunctions.h"
 #include <stdio.h>
 #include <string.h>
@@ -110,3 +110,5 @@ void CheckEQEMuErrorAndPause() {
 		getchar();
 	}
 }
+
+

source/common/EQStream.cpp

@@ -27,7 +27,7 @@
 #include "EQStream.h"
 #include "EQStreamFactory.h"
 #include "misc.h"
-#include "mutex.h"
+#include "Mutex.h"
 #include "op_codes.h"
 #include "crypto/crc.h"
 #include "packet_dump.h"

source/common/EQStream.h

@@ -18,7 +18,7 @@
 
 // Project headers
 #include "EQPacket.h"
-#include "mutex.h"
+#include "Mutex.h"
 #include "opcodemgr.h"
 #include "misc.h"
 #include "crypto/crypto.h"

source/common/Mutex.cpp

@@ -0,0 +1,361 @@
+/*
+	EQ2Emulator:  Everquest II Server Emulator
+	Copyright (C) 2007  EQ2EMulator Development Team (http://www.eq2emulator.net)
+
+	This file is part of EQ2Emulator.
+
+	EQ2Emulator is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	EQ2Emulator is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with EQ2Emulator.  If not, see <http://www.gnu.org/licenses/>.
+*/
+#include "../common/Log.h"
+#include "../common/debug.h"
+#include "../common/Mutex.h"
+
+Mutex::Mutex() {
+	readers = 0;
+	mlocked = false;
+	writing = false;
+	name = "";
+#ifdef DEBUG
+	stack.clear();
+#endif
+	//CSLock is a pointer so we can use a different attribute type on create
+	CSLock = new CriticalSection(MUTEX_ATTRIBUTE_RECURSIVE);
+}
+
+Mutex::~Mutex() {
+	safe_delete(CSLock);
+#ifdef DEBUG
+	stack.clear();
+#endif
+}
+
+void Mutex::SetName(string in_name) {
+#ifdef DEBUG
+	name = in_name;
+#endif
+}
+
+void Mutex::lock() {
+#ifdef DEBUG
+	int i = 0;
+#endif
+	if (name.length() > 0) {
+		while (mlocked) {
+#ifdef DEBUG
+			if (i > MUTEX_TIMEOUT_MILLISECONDS) {
+				LogWrite(MUTEX__ERROR, 0, "Mutex", "Possible deadlock attempt by '%s'!", name.c_str());
+				return;
+			}
+			i++;
+#endif
+			Sleep(1);
+		}
+	}
+	mlocked = true;
+	CSLock->lock();
+}
+
+bool Mutex::trylock() {
+	return CSLock->trylock();
+}
+
+void Mutex::unlock() {
+	CSLock->unlock();
+	mlocked = false;
+}
+
+void Mutex::readlock(const char* function, int32 line) {
+#ifdef DEBUG
+	int32 i = 0;
+#endif
+	while (true) {
+		//Loop until there isn't a writer, then we can read!
+		CSRead.lock();
+		if (!writing) {
+			readers++;
+			CSRead.unlock();
+#ifdef DEBUG
+			CSStack.lock();
+			if (function)
+				stack[(string)function]++;
+			CSStack.unlock();
+#endif
+			return;
+		}
+		CSRead.unlock();
+#ifdef DEBUG
+		if (i > MUTEX_TIMEOUT_MILLISECONDS) {
+			LogWrite(MUTEX__ERROR, 0, "Mutex", "The mutex %s called from %s at line %u timed out waiting for a readlock!", name.c_str(), function ? function : "name_not_provided", line);
+			LogWrite(MUTEX__ERROR, 0, "Mutex", "The following functions had locks:");
+			map<string, int32>::iterator itr;
+			CSStack.lock();
+			for (itr = stack.begin(); itr != stack.end(); itr++) {
+				if (itr->second > 0 && itr->first.length() > 0)
+					LogWrite(MUTEX__ERROR, 0, "Mutex", "%s, number of locks = %u", itr->first.c_str(), itr->second);
+			}
+			CSStack.unlock();
+			i = 0;
+			continue;
+		}
+		i++;
+#endif
+		Sleep(1);
+	}
+}
+
+void Mutex::releasereadlock(const char* function, int32 line) {
+	//Wait for the readcount lock
+	CSRead.lock();
+	//Lower the readcount by one, when readcount is 0 writers may start writing
+	readers--;
+	CSRead.unlock();
+#ifdef DEBUG
+	CSStack.lock();
+	if (function) {
+		map<string, int32>::iterator itr = stack.find((string)function);
+		if (itr != stack.end()) {
+			if (--(itr->second) == 0) {
+				stack.erase(itr);
+			}
+		}
+	}
+	CSStack.unlock();
+#endif
+}
+
+bool Mutex::tryreadlock(const char* function) {
+	//This returns true if able to instantly obtain a readlock, false if not
+	CSRead.lock();
+	if (!writing) {
+		readers++;
+		CSRead.unlock();
+	}
+	else {
+		CSRead.unlock();
+		return false;
+	}
+
+#ifdef DEBUG
+	CSStack.lock();
+	if (function)
+		stack[(string)function]++;
+	CSStack.unlock();
+#endif
+
+	return true;
+}
+
+void Mutex::writelock(const char* function, int32 line) {
+	//Wait until the writer lock becomes available, then we can be the only writer!
+#ifdef DEBUG
+	int32 i = 0;
+#endif
+	while (!CSWrite.trylock()) {
+#ifdef DEBUG
+		if (i > MUTEX_TIMEOUT_MILLISECONDS) {
+			LogWrite(MUTEX__ERROR, 0, "Mutex", "The mutex %s called from %s at line %u timed out waiting on another writelock!", name.c_str(), function ? function : "name_not_provided", line);
+			LogWrite(MUTEX__ERROR, 0, "Mutex", "The following functions had locks:");
+			map<string, int32>::iterator itr;
+			CSStack.lock();
+			for (itr = stack.begin(); itr != stack.end(); itr++) {
+				if (itr->second > 0 && itr->first.length() > 0)
+					LogWrite(MUTEX__ERROR, 0, "Mutex", "%s, number of locks = %u", itr->first.c_str(), itr->second);
+			}
+			CSStack.unlock();
+			i = 0;
+			continue;
+		}
+		i++;
+#endif
+		Sleep(1);
+	}
+	waitReaders(function, line);
+#ifdef DEBUG
+	CSStack.lock();
+	if (function)
+		stack[(string)function]++;
+	CSStack.unlock();
+#endif
+}
+
+void Mutex::releasewritelock(const char* function, int32 line) {
+	//Wait for the readcount lock
+	CSRead.lock();
+	//Readers are aloud again
+	writing = false;
+	CSRead.unlock();
+	//Allow other writers to write
+	CSWrite.unlock();
+#ifdef DEBUG
+	CSStack.lock();
+	if (function) {
+		map<string, int32>::iterator itr = stack.find((string)function);
+		if (itr != stack.end()) {
+			if (--(itr->second) == 0) {
+				stack.erase(itr);
+			}
+		}
+	}
+	CSStack.unlock();
+#endif
+}
+
+bool Mutex::trywritelock(const char* function) {
+	//This returns true if able to instantly obtain a writelock, false if not
+	if (CSWrite.trylock()) {
+		CSRead.lock();
+		if (readers == 0)
+			writing = true;
+		CSRead.unlock();
+		if (!writing) {
+			CSWrite.unlock();
+			return false;
+		}
+	}
+	else
+		return false;
+
+#ifdef DEBUG
+	CSStack.lock();
+	if (function)
+		stack[(string)function]++;
+	CSStack.unlock();
+#endif
+
+	return true;
+}
+
+void Mutex::waitReaders(const char* function, int32 line)
+{
+	//Wait for all current readers to stop, then we can write!
+#ifdef DEBUG
+	int32 i = 0;
+#endif
+	while (true)
+	{
+		CSRead.lock();
+		if (readers == 0)
+		{
+			writing = true;
+			CSRead.unlock();
+			break;
+		}
+		CSRead.unlock();
+#ifdef DEBUG
+		if (i > MUTEX_TIMEOUT_MILLISECONDS) {
+			LogWrite(MUTEX__ERROR, 0, "Mutex", "The mutex %s called from %s at line %u timed out while waiting on readers!", name.c_str(), function ? function : "name_not_provided", line);
+			LogWrite(MUTEX__ERROR, 0, "Mutex", "The following functions had locks:");
+			map<string, int32>::iterator itr;
+			CSStack.lock();
+			for (itr = stack.begin(); itr != stack.end(); itr++) {
+				if (itr->second > 0 && itr->first.length() > 0)
+					LogWrite(MUTEX__ERROR, 0, "Mutex", "%s, number of locks = %u", itr->first.c_str(), itr->second);
+			}
+			CSStack.unlock();
+			i = 0;
+			continue;
+		}
+		i++;
+#endif
+		Sleep(1);
+	}
+}
+
+LockMutex::LockMutex(Mutex* in_mut, bool iLock) {
+	mut = in_mut;
+	locked = iLock;
+	if (locked) {
+		mut->lock();
+	}
+}
+
+LockMutex::~LockMutex() {
+	if (locked) {
+		mut->unlock();
+	}
+}
+
+void LockMutex::unlock() {
+	if (locked)
+		mut->unlock();
+	locked = false;
+}
+
+void LockMutex::lock() {
+	if (!locked)
+		mut->lock();
+	locked = true;
+}
+
+CriticalSection::CriticalSection(int attribute) {
+#ifdef WIN32
+	InitializeCriticalSection(&CSMutex);
+#else
+	pthread_mutexattr_init(&type_attribute);
+	switch (attribute)
+	{
+	case MUTEX_ATTRIBUTE_FAST:
+		pthread_mutexattr_settype(&type_attribute, PTHREAD_MUTEX_FAST_NP);
+		break;
+	case MUTEX_ATTRIBUTE_RECURSIVE:
+		pthread_mutexattr_settype(&type_attribute, PTHREAD_MUTEX_RECURSIVE_NP);
+		break;
+	case MUTEX_ATTRIBUTE_ERRORCHK:
+		pthread_mutexattr_settype(&type_attribute, PTHREAD_MUTEX_ERRORCHECK_NP);
+		break;
+	default:
+		LogWrite(MUTEX__DEBUG, 0, "Critical Section", "Invalid mutex attribute type! Using PTHREAD_MUTEX_FAST_NP");
+		pthread_mutexattr_settype(&type_attribute, PTHREAD_MUTEX_FAST_NP);
+		break;
+	}
+	pthread_mutex_init(&CSMutex, &type_attribute);
+#endif
+}
+
+CriticalSection::~CriticalSection() {
+#ifdef WIN32
+	DeleteCriticalSection(&CSMutex);
+#else
+	pthread_mutex_destroy(&CSMutex);
+	pthread_mutexattr_destroy(&type_attribute);
+#endif
+}
+
+void CriticalSection::lock() {
+	//Waits for a lock on this critical section
+#ifdef WIN32
+	EnterCriticalSection(&CSMutex);
+#else
+	pthread_mutex_lock(&CSMutex);
+#endif
+}
+
+void CriticalSection::unlock() {
+	//Gets rid of one of the current thread's locks on this critical section
+#ifdef WIN32
+	LeaveCriticalSection(&CSMutex);
+#else
+	pthread_mutex_unlock(&CSMutex);
+#endif
+}
+
+bool CriticalSection::trylock() {
+	//Returns true if able to instantly get a lock on this critical section, false if not
+#ifdef WIN32
+	return TryEnterCriticalSection(&CSMutex);
+#else
+	return (pthread_mutex_trylock(&CSMutex) == 0);
+#endif
+}
+

source/common/Mutex.h

@@ -0,0 +1,86 @@
+// Copyright (C) 2007-2025 EQ2EMulator
+// Licensed under GPL v3
+#ifndef MYMUTEX_H
+#define MYMUTEX_H
+#ifdef WIN32
+	#include <WinSock2.h>
+	#include <windows.h>
+#else
+	#include <pthread.h>
+	#include "../common/unix.h"
+#endif	
+#include "../common/types.h"
+#include <string>
+#include <map>
+
+#define MUTEX_ATTRIBUTE_FAST      1
+#define MUTEX_ATTRIBUTE_RECURSIVE 2
+#define MUTEX_ATTRIBUTE_ERRORCHK  3
+#define MUTEX_TIMEOUT_MILLISECONDS     10000
+
+class CriticalSection {
+public:
+	CriticalSection(int attribute = MUTEX_ATTRIBUTE_FAST);
+	~CriticalSection();
+	void lock();
+	void unlock();
+	bool trylock();
+private:
+#ifdef WIN32
+	CRITICAL_SECTION CSMutex;
+#else
+	pthread_mutex_t CSMutex;
+	pthread_mutexattr_t type_attribute;
+#endif
+};
+
+class Mutex {
+public:
+	Mutex();
+	~Mutex();
+
+	void lock();
+	void unlock();
+	bool trylock();
+
+	void readlock(const char* function = 0, int32 line = 0);
+	void releasereadlock(const char* function = 0, int32 line = 0);
+	bool tryreadlock(const char* function = 0);
+
+	void writelock(const char* function = 0, int32 line = 0);
+	void releasewritelock(const char* function = 0, int32 line = 0);
+	bool trywritelock(const char* function = 0);
+
+	void waitReaders(const char* function = 0, int32 line = 0);
+
+	void SetName(string in_name);
+private:
+	CriticalSection  CSRead;
+	CriticalSection  CSWrite;
+	CriticalSection* CSLock;
+
+#ifdef DEBUG	//Used for debugging only
+	CriticalSection  CSStack;
+	map<string, int32> stack;
+#endif
+
+	int readers;
+	bool writing;
+	volatile bool mlocked;
+	string name;
+};
+
+
+class LockMutex {
+public:
+	LockMutex(Mutex* in_mut, bool iLock = true);
+	~LockMutex();
+	void unlock();
+	void lock();
+private:
+	bool	locked;
+	Mutex*	mut;
+};
+
+
+#endif

source/common/TCPConnection.h

@@ -30,7 +30,7 @@
 #endif
 
 #include "types.h"
-#include "mutex.h"
+#include "Mutex.h"
 #include "linked_list.h"
 #include "queue.h"
 #include "servertalk.h"

source/common/database.h

@@ -14,7 +14,7 @@
 #include "linked_list.h"
 #include "EQStream.h"
 #include "MiscFunctions.h"
-#include "mutex.h"
+#include "Mutex.h"
 #include <string>
 #include <vector>
 #include <map>

source/common/dbcore.h

@@ -10,7 +10,7 @@
 #endif
 #include <mysql.h>
 #include "../common/types.h"
-#include "../common/mutex.h"
+#include "../common/Mutex.h"
 #include "../common/linked_list.h"
 #include "../common/queue.h"
 #include "../common/timer.h"
@@ -58,3 +58,5 @@ private:
 	bool	pSSL;
 };
 #endif
+
+

source/common/debug.cpp

@@ -0,0 +1,319 @@
+// Copyright (C) 2007-2025 EQ2EMulator
+// Licensed under GPL v3
+
+/*
+	JA: File rendered obsolete (2011-08-12)
+
+#include "debug.h"
+
+#include <iostream>
+using namespace std;
+#include <time.h>
+#include <string.h>
+#ifdef WIN32
+	#include <process.h>
+
+	#define snprintf	_snprintf
+	#define vsnprintf	_vsnprintf
+	#define strncasecmp	_strnicmp
+	#define strcasecmp  _stricmp
+#else
+	#include <sys/types.h>
+	#include <unistd.h>
+	#include <stdarg.h>
+#endif
+#include "../common/MiscFunctions.h"
+
+EQEMuLog* LogFile = new EQEMuLog;
+AutoDelete<EQEMuLog> adlf(&LogFile);
+
+static const char* FileNames[EQEMuLog::MaxLogID] = { "logs/eq2emu", "logs/eq2emu", "logs/eq2emu_error", "logs/eq2emu_debug", "logs/eq2emu_quest", "logs/eq2emu_commands" };
+static const char* LogNames[EQEMuLog::MaxLogID] = { "Status", "Normal", "Error", "Debug", "Quest", "Command" };
+
+EQEMuLog::EQEMuLog() {
+	for (int i=0; i<MaxLogID; i++) {
+		fp[i] = 0;
+#if EQDEBUG >= 2
+		pLogStatus[i] = 1 | 2;
+#else
+		pLogStatus[i] = 0;
+#endif
+		logCallbackFmt[i] = NULL;
+		logCallbackBuf[i] = NULL;
+	}
+#if EQDEBUG < 2
+	pLogStatus[Status] = 3;
+	pLogStatus[Error] = 3;
+	pLogStatus[Debug] = 3;
+	pLogStatus[Quest] = 2;
+	pLogStatus[Commands] = 2;
+#endif
+}
+
+EQEMuLog::~EQEMuLog() {
+	for (int i=0; i<MaxLogID; i++) {
+		if (fp[i])
+			fclose(fp[i]);
+	}
+}
+
+bool EQEMuLog::open(LogIDs id) {
+	if (id >= MaxLogID) {
+		return false;
+    }
+	LockMutex lock(&MOpen);
+	if (pLogStatus[id] & 4) {
+		return false;
+    }
+    if (fp[id]) {
+        return true;
+    }
+
+	char exename[200] = "";
+#if defined(WORLD)
+	snprintf(exename, sizeof(exename), "_world");
+#elif defined(ZONE)
+	snprintf(exename, sizeof(exename), "_zone");
+#endif
+	char filename[200];
+#ifndef NO_PIDLOG
+	snprintf(filename, sizeof(filename), "%s%s_%04i.log", FileNames[id], exename, getpid());
+#else
+	snprintf(filename, sizeof(filename), "%s%s.log", FileNames[id], exename);
+#endif
+    fp[id] = fopen(filename, "a");
+    if (!fp[id]) {
+		cerr << "Failed to open log file: " << filename << endl;
+		pLogStatus[id] |= 4; // set file state to error
+        return false;
+    }
+    fputs("---------------------------------------------\n",fp[id]);
+    return true;
+}
+
+bool EQEMuLog::write(LogIDs id, const char *fmt, ...) {
+	char buffer[4096];
+
+	if (!this) {
+		return false;
+    }
+	if (id >= MaxLogID) {
+		return false;
+    }
+	bool dofile = false;
+	if (pLogStatus[id] & 1) {
+		dofile = open(id);
+	}
+	if (!(dofile || pLogStatus[id] & 2))
+		return false;
+	LockMutex lock(&MLog[id]);
+
+    time_t aclock;
+    struct tm *newtime;
+    
+    time( &aclock );                 //Get time in seconds
+    newtime = localtime( &aclock );  //Convert time to struct
+
+	if (dofile){
+#ifndef NO_PIDLOG
+		fprintf(fp[id], "[%04d%02d%02d %02d:%02d:%02d] ", newtime->tm_year+1900, newtime->tm_mon+1, newtime->tm_mday, newtime->tm_hour, newtime->tm_min, newtime->tm_sec);
+#else
+		fprintf(fp[id], "%04i [%04d%02d%02d %02d:%02d:%02d] ", getpid(), newtime->tm_year+1900, newtime->tm_mon+1, newtime->tm_mday, newtime->tm_hour, newtime->tm_min, newtime->tm_sec);
+#endif
+	}
+
+	va_list argptr;
+	va_start(argptr, fmt);
+	vsnprintf(buffer, sizeof(buffer), fmt, argptr);
+	va_end(argptr);
+    if (dofile)
+		fprintf(fp[id], "%s\n", buffer);
+	if(logCallbackFmt[id]) {
+		msgCallbackFmt p = logCallbackFmt[id];
+		p(id, fmt, argptr );
+	}
+
+    if (pLogStatus[id] & 2) {
+		if (pLogStatus[id] & 8) {
+			fprintf(stderr, "[%04d%02d%02d %02d:%02d:%02d] [%s] ", newtime->tm_year+1900, newtime->tm_mon+1, newtime->tm_mday, newtime->tm_hour, newtime->tm_min, newtime->tm_sec, LogNames[id]);
+			fprintf(stderr, "%s\n", buffer);
+		}
+		else {
+			fprintf(stdout, "[%04d%02d%02d %02d:%02d:%02d] [%s] ", newtime->tm_year+1900, newtime->tm_mon+1, newtime->tm_mday, newtime->tm_hour, newtime->tm_min, newtime->tm_sec, LogNames[id]);
+			fprintf(stdout, "%s\n", buffer);
+		}
+	}
+    if (dofile)
+		fprintf(fp[id], "\n");
+    if (pLogStatus[id] & 2) {
+		if (pLogStatus[id] & 8)
+			fprintf(stderr, "\n");
+		else
+			fprintf(stdout, "\n");
+	}
+    if(dofile)
+      fflush(fp[id]);
+    return true;
+}
+
+bool EQEMuLog::writebuf(LogIDs id, const char *buf, int8 size, int32 count) {
+	if (!this) {
+		return false;
+    }
+	if (id >= MaxLogID) {
+		return false;
+    }
+	bool dofile = false;
+	if (pLogStatus[id] & 1) {
+		dofile = open(id);
+	}
+	if (!(dofile || pLogStatus[id] & 2))
+		return false;
+	LockMutex lock(&MLog[id]);
+
+    time_t aclock;
+    struct tm *newtime;
+    
+    time( &aclock );                 // Get time in seconds
+    newtime = localtime( &aclock );  // Convert time to struct
+
+	if (dofile){
+#ifndef NO_PIDLOG
+		fprintf(fp[id], "[%02d.%02d. - %02d:%02d:%02d] ", newtime->tm_mon+1, newtime->tm_mday, newtime->tm_hour, newtime->tm_min, newtime->tm_sec);
+#else
+		fprintf(fp[id], "%04i [%02d.%02d. - %02d:%02d:%02d] ", getpid(), newtime->tm_mon+1, newtime->tm_mday, newtime->tm_hour, newtime->tm_min, newtime->tm_sec);
+#endif
+	}
+
+	if (dofile) {
+		fwrite(buf, size, count, fp[id]);
+		fprintf(fp[id], "\n");
+	}
+	if(logCallbackBuf[id]) {
+		msgCallbackBuf p = logCallbackBuf[id];
+		p(id, buf, size, count);
+	}
+    if (pLogStatus[id] & 2) {
+		if (pLogStatus[id] & 8) {
+			fprintf(stderr, "[%s] ", LogNames[id]);
+			fwrite(buf, size, count, stderr);
+			fprintf(stderr, "\n");
+		} else {
+			fprintf(stdout, "[%s] ", LogNames[id]);
+			fwrite(buf, size, count, stdout);
+			fprintf(stdout, "\n");
+		}
+	}
+    if(dofile)
+      fflush(fp[id]);
+    return true;
+}
+
+bool EQEMuLog::writeNTS(LogIDs id, bool dofile, const char *fmt, ...) {
+	char buffer[4096];
+	va_list argptr;
+	va_start(argptr, fmt);
+	vsnprintf(buffer, sizeof(buffer), fmt, argptr);
+	va_end(argptr);
+	if (dofile)
+		fprintf(fp[id], "%s\n", buffer);
+    if (pLogStatus[id] & 2) {
+		if (pLogStatus[id] & 8)
+			fprintf(stderr, "%s\n", buffer);
+		else
+			fprintf(stdout, "%s\n", buffer);
+	}
+    return true;
+};
+
+bool EQEMuLog::Dump(LogIDs id, int8* data, int32 size, int32 cols, int32 skip) {
+	if (!this) {
+#if EQDEBUG >= 10
+    cerr << "Error: Dump() from null pointer"<<endl;
+#endif
+		return false;
+    }
+	if (size == 0)
+		return true;
+	if (!LogFile)
+		return false;
+	if (id >= MaxLogID)
+		return false;
+	bool dofile = false;
+	if (pLogStatus[id] & 1) {
+		dofile = open(id);
+	}
+	if (!(dofile || pLogStatus[id] & 2))
+		return false;
+	LockMutex lock(&MLog[id]);
+	write(id, "Dumping Packet: %i", size);
+	// Output as HEX
+	int j = 0; char* ascii = new char[cols+1]; memset(ascii, 0, cols+1);
+	int32 i;
+    for(i=skip; i<size; i++) {
+		if ((i-skip)%cols==0) {
+			if (i != skip)
+				writeNTS(id, dofile, " | %s\n", ascii);
+			writeNTS(id, dofile, "%4i: ", i-skip);
+			memset(ascii, 0, cols+1);
+			j = 0;
+		}
+		else if ((i-skip)%(cols/2) == 0) {
+			writeNTS(id, dofile, "- ");
+		}
+		writeNTS(id, dofile, "%02X ", (unsigned char)data[i]);
+
+		if (data[i] >= 32 && data[i] < 127)
+			ascii[j++] = data[i];
+		else
+			ascii[j++] = '.';
+    }
+	int32 k = ((i-skip)-1)%cols;
+	if (k < 8)
+		writeNTS(id, dofile, "  ");
+	for (int32 h = k+1; h < cols; h++) {
+		writeNTS(id, dofile, "   ");
+	}
+	writeNTS(id, dofile, " | %s\n", ascii);
+	if (dofile)
+		fflush(fp[id]);
+	safe_delete_array(ascii);
+	return true;
+}
+	
+void EQEMuLog::SetCallback(LogIDs id, msgCallbackFmt proc) {
+	if (!this)
+		return;
+	if (id >= MaxLogID) {
+		return;
+    }
+    logCallbackFmt[id] = proc;
+}
+
+void EQEMuLog::SetCallback(LogIDs id, msgCallbackBuf proc) {
+	if (!this)
+		return;
+	if (id >= MaxLogID) {
+		return;
+    }
+    logCallbackBuf[id] = proc;
+}
+
+void EQEMuLog::SetAllCallbacks(msgCallbackFmt proc) {
+	if (!this)
+		return;
+	int r;
+	for(r = Status; r < MaxLogID; r++) {
+		SetCallback((LogIDs)r, proc);
+	}
+}
+
+void EQEMuLog::SetAllCallbacks(msgCallbackBuf proc) {
+	if (!this)
+		return;
+	int r;
+	for(r = Status; r < MaxLogID; r++) {
+		SetCallback((LogIDs)r, proc);
+	}
+}
+*/

source/common/debug.h

@@ -1,13 +1,7 @@
 // Copyright (C) 2007-2025 EQ2EMulator
 // Licensed under GPL v3
-
+#ifndef EQDEBUG_H
-#pragma once
+#define EQDEBUG_H
-
-#include <cstdio>
-#include <cstdarg>
-#include <cstdint>
-#include <iostream>
-#include <mutex>
 
 // Debug Levels
 /*
@@ -22,33 +16,55 @@
 	#define EQDEBUG 1
 #endif
 
+
+#if defined(DEBUG) && defined(WIN32)
+	//#ifndef _CRTDBG_MAP_ALLOC
+		#include <stdlib.h>
+		#include <crtdbg.h>
+		#if (_MSC_VER < 1300)
+			#include <new>
+			#include <memory>
+			#define _CRTDBG_MAP_ALLOC
+			#define new new(_NORMAL_BLOCK, __FILE__, __LINE__)
+			#define malloc(s) _malloc_dbg(s, _NORMAL_BLOCK, __FILE__, __LINE__)
+		#endif
+	//#endif
+#endif
+
 #ifndef ThrowError
 	void CatchSignal(int);
 	#if defined(CATCH_CRASH) || defined(_EQDEBUG)
-		#define ThrowError(errstr) { \
+		#define ThrowError(errstr)	{ cout << "Fatal error: " << errstr << " (" << __FILE__ << ", line " << __LINE__ << ")" << endl; LogWrite(WORLD__ERROR, 0, "Debug", "Thrown Error: %s (%s:%i)", errstr, __FILE__, __LINE__); throw errstr; }
-			std::cout << "Fatal error: " << errstr << " (" << __FILE__ << ", line " << __LINE__ << ")" << std::endl; \
-			LogWrite(WORLD__ERROR, 0, "Debug", "Thrown Error: %s (%s:%i)", errstr, __FILE__, __LINE__); \
-			throw errstr; \
-		}
 	#else
-		#define ThrowError(errstr) { \
+		#define ThrowError(errstr)	{ cout << "Fatal error: " << errstr << " (" << __FILE__ << ", line " << __LINE__ << ")" << endl; LogWrite(WORLD__ERROR, 0, "Debug", "Thrown Error: %s (%s:%i)", errstr, __FILE__, __LINE__); CatchSignal(0); }
-			std::cout << "Fatal error: " << errstr << " (" << __FILE__ << ", line " << __LINE__ << ")" << std::endl; \
-			LogWrite(WORLD__ERROR, 0, "Debug", "Thrown Error: %s (%s:%i)", errstr, __FILE__, __LINE__); \
-			CatchSignal(0); \
-		}
 	#endif
 #endif
 
-#define DebugBreak() if(0) {}
+#ifdef WIN32
+	// VS6 doesn't like the length of STL generated names: disabling
+	#pragma warning(disable:4786)
+#endif
 
-class EQEMuLog
+#ifndef WIN32
-{
+	#define DebugBreak()			if(0) {}
+#endif
+
+#ifdef WIN32
+	#include <WinSock2.h>
+	#include <windows.h>
+#endif
+
+#include "../common/Mutex.h"
+#include <stdio.h>
+#include <stdarg.h>
+
+
+class EQEMuLog {
 public:
 	EQEMuLog();
 	~EQEMuLog();
 
-	enum LogIDs
+	enum LogIDs {
-	{
 		Status = 0,	//this must stay the first entry in this list
 		Normal,
 		Error,
@@ -58,57 +74,53 @@ public:
 		MaxLogID
 	};
 	
-	// Callbacks called for each log entry
+	//these are callbacks called for each
-	using msgCallbackBuf = void (*)(LogIDs id, const char* buf, std::int8_t size, std::int32_t count);
+	typedef void (* msgCallbackBuf)(LogIDs id, const char *buf, int8 size, int32 count);
-	using msgCallbackFmt = void (*)(LogIDs id, const char* fmt, va_list ap);
+	typedef void (* msgCallbackFmt)(LogIDs id, const char *fmt, va_list ap);
 	
 	void SetAllCallbacks(msgCallbackFmt proc);
 	void SetAllCallbacks(msgCallbackBuf proc);
 	void SetCallback(LogIDs id, msgCallbackFmt proc);
 	void SetCallback(LogIDs id, msgCallbackBuf proc);
 	
-	bool writebuf(LogIDs id, const char* buf, std::int8_t size, std::int32_t count);
+	bool writebuf(LogIDs id, const char *buf, int8 size, int32 count);
-	bool write(LogIDs id, const char* fmt, ...);
+	bool write(LogIDs id, const char *fmt, ...);
-	bool Dump(LogIDs id, std::uint8_t* data, std::int32_t size, std::int32_t cols = 16, std::int32_t skip = 0);
+	bool Dump(LogIDs id, int8* data, int32 size, int32 cols=16, int32 skip=0);
-
 private:
 	bool open(LogIDs id);
-	bool writeNTS(LogIDs id, bool dofile, const char* fmt, ...); // no error checking, assumes is open, no locking, no timestamp, no newline
+	bool writeNTS(LogIDs id, bool dofile, const char *fmt, ...); // no error checking, assumes is open, no locking, no timestamp, no newline
 
-	std::mutex MOpen;
+	Mutex	MOpen;
-	std::mutex MLog[MaxLogID];
+	Mutex	MLog[MaxLogID];
 	FILE*	fp[MaxLogID];
-
+/* LogStatus: bitwise variable
-	/* LogStatus: bitwise variable
 	1 = output to file
 	2 = output to stdout
 	4 = fopen error, dont retry
 	8 = use stderr instead (2 must be set)
-	*/
+*/
-	std::int8_t pLogStatus[MaxLogID];
+	int8	pLogStatus[MaxLogID];
 	
 	msgCallbackFmt logCallbackFmt[MaxLogID];
 	msgCallbackBuf logCallbackBuf[MaxLogID];
 };
 
+//extern EQEMuLog* LogFile;
+
 #ifdef _EQDEBUG
-class PerformanceMonitor
+class PerformanceMonitor {
-{
 public:
-	PerformanceMonitor(std::int64_t* ip)
+	PerformanceMonitor(sint64* ip) {
-	{
 		p = ip;
 		QueryPerformanceCounter(&tmp);
 	}
-
+	~PerformanceMonitor() {
-	~PerformanceMonitor()
-	{
 		LARGE_INTEGER tmp2;
 		QueryPerformanceCounter(&tmp2);
 		*p += tmp2.QuadPart - tmp.QuadPart;
 	}
-
 	LARGE_INTEGER tmp;
-	std::int64_t* p;
+	sint64* p;
 };
 #endif
+#endif

source/common/defines.h

@@ -1,16 +0,0 @@
-// Copyright (C) 2007-2025 EQ2EMulator
-// Licensed under GPL v3
-
-#define BASEDIR "./"
-
-#ifndef DB_INI_FILE
-	#ifdef LOGIN
-		#define DB_INI_FILE	BASEDIR "login_db.ini"
-	#else
-		#define DB_INI_FILE BASEDIR "world_db.ini"
-	#endif
-#endif
-
-#ifndef MAIN_CONFIG_FILE
-	#define MAIN_CONFIG_FILE BASEDIR "server_config.json"
-#endif

source/common/mutex.cpp

@@ -1,238 +0,0 @@
-// Copyright (C) 2007-2025 EQ2EMulator
-// Licensed under GPL v3
-
-#include "mutex.h"
-
-// CriticalSection implementation
-CriticalSection::CriticalSection(int attribute) : mutex_type(attribute)
-{
-	if (mutex_type == MUTEX_ATTRIBUTE_RECURSIVE) {
-		recursive_mutex = std::make_unique<std::recursive_mutex>();
-	} else {
-		regular_mutex = std::make_unique<std::mutex>();
-	}
-}
-
-void CriticalSection::lock()
-{
-	if (recursive_mutex) {
-		recursive_mutex->lock();
-	} else {
-		regular_mutex->lock();
-	}
-}
-
-void CriticalSection::unlock()
-{
-	if (recursive_mutex) {
-		recursive_mutex->unlock();
-	} else {
-		regular_mutex->unlock();
-	}
-}
-
-bool CriticalSection::trylock()
-{
-	if (recursive_mutex) {
-		return recursive_mutex->try_lock();
-	} else {
-		return regular_mutex->try_lock();
-	}
-}
-
-// Mutex implementation
-Mutex::Mutex() : name("")
-{
-#ifdef DEBUG
-	stack.clear();
-#endif
-}
-
-void Mutex::SetName(std::string in_name)
-{
-	name = in_name;
-}
-
-void Mutex::lock()
-{
-#ifdef DEBUG
-	if (!name.empty()) {
-		auto start = std::chrono::steady_clock::now();
-		while (!basic_mutex.try_lock()) {
-			auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
-			    std::chrono::steady_clock::now() - start).count();
-			if (elapsed > MUTEX_TIMEOUT_MILLISECONDS) {
-				LogWrite(MUTEX__ERROR, 0, "Mutex", "Possible deadlock attempt by '%s'!", name.c_str());
-				return;
-			}
-			std::this_thread::sleep_for(std::chrono::milliseconds(1));
-		}
-	} else {
-		basic_mutex.lock();
-	}
-#else
-	basic_mutex.lock();
-#endif
-}
-
-bool Mutex::trylock()
-{
-	return basic_mutex.try_lock();
-}
-
-void Mutex::unlock()
-{
-	basic_mutex.unlock();
-}
-
-void Mutex::readlock([[maybe_unused]] const char* function, [[maybe_unused]] std::int32_t line)
-{
-#ifdef DEBUG
-	auto start = std::chrono::steady_clock::now();
-	while (!rw_mutex.try_lock_shared()) {
-		auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
-		    std::chrono::steady_clock::now() - start).count();
-		if (elapsed > MUTEX_TIMEOUT_MILLISECONDS) {
-			logDeadlock(function, line, "readlock");
-			start = std::chrono::steady_clock::now(); // Reset timer and continue
-		}
-		std::this_thread::sleep_for(std::chrono::milliseconds(1));
-	}
-	addDebugLock(function);
-#else
-	rw_mutex.lock_shared();
-#endif
-}
-
-void Mutex::releasereadlock([[maybe_unused]] const char* function, [[maybe_unused]] std::int32_t line)
-{
-	rw_mutex.unlock_shared();
-#ifdef DEBUG
-	removeDebugLock(function);
-#endif
-}
-
-bool Mutex::tryreadlock([[maybe_unused]] const char* function)
-{
-	bool result = rw_mutex.try_lock_shared();
-#ifdef DEBUG
-	if (result && function) {
-		addDebugLock(function);
-	}
-#endif
-	return result;
-}
-
-void Mutex::writelock([[maybe_unused]] const char* function, [[maybe_unused]] std::int32_t line)
-{
-#ifdef DEBUG
-	auto start = std::chrono::steady_clock::now();
-	while (!rw_mutex.try_lock()) {
-		auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
-		    std::chrono::steady_clock::now() - start).count();
-		if (elapsed > MUTEX_TIMEOUT_MILLISECONDS) {
-			logDeadlock(function, line, "writelock");
-			start = std::chrono::steady_clock::now(); // Reset timer and continue
-		}
-		std::this_thread::sleep_for(std::chrono::milliseconds(1));
-	}
-	addDebugLock(function);
-#else
-	rw_mutex.lock();
-#endif
-}
-
-void Mutex::releasewritelock([[maybe_unused]] const char* function, [[maybe_unused]] std::int32_t line)
-{
-	rw_mutex.unlock();
-#ifdef DEBUG
-	removeDebugLock(function);
-#endif
-}
-
-bool Mutex::trywritelock([[maybe_unused]] const char* function)
-{
-	bool result = rw_mutex.try_lock();
-#ifdef DEBUG
-	if (result && function) {
-		addDebugLock(function);
-	}
-#endif
-	return result;
-}
-
-void Mutex::waitReaders(const char* function, std::int32_t line)
-{
-	// Wait until we can get a write lock (which means no readers)
-	writelock(function, line);
-	releasewritelock(function, line);
-}
-
-#ifdef DEBUG
-void Mutex::addDebugLock(const char* function)
-{
-	if (function) {
-		std::lock_guard<std::mutex> guard(debug_mutex);
-		stack[std::string(function)]++;
-	}
-}
-
-void Mutex::removeDebugLock(const char* function)
-{
-	if (function) {
-		std::lock_guard<std::mutex> guard(debug_mutex);
-		auto itr = stack.find(std::string(function));
-		if (itr != stack.end()) {
-			if (--(itr->second) == 0) {
-				stack.erase(itr);
-			}
-		}
-	}
-}
-
-void Mutex::logDeadlock(const char* function, std::int32_t line, const char* lock_type)
-{
-	LogWrite(MUTEX__ERROR, 0, "Mutex", "The mutex %s called from %s at line %u timed out waiting for a %s!",
-	         name.c_str(), function ? function : "name_not_provided", line, lock_type);
-	LogWrite(MUTEX__ERROR, 0, "Mutex", "The following functions had locks:");
-
-	std::lock_guard<std::mutex> guard(debug_mutex);
-	for (const auto& [func_name, count] : stack) {
-		if (count > 0 && !func_name.empty()) {
-			LogWrite(MUTEX__ERROR, 0, "Mutex", "%s, number of locks = %u", func_name.c_str(), count);
-		}
-	}
-}
-#endif
-
-// LockMutex implementation
-LockMutex::LockMutex(Mutex* in_mut, bool iLock)
-    : locked(false), mut(in_mut)
-{
-	if (mut && iLock) {
-		lock();
-	}
-}
-
-LockMutex::~LockMutex()
-{
-	if (locked) {
-		unlock();
-	}
-}
-
-void LockMutex::lock()
-{
-	if (mut && !locked) {
-		mut->lock();
-		locked = true;
-	}
-}
-
-void LockMutex::unlock()
-{
-	if (mut && locked) {
-		mut->unlock();
-		locked = false;
-	}
-}

source/common/mutex.h

@@ -1,83 +0,0 @@
-// Copyright (C) 2007-2025 EQ2EMulator
-// Licensed under GPL v3
-
-#pragma once
-
-#include <shared_mutex>
-#include <mutex>
-#include <string>
-#include <map>
-#include <cstdint>
-#include <memory>
-#include <chrono>
-
-#define MUTEX_ATTRIBUTE_FAST      1
-#define MUTEX_ATTRIBUTE_RECURSIVE 2
-#define MUTEX_ATTRIBUTE_ERRORCHK  3
-#define MUTEX_TIMEOUT_MILLISECONDS 10000
-
-class CriticalSection
-{
-public:
-	CriticalSection(int attribute = MUTEX_ATTRIBUTE_FAST);
-	~CriticalSection() = default;
-
-	void lock();
-	void unlock();
-	bool trylock();
-
-private:
-	std::unique_ptr<std::mutex> regular_mutex;
-	std::unique_ptr<std::recursive_mutex> recursive_mutex;
-	int mutex_type;
-};
-
-class Mutex
-{
-public:
-	Mutex();
-	~Mutex() = default;
-
-	void lock();
-	void unlock();
-	bool trylock();
-
-	void readlock(const char* function = nullptr, std::int32_t line = 0);
-	void releasereadlock(const char* function = nullptr, std::int32_t line = 0);
-	bool tryreadlock(const char* function = nullptr);
-
-	void writelock(const char* function = nullptr, std::int32_t line = 0);
-	void releasewritelock(const char* function = nullptr, std::int32_t line = 0);
-	bool trywritelock(const char* function = nullptr);
-
-	void waitReaders(const char* function = nullptr, std::int32_t line = 0);
-
-	void SetName(std::string in_name);
-
-private:
-	std::shared_mutex rw_mutex;
-	std::mutex basic_mutex;
-	std::string name;
-
-#ifdef DEBUG
-	std::mutex debug_mutex;
-	std::map<std::string, std::int32_t> stack;
-	void addDebugLock(const char* function);
-	void removeDebugLock(const char* function);
-	void logDeadlock(const char* function, std::int32_t line, const char* lock_type);
-#endif
-};
-
-class LockMutex
-{
-public:
-	LockMutex(Mutex* in_mut, bool iLock = true);
-	~LockMutex();
-
-	void unlock();
-	void lock();
-
-private:
-	bool locked;
-	Mutex* mut;
-};

source/common/opcodemgr.h

@@ -4,7 +4,7 @@
 #define OPCODE_MANAGER_H
 
 #include "types.h"
-#include "mutex.h"
+#include "Mutex.h"
 #include "emu_opcodes.h"
 
 #include <map>
@@ -141,3 +141,5 @@ protected:
 };
 
 #endif
+
+