Some of these really slow down profiling without adding much (short functions)

numhits issue fix

.travis.yml

@@ -0,0 +1,18 @@
+language: cpp
+compiler: gcc
+before_install:
+  - sudo apt-get update -qq
+  - sudo apt-get install -y libmysqlclient-dev libperl-dev libboost-dev liblua5.1-0-dev zlib1g-dev
+script:
+  - cmake -G "Unix Makefiles" -DEQEMU_BUILD_TESTS=ON -DEQEMU_ENABLE_BOTS=ON
+  - make
+  - ./bin/tests
+branches:
+  only:
+    - master
+    - stable
+notifications:
+  email: false
+  irc:
+    channels: "irc.eqemulator.net#eqemucoders"
+os: linux

CMakeLists.txt

@@ -1,4 +1,37 @@
-#EQEmu Cmake
+#EQEmu CMake
+#Variables used:
+#EQEMU_DISABLE_CRT_SECURE_WARNINGS
+#EQEMU_FAST_FLOATINGPOINT
+#EQEMU_ENABLE_CRASH_LOGGING
+#EQEMU_DISABLE_SAFESEH
+#EQEMU_BUILD_MSVC_MP
+#EQEMU_DEBUG_LEVEL
+#EQEMU_LOG_LEVEL_STATUS
+#EQEMU_LOG_LEVEL_NORMAL
+#EQEMU_LOG_LEVEL_ERROR
+#EQEMU_LOG_LEVEL_DEBUG
+#EQEMU_LOG_LEVEL_QUEST
+#EQEMU_LOG_LEVEL_COMMANDS
+#EQEMU_LOG_LEVEL_CRASH
+#EQEMU_STREAM_SEND_RATE
+#EQEMU_STREAM_DECAY_RATE
+#EQEMU_STREAM_RETRANSMIT_TIMEOUT_MUL
+#EQEMU_STREAM_RETRANSMIT_TIMEOUT_MAX
+#EQEMU_STREAM_AVERAGE_DELTA_MAX
+#EQEMU_STREAM_RETRANSMIT_ACKED_PACKETS
+#EQEMU_DEPOP_INVALIDATES_CACHE
+#EQEMU_ENABLE_BOTS
+#EQEMU_DISABLE_LOGSYS
+#EQEMU_COMMANDS_LOGGING
+#EQEMU_BUILD_SERVER
+#EQEMU_BUILD_LOGIN
+#EQEMU_BUILD_TESTS
+#EQEMU_BUILD_PERL
+#EQEMU_BUILD_LUA
+#EQEMU_SANITIZE_LUA_LIBS
+#EQEMU_BUILD_CLIENT_FILES
+#EQEMU_MAP_DIR
+#EQEMU_ENABLE_PROFILING
 
 #We set a fairly new version (as of 2013) because I found finding perl was a bit... buggy on older ones
 #Can change this if you really want but you should upgrade!
@@ -7,9 +40,6 @@ CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
 #FindMySQL is located here so lets make it so CMake can find it
 SET(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/" ${CMAKE_MODULE_PATH})
 
-#For checking includes
-INCLUDE (CheckIncludeFiles)
-
 #Our project name is EQEmu
 PROJECT(EQEmu)
 
@@ -74,8 +104,8 @@ IF(MSVC)
 		SET(CMAKE_MODULE_LINKER_FLAGS_RELEASE "${CMAKE_MODULE_LINKER_FLAGS_RELEASE} /SAFESEH:NO")
 		SET(CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO "${CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO} /SAFESEH:NO")
 	ENDIF(EQEMU_DISABLE_SAFESEH)
-	
-	OPTION(EQEMU_BUILD_MSVC_MP "Enable build with multiple processes." TRUE)
+
+	OPTION(EQEMU_BUILD_MSVC_MP "Enable build with multiple processes." ON)
 	IF(EQEMU_BUILD_MSVC_MP)
 		SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MP")
 	ENDIF(EQEMU_BUILD_MSVC_MP)
@@ -86,7 +116,7 @@ IF(MSVC)
 			STRING(REGEX REPLACE "/MD" "/MT" ${flag_var} "${${flag_var}}")
 		ENDIF(${flag_var} MATCHES "/MD")
 	ENDFOREACH(flag_var)
-	
+
 	ADD_DEFINITIONS(-DNOMINMAX)
 ELSE(MSVC)
 	#Normally set by perl but we don't use the perl flags anymore so we set it.
@@ -97,6 +127,7 @@ ENDIF(MSVC)
 IF(UNIX)
 	IF(CMAKE_SYSTEM_NAME MATCHES "FreeBSD")
 		ADD_DEFINITIONS(-DFREEBSD)
+		ADD_DEFINITIONS(-D_GLIBCXX_USE_C99)
 		SET(FREEBSD TRUE)
 	ENDIF(CMAKE_SYSTEM_NAME MATCHES "FreeBSD")
 	IF(CMAKE_SYSTEM_NAME MATCHES "Darwin")
@@ -105,12 +136,6 @@ IF(UNIX)
 	ENDIF(CMAKE_SYSTEM_NAME MATCHES "Darwin")
 ENDIF(UNIX)
 
-#use stdint.h types if they exist for this platform (we have to guess otherwise)
-CHECK_INCLUDE_FILES(stdint.h HAVE_STDINT_H)
-IF(HAVE_STDINT_H)
-	ADD_DEFINITIONS(-DEQEMU_USE_STDINT)
-ENDIF(HAVE_STDINT_H)
-
 #debug level, 5 is default. Most people wont ever change this but it's there if you want to
 SET(EQEMU_DEBUG_LEVEL 5 CACHE STRING "EQEmu debug level:
 	0 - Quiet mode Errors to file Status and Normal ignored
@@ -229,15 +254,18 @@ ENDIF(EQEMU_ENABLE_BOTS)
 #What to build
 OPTION(EQEMU_BUILD_SERVER "Build the game server." ON)
 OPTION(EQEMU_BUILD_LOGIN "Build the login server." OFF)
-OPTION(EQEMU_BUILD_AZONE "Build azone utility." OFF)
 OPTION(EQEMU_BUILD_TESTS "Build utility tests." OFF)
 OPTION(EQEMU_BUILD_PERL "Build Perl parser." ON)
-OPTION(EQEMU_BUILD_LUA "Build Lua parser." OFF)
-OPTION(EQEMU_BUILD_CLIENT_FILES "Build Client Inport/Export Data Programs." ON)
+OPTION(EQEMU_BUILD_LUA "Build Lua parser." ON)
+OPTION(EQEMU_BUILD_CLIENT_FILES "Build Client Import/Export Data Programs." ON)
+OPTION(EQEMU_ENABLE_PROFILING "Enable CPU profiler. Note: will slow down execution time." OFF)
 
 #C++11 stuff
 IF(NOT MSVC)
-	ADD_DEFINITIONS(-std=c++0x)
+	SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x")
+	IF("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+		SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-reserved-user-defined-literal")
+	ENDIF()
 ENDIF(NOT MSVC)
 
 #Various definitions
@@ -267,6 +295,7 @@ ADD_DEFINITIONS(-DLOG_LEVEL_DEBUG=${EQEMU_LOG_LEVEL_DEBUG})
 ADD_DEFINITIONS(-DLOG_LEVEL_QUEST=${EQEMU_LOG_LEVEL_QUEST})
 ADD_DEFINITIONS(-DLOG_LEVEL_COMMANDS=${EQEMU_LOG_LEVEL_COMMANDS})
 ADD_DEFINITIONS(-DLOG_LEVEL_CRASH=${EQEMU_LOG_LEVEL_CRASH})
+ADD_DEFINITIONS(-DGLM_FORCE_RADIANS)
 
 IF(EQEMU_STREAM_RETRANSMIT_ACKED_PACKETS)
 	ADD_DEFINITIONS(-DRETRANSMIT_ACKED_PACKETS=true)
@@ -279,31 +308,41 @@ FIND_PACKAGE(ZLIB REQUIRED)
 FIND_PACKAGE(MySQL REQUIRED)
 IF(EQEMU_BUILD_PERL)
 	FIND_PACKAGE(PerlLibs REQUIRED)
-	INCLUDE_DIRECTORIES("${PERL_INCLUDE_PATH}")
+	INCLUDE_DIRECTORIES(SYSTEM "${PERL_INCLUDE_PATH}")
 ENDIF(EQEMU_BUILD_PERL)
 
 IF(EQEMU_BUILD_LUA)
 	FIND_PACKAGE(EQLua51 REQUIRED)
 	SET(Boost_USE_STATIC_LIBS OFF)
-	SET(Boost_USE_MULTITHREADED ON) 
+	SET(Boost_USE_MULTITHREADED ON)
 	SET(Boost_USE_STATIC_RUNTIME OFF)
 	SET(BOOST_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/boost")
 
 	FIND_PACKAGE(Boost REQUIRED)
-	INCLUDE_DIRECTORIES("${LUA_INCLUDE_DIR}" "${Boost_INCLUDE_DIRS}" "luabind")
-	
+	INCLUDE_DIRECTORIES(SYSTEM "${LUA_INCLUDE_DIR}" "${Boost_INCLUDE_DIRS}" "luabind")
+
 	OPTION(EQEMU_SANITIZE_LUA_LIBS "Sanitize Lua Libraries (Remove OS and IO standard libraries from being able to run)." ON)
 	IF(EQEMU_SANITIZE_LUA_LIBS)
 		ADD_DEFINITIONS(-DSANITIZE_LUA_LIBS)
 	ENDIF(EQEMU_SANITIZE_LUA_LIBS)
 ENDIF(EQEMU_BUILD_LUA)
 
-INCLUDE_DIRECTORIES("${ZLIB_INCLUDE_DIRS}" "${MySQL_INCLUDE_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}/common/glm/glm")
+INCLUDE_DIRECTORIES(SYSTEM "${ZLIB_INCLUDE_DIRS}" "${MySQL_INCLUDE_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}/common/glm")
 
 IF(EQEMU_BUILD_LUA)
     ADD_SUBDIRECTORY(luabind)
 ENDIF(EQEMU_BUILD_LUA)
 
+IF(EQEMU_ENABLE_PROFILING)
+	ADD_DEFINITIONS(-DEQPERF_ENABLED)
+	ADD_DEFINITIONS(-DEQP_MULTITHREAD)
+	INCLUDE_DIRECTORIES("eqperf")
+	ADD_SUBDIRECTORY(eqperf)
+	SET(PERF_LIBS eqperf)
+ELSE(EQEMU_ENABLE_PROFILING)
+	SET(PERF_LIBS "")
+ENDIF(EQEMU_ENABLE_PROFILING)
+
 IF(EQEMU_BUILD_SERVER OR EQEMU_BUILD_LOGIN OR EQEMU_BUILD_TESTS)
 	ADD_SUBDIRECTORY(common)
 ENDIF(EQEMU_BUILD_SERVER OR EQEMU_BUILD_LOGIN OR EQEMU_BUILD_TESTS)
@@ -319,10 +358,6 @@ IF(EQEMU_BUILD_LOGIN)
 	ADD_SUBDIRECTORY(loginserver)
 ENDIF(EQEMU_BUILD_LOGIN)
 
-IF(EQEMU_BUILD_AZONE)
-	ADD_SUBDIRECTORY(utils)
-ENDIF(EQEMU_BUILD_AZONE)
-
 IF(EQEMU_BUILD_TESTS)
 	ADD_SUBDIRECTORY(tests)
 ENDIF(EQEMU_BUILD_TESTS)

README.md

@@ -1,5 +1,53 @@
-EQEmu - Custom Game Implementation for EverQuest
+EQEmu
+===
 
-Dependencies can be obtained at http://eqemu.github.io
+[![Build Status](https://travis-ci.org/EQEmu/Server.svg?branch=master)](https://travis-ci.org/EQEmu/Server)
+
+Overview
+---
+
+EQEmu is a custom server implementation for EverQuest
+
+Dependencies
+---
+
+For Windows: http://eqemu.github.io
+
+Login Server dependencies for Windows/Linux/OSX: http://eqemu.github.io
+
+For Debian based distros (adjust to your local flavor):
+
+- libmysqlclient-dev
+- libperl-dev
+- liblua5.1-0-dev (5.2 should work as well)
+- libboost-dev
+
+Further instructions on building the source can be found on the
+[wiki](http://wiki.eqemulator.org/i?M=Wiki).
+
+Bug reports
+---
+
+Please use the [issue tracker](https://github.com/EQEmu/Server/issues) provided by GitHub to send us bug
+reports or feature requests.
+
+The [EQEmu Forums](http://www.eqemulator.org/forums/) also have forums to submit
+bugs/get help with bugs.
+
+Contributions
+---
+
+The preferred way to contribute is to fork the repo and submit a pull request on
+GitHub. If you need help with your changes, you can always post on the forums or
+try IRC. You can also post unified diffs (`git diff` should do the trick) on the
+[Server Code Submissions](http://www.eqemulator.org/forums/forumdisplay.php?f=669)
+forum, although pull requests will be much quicker and easier on all parties.
+
+Contact
+---
+ - **User IRC Channel**: `#eqemu` on `irc.eqemulator.net`
+ - **Developer IRC Channel**: `#eqemucoders` on `irc.eqemulator.net`
+
+- [EQEmulator Forums](http://www.eqemulator.org/forums)
+- [EQEmulator Wiki](http://wiki.eqemulator.org/i?M=Wiki)
 
-More Information: https://github.com/EQEmu/Server/wiki

changelog.txt

@@ -1,5 +1,940 @@
 EQEMu Changelog (Started on Sept 24, 2003 15:50)
 -------------------------------------------------------
+== 02/09/2015 ==
+Trevius: (RoF+) Setting Alt flag on characters in the Guild Management Window is now saved and functional for filtering.
+Trevius: (RoF+) Guild Invites between RoF+ and previous Clients is now functional.
+
+== 02/08/2015 ==
+Kayen: Implemented npc specialability (44) COUNTER_AVOID_DAMAGE which when applied to the ATTACKING NPC will make their attacks more difficult to be avoided by riposte/dodge/parry/block.
+Parama0: Negative modifer value that affects ALL avoid damage types dodge/parry/riposte/block) chance on defender. Ie (44,50 = 50 pct reduction to ALL)
+Parama1: Negative modifer value that affects RIPOSTE chance on defender. Ie (44,1,0,50 = 50 pct reduction to riposte chance)
+Parama2: Negative modifer value that affects PARRY chance on defender.  Ie (44,1,0,0,50 = 50 pct reduction to parry chance)
+Parama3: Negative modifer value that affects BLOCK chance on defender.  Ie (44,1,0,0,0,50 = 50 pct reduction to block chance)
+Parama4: Negative modifer value that affects DODGE chance on defender.  e (44,1,0,0,0,0,50 = 50 pct reduction to dodge chance)
+Example of usage: Player has Improved Dodge V (+50 pct dodge chance), you want to negate this bonus you would set 44,1,0,0,0,0,50 on your NPC.
+
+== 02/07/2015 ==
+Akkadius: Reduced #repop time dramatically by taking down hundreds of individual SELECT/DELETE/INSERT queries in routines and bringing it down to very few
+	See: https://www.youtube.com/watch?v=9kSFbyTBuAk
+
+== 02/06/2015 ==
+Uleat: Updated returns for Inventory and ItemInst const iterators. (const == const)
+Uleat: Replaced 'iter_inst' and 'iter_contents' typedefs with their stl definitions
+Uleat: Removed 'limbo' from the 'HasItem' series of checks - including lore checks. The client excludes this range and it causes issues when performing item searches - dupe lore checks were added to account for this.
+Uleat: Updated command #iteminfo to show light source information and a few other things
+
+== 02/05/2015 ==
+Trevius: Fixed Environmental Damage for RoF2. 
+
+== 02/03/2015 ==
+Trevius: Crashfix for TempName() when numbers are passed at the end of the name.
+Uleat: Tweaking of item type exclusions to alleviate strobing conditions with light sources
+
+== 02/02/2015 ==
+Akkadius: Implement Packet logs with dumps
+	- Category: 41: Packet: Server -> Client With Dump
+	- Category: 42: Packet: Server -> Client With Dump
+	See: http://wiki.eqemulator.org/p?Logging_System_Overhaul#packet-logging-levels
+
+== 02/01/2015 ==
+demonstar55: Add quest debugging to lua
+	eq.debug("Test debug level implicit 1")
+	eq.debug("Test debug level explicit 1", 1)
+	eq.debug("Test debug level explicit 2", 2)
+	eq.debug("Test debug level explicit 3", 3)
+Akkadius: Add Packet Logging Categories
+	- 5 - Packet: Client -> Server - Logs::Client_Server_Packet
+	- 39 - Packet: Server -> Client - Logs::Server_Client_Packet
+	- 40 - Packet: Client -> Server Unhandled - Logs::Client_Server_Packet_Unhandled
+	See: http://wiki.eqemulator.org/p?Logging_System_Overhaul#packet-logging
+	
+== 01/31/2015 ==
+Trevius: Fixed FindGroundZ() and GetGroundZ() to once again utilize the X and Y arguments that are passed to them.
+
+== 01/30/2015 ==
+Akkadius: Implemented event type "EVENT_ENVIRONMENTAL_DAMAGE"
+	- This event triggers when taking any sort of environmental damage. Example use: 
+	sub EVENT_ENVIRONMENTAL_DAMAGE{
+		quest::debug("EVENT_ENVIRONMENTAL_DAMAGE");
+		quest::debug("env_damage is " . $env_damage);
+		quest::debug("env_damage_type is " . $env_damage_type);
+		quest::debug("env_final_damage is " . $env_final_damage);
+	} 
+	Result: (Test falling in Velks): http://i.imgur.com/tPRL7yL.png
+	- Implemented LUA counterpart of this same implementation above
+Akkadius (Bobaski): Add PoK New Merchant sql/git/optional/2015_01_30_poknowledge_spell_vendors.sql
+
+== 01/29/2015 ==
+Trevius: Added more information to Mercenary Logging.
+Trevius: Added potential fix for Mercenaries that fail to unsuspend.
+Trevius: Added a new "statscale" field to the merc_stats table that can be used to quickly balance Mercenary Stats based on Level.
+Trevius: The new "statscale" field now combines with the Mercs::ScaleRate rule value (default 100 percent for both).
+
+== 01/28/2015 ==
+Akkadius: Added Logs::DebugQuest category per request from Trevius (Great idea)
+	- Exported quest::debug(log_message, [debug_level = 1)
+	- Example:
+		quest::debug("This is a test debug message, level 1 (default)");
+		quest::debug("This is a test debug message, level 1", 1);
+		quest::debug("This is a test debug message, level 2", 2);
+		quest::debug("This is a test debug message, level 3", 3);
+		
+		Result: http://i.imgur.com/6VoafGE.png
+	- Uses traditional logging system to output this category
+	- Required MySQL Source in Database version 9070
+
+== 01/27/2015 ==
+Trevius: Removed "Mercenary Debug:" from the Mercenary Log entries.
+Trevius: Resolved duplicate "You have no Mercenaries" messages when zoning without owning a Mercenary.
+Trevius: Mercenaries should now always be able to unsuspend if the timer is up.
+Trevius: More work on Mercenaries and Grouping to reduce bugs and redundant queries.
+Uleat: Finished ClientVersion update to include patch file and namespace updates - don't forget to copy the renamed 'patch_UF.conf' into your eqemu directory.)
+
+== 01/26/2015 ==
+Uleat: Changed Corpse::MoveItemToCorpse() to allow 'by address' passing of removed item slot list. Fixed a bug that kept soul-bound items inside of bags from attuning properly
+
+== 01/25/2015 ==
+Trevius: Fixed an issue where Mercenaries were causing several DB queries per second while suspended.
+Trevius: Added Logs::Mercenaries to the new Logging System.  Logging of Mercenary information is off by default with the required SQL.
+
+== 01/24/2015 ==
+Uleat: Added equipment light source functionality to all mob derived classes (may still need tweaking...)
+Notes:
+	- In addition to equipment light sources, innate npc_type light sources have already been activated
+	- Valid light source values are 0 thru 15 (values are bitmask checked and limited to 0x0F)
+	- Not all classes handle equipment light sources the same way due to their equipment/loot list configurations
+	- Spell (casting?) light sources may be implemented at some point..more information is needed
+	- Currently, loot list (general inventory) light sources are limited to ItemTypeMisc and ItemTypeLight to avoid issues with worn-specific light sources emitting
+	- Augment light sources are not recognized by the client and, therefore, not implemented in the server code
+
+== 01/22/2015 ==
+Akkadius: Massive Log System overhaul, see: http://wiki.eqemulator.org/p?Logging_System_Overhaul&frm=Main
+	
+== 01/21/2015 ==
+Uleat: Added `light` field to npc_types load query (all six clients tested positive for functionality.)
+Note: This only affects 'innate' light. Equipment (other) light is still in-work.
+Optional SQL: utils/sql/git/optional/2015_01_21_NPC_Types_Light_Field_Primer.sql
+
+== 01/20/2015 ==
+Uleat: Fix for Inventory::_HasItemByUse(bucket) using the parent container when searching for bag container items.
+
+== 01/19/2015 ==
+Uleat: Changed 'enum EQClientVersion' to 'enum class ClientVersion.' Other light modifications were made to accommodate this namespace. Added 'RoF2' to the lua client version enumeration.
+
+== 01/15/2015 ==
+Uleat: Attempted fix for elusive inventory bug:
+  - Removed 'iter_queue' typedef and converted lcast to explicit or auto defines
+  - Reworked several functions that manipulate the cursor queue
+  - Found/corrected one occurrence of post-processing iterator incrementing in an ItemInstQueue handler
+  - Added many scope declarations in code that handles inventory manipulation (loose macros are bad...)
+Uleat: Added Item_Struct pointer checks to ItemInst methods that did not have them
+Uleat: Changed IsEquippable(race,class) to use bit-wise 'and' (&) over '(x%2)==1' in conditional check.
+Uleat: Changed DyeArmor() assignment of 'armor_color' to use bit-wise 'or' and bit-shifting (|,<<) over multiplication and addition (*,+).
+
+== 01/13/2015 ==
+Uleat: Placed an upper limit on the cursor queue save loop.
+Trevius: (RoF2) Guild invites now add new members as members instead of recruits, and /guild chat works properly.
+Trevius: (RoF2) Guild Promote is now functional.
+
+== 01/12/2015 ==
+Uleat: Fix for OP_FormattedMessage text link server crashes
+Uleat: Added text link translators for OP_TaskDescription (RoF+ -- all clients current)
+Uleat: Fix for load_bots.sql using '\\' as a delimiter (Changed to '$$')
+
+== 01/11/2015 ==
+Uleat: Added text link translators for OP_TaskDescription (Ti thru UF..RoF+ in-work)
+
+== 01/10/2015 ==
+Uleat: Added text link translators for OP_Emote
+
+== 01/09/2015 ==
+Uleat: Added text link translators for OP_FormattedMessage
+
+== 01/08/2015 ==
+Trevius: Added some extra checks and clean-up related to Groups and Mercenaries. 
+
+== 01/07/2015 ==
+Uleat: Excluded text link body from message scrambling in Client::GarbleMessage()
+Trevius: Mercenaries now load directly from tables only.  The vwMercNpcTypes view is no longer required and can be deleted.
+Trevius: Query fix for group_leaders table.  This may resolve some crashes/bugs related to Mercs/Bots and Groups.
+
+== 01/06/2015 ==
+Trevius: Changed the pet command #defines to be based on RoF2 list of pet commands and added decodes to Titanium, SoF and SoD.
+Trevius: (RoF+) The /pet focus on/off and /pet hold on/off commands are now functional.
+Trevius: Added defines for all remaining pet commands and some support for them as well.
+
+== 01/05/2015 ==
+Uleat: Fixed (added translators for) item/text links. Only 'OP_ChannelMessage' and 'OP_SpecialMesg' are currently handled..more text channels will be added as the need arises.
+
+== 01/03/2015 ==
+Trevius: (RoF2) /shield (shielding) and /key (key ring) are both now functional after opcode updates.
+
+== 01/02/2015 ==
+Trevius: (RoF2) *Hopefully* Fixed looting incorrect items from NPCs.  Please report any issues!
+Trevius: (RoF2) Now able to loot items past the 10th slot on NPC corpses.
+Trevius: Attuned Items can now be auto-looted and will equip properly.
+Trevius: Mercenaries and Bots will no longer take a share from /split or /autosplit.
+
+== 12/30/2014 ==
+Trevius: (RoF2) Aug Type 21 no longer shows the "Buy Now" button in the aug slot of items.
+Trevius: (RoF2) Identified the "Copied" item flag with the help of Uleat.
+
+== 12/29/2014 ==
+Trevius: (RoF2) Identified a few Item Fields and resolved an issue with cloth armor not accepting certain augments that they should.
+Akkadius: Updated $client->UpdateTaskActivity to have optional argument ignore_quest_update IE: Client::UpdateTaskActivity(THIS, TaskID, ActivityID, Count, [ignore_quest_update])
+Akkadius: Also updated internal UpdateTaskActivity methods to optionally ignore quest based task updates to prevent feedback
+
+== 12/28/2014 ==
+Uleat: Implemented class Client::TextLink as a replacement for the dozens of individual link formatters.
+
+== 12/27/2014 ==
+Akkadius: Add option to automatic database upgrade script 5) Download latest Opcodes from Github
+Trevius: (RoF2) Fixed dropping items on the ground so they go to ground level instead of camera height.
+Trevius: Show Helm Option should be functional again.
+Kayen: Implemened npc special ability (43) CASTING_RESIST_DIFF which sets innate resist modifier on
+ALL spells used by that NPC. Ie. 43,1,-200 will set a -200 innate resist diff, so if your npc cast
+a spell that has a -10 resist modifier the final resist diff would be -210.
+
+== 12/25/2014 ==
+Uleat: Updated 'links' code for all clients
+
+== 12/24/2014 ==
+Trevius: (RoF+) Added herosforgemodel field to the npc_types table.
+Trevius: (RoF2) Updated item links from #npcstat command output.
+Trevius: (RoF+) Implemented Hero's Forge Armor for NPCs.  Set the herosforgemodel field in npc_types table to the model (example: 84 for full set, or 12107 for robe).
+Trevius: (RoF+) Hero's Forge Armor now overrides NPC texture settings.  To display Hero's Forge Armor Helms, set helmtexture field to anything other than 0.
+
+== 12/23/2014 ==
+Uleat: Tidied up some ItemInst* declarations and added some nullptr checks.
+Trevius: (RoF+) Added support for Hero's Forge Robe Models.  Set herosforgemodel field in items table to exact model such as 11607, 11707, etc.
+
+== 12/22/2014 ==
+Trevius: (RoF2) Fixed Tracking.
+Trevius: (RoF+) Added a work-around for the cursor buffer issue.
+
+== 12/21/2014 ==
+Trevius: (RoF2) Fixed Extended Targets Window by correcting opcodes.
+Trevius: (RoF/RoF2) Fixed Guild Rank in the Player Profile, which prevents the guild rank message on login/zone.
+
+== 12/20/2014 ==
+Akkadius: Updated #cvs to display RoF2 Client Stream count
+
+== 12/19/2014 ==
+Trevius: (RoF2) Fixed Leadership AA Purchasing and Recipe Search by correcting opcodes.
+Trevius: Fixed Armor Tinting (players and NPCs) that was broken during a previous update.
+Trevius: (RoF2) Fixed Rest Timer, Show Helm Option, Auto-Consent Options, and identified Krono in the PP.
+Trevius: Fixed Selling for Alternate Currency Merchants for RoF and RoF2.
+
+== 12/18/2014 ==
+Trevius: Finished lining up the RoF2 Player Profile Struct.  Zone times are now normal, and everything from the PP is accurate in game now.
+Trevius: Fixed zoning after death for RoF2.
+
+== 12/17/2014 ==
+demonstar55: Use vectors for route stuff, should be more CPU cache friendly so faster
+Secrets: EQStream changes as recommended by a community member in private.
+
+== 12/15/2014 ==
+Trevius: (RoF+) Implemented the 6th Augment Slot for Items.
+Trevius: Player Corpses now saved attuned settings for Items.
+
+Required SQL: utils/sql/git/required/2014_12_15_multiple_table_updates.sql
+
+== 12/13/2014 ==
+demonstar55: Fix guild rank spam on zone (needed to be in OP_PP).
+Trevius: (RoF+) Implemented Armor Ornamentation using Hero's Forge Armor Models.  To use, create an ornamentation augment and set the herosforgemodel field in the items table.
+Trevius: (RoF+) Added command #heromodel (#hm for short) - Usage: #heromodel [hero forge model] [ [slot] ] (example: #heromodel 63)
+
+Be sure to run this or there will be item loss:
+Required SQL: utils/sql/git/required/2014_12_13_inventory_table_update.sql
+
+== 12/12/2014 ==
+demonstar55: Add special attack 42, Ignore Root Aggro Rules. This allows you to root a mob and have them still use the normal aggro rules (so they will attack the one with most hate, not closest)
+
+== 12/09/2014 ==
+Trevius: (RoF+) Implemented Hero's Forge Armor Models for Items.  To use, set herosforgemodel field in the item table to a model number such as 63 (for example).
+demonstar55: SoF+ swarm pets will no longer be F8able (without a hack!)
+
+== 12/08/2014 ==
+Secrets: Added a feature that allows an EQ client to log in directly to World without having to enter the LoginServer, provided the 'password' field is set in WorldServer.
+
+== 12/04/2014 ==
+Kayen: Ranged attacks will now more accurately check MAX firing range, fixing the issue where you would
+hit ranged attack and nothing would happpen due to incorrect server side range checks.
+Trevius: Initial addition of the RoF2 client from May 10th 2013 (currently available on Steam as the F2P client).
+Trevius: RoF2 is disabled by default, but you can enable by editing /common/patches/patches.cpp (see comments)
+
+== 12/01/2014 ==
+Trevius: Mercenaries now spawn as the same Gender and Size of the Merchant they are purchased from.
+Trevius: Mercenaries now spawn with randomized facial features when purchased.
+Trevius: Setting a lastname for NPCs will now override any hard coded lastname (such as GM Trainers).
+
+Required SQL: utils/sql/git/required/2014_12_01_mercs_table_update.sql
+
+== 11/28/2014 ==
+Trevius: Fixed a zone crash related to numhits for spells.
+Trevius: Fixed a query related to group leaders logging in.
+Trevius (Natedog): Fixed a world crash related to attempting to join an adventure with Mercenaries.
+
+== 11/27/2014 ==
+Kayen: Projectiles (ie Arrows) fired from archery will now do damage upon impact instead of instantly (consistent w/ live).
+Optional SQL: utils/sql/git/optional/2014_11_27_ProjectileDmgOnImpact.sql
+
+== 11/25/2014 ==
+Trevius: Spells that modify model size are now limited to 2 size adjustments from the base size.
+Trevius: Fix to prevent Mercenaries from being set as Group Leader.
+
+== 11/24/2014 ==
+Trevius: Added Rule NPC:EnableMeritBasedFaction (disabled by default) - Allows faction gain to work similar to experience.
+
+== 11/22/2014 ==
+Trevius: Grouping with Mercenaries is now considerably less buggy.
+Trevius: Fixed an issue with Spell Globals related to high Character IDs.
+Trevius: Crash fix for Swarm Pets.
+
+== 11/19/2014 ==
+Trevius: Mercenaries now Dismiss, Suspend, Unsuspend, and Die correctly.
+
+== 11/18/2014 ==
+Trevius: Mercenaries can now zone once again.
+
+== 11/17/2014 ==
+demonstar55: Correct OP_AugmentInfo reply. This fixes RoF display issue with Adventurer's Stone. Still issues with UF/SoF/SoD though.
+
+== 11/16/2014 ==
+demonstar55: fix size issue with ControlBoat_Struct and exploit fix in OP_BoardBoat
+
+Akkadius: Implemented Automatic Database update and versioning system
+Akkadius: Created database revision define, this is located in version.h in common #define CURRENT_BINARY_DATABASE_VERSION 9057
+	- This revision define will need to be incremented each time a database update is made
+	- Along with a revision define increment, you will need to update the db_update manifest located in:
+		- https://raw.githubusercontent.com/EQEmu/Server/master/utils/sql/db_update_manifest.txt
+		- An entry needs to be made at the bottom of the manifest, the entry is quite simple
+		- Example: 9057|2014_11_13_spells_new_updates.sql|SHOW COLUMNS FROM `spells_new` LIKE 'disallow_sit'|empty|
+			- This latest example is checking to see if the spells_new table contains the column 'disallow_sit', if its empty, the update needs to be ran
+				- More examples of match types below:
+		# Example: Version|Filename.sql|Query_to_Check_Condition_For_Needed_Update|match type|text to match
+		#	0 = Database Version
+		#	1 = Filename.sql
+		#	2 = Query_to_Check_Condition_For_Needed_Update
+		#	3 = Match Type - If condition from match type to Value 4 is true, update will flag for needing to be ran
+		#		contains = If query results contains text from 4th value
+		#		match = If query results matches text from 4th value
+		#		missing = If query result is missing text from 4th value
+		#		empty = If the query results in no results
+		#		not_empty = If the query is not empty
+		#	4 = Text to match
+	- The manifest contains all database updates 'Required' to be made to the schema, and it will contain a working backport all the way back to SVN - 
+		currently it is tested and backported through the beginning of our Github repo
+	- On world bootup or standalone run of db_update.pl, users will be prompted with a simple menu that we will expand upon later:
+	
+		============================================================
+			   EQEmu: Automatic Database Upgrade Check
+		============================================================
+				Operating System is: MSWin32
+				(Windows) MySQL is in system path
+				Path = C:\Program Files\MariaDB 10.0\bin/mysql
+		============================================================
+				Binary Database Version: (9057)
+				Local Database Version: (9057)
+
+				Database up to Date: Continuing World Bootup...
+		============================================================
+		Retrieving latest database manifest...
+        URL:    https://raw.githubusercontent.com/EQEmu/Server/master/utils/sql/db_update_manifest.txt
+        Saved:  db_update/db_update_manifest.txt
+
+Database Management Menu (Please Select):
+        1) Backup Database - (Saves to Backups folder)
+                Ideal to perform before performing updates
+        2) Backup Database Compressed - (Saves to Backups folder)
+                Ideal to perform before performing updates
+        3) Check for pending Database updates
+                Stages updates for automatic upgrade...
+        0) Exit
+
+Akkadius: Created db_update.pl, placed in utils/scripts folder, used for the automatic database update routine (Linux/Windows)
+	- db_update.pl script created db_version table if not created, if old one is present it will remove it
+Akkadius: Created db_dumper.pl, placed in utils/scripts folder, used for the automatic database update routine backups and standalone backups (Linux/Windows)
+Akkadius: World will now check the db_update.pl script on bootup, if the db_update.pl script is not present, it will fetch it remotely before running - 
+	when db_update.pl is done running, world will continue with bootup
+
+== 11/15/2014 ==
+Uleat(Natedog): A better fix for OP_ShopPlayerBuy - doesn't cause the issues that I introduced
+Kayen: Implemented NPC Special Ability 41 'Allow To Tank', gives NPC opportunity to take aggro over a client in melee range.
+Kayen: Updated swarm pet AI to be consistent with live.
+
+*OLD AI: Swarm pet would lock on to target until target died, then depop as soon as target died.
+
+*NEW AI: Swarm pet will attack cast on target, NOT perma locked it can change targets if attacked
+by something else that generate more hate. When target dies swarm pet will follow owner, if owner is
+attacked by something else the swarm pet will attack it (until duration timer despawns the pet).
+
+Kayen: Updated perl quest function: MakeTempPet(Tspell_id, name=nullptr, duration=0, target=nullptr, sticktarg=0)
+Kayen: Implemented perl quest function:  Mob::TypesTempPet(npctypesid, name=nullptr, duration=0, follow=0, target=nullptr, sticktarg=0)
+Note: 'sticktarg' field will cause the swarm pet to use the OLD AI
+
+Rule to use OLD AI only - default is disabled.
+Optional SQL: utils/sql/git/optional/2014_11_15_SwarmPetTargetLock.sql
+
+== 11/14/2014 ==
+Secrets: Identified object size and solidtype as flags. Exported them as functions to Perl.
+demonstar55: Don't use the hack for charms that doesn't work on RoF
+demonstar55: UF too
+demonstar55: Tit
+demonstar55: SoF
+demonstar55: SoD
+demonstar55: 62 (untested)
+
+== 11/13/2014 ==
+Kayen: Implemented target type (44) 'Beams' (which projects an AE infront of caster with a specified length and width).
+Kayen: Implemented target type (32) AE Target HateList
+Kayen: Implemented target type (36) Area Client Only
+Kayen: Implemented target type (37) Area PC Only
+Kayen: Implemented target type (39) Group No Pet
+Uleat: PlayerLogMerchantTransactions does not support partial stack purchase logging at this time
+
+== 11/12/2014 ==
+Uleat: Changed 'GMTrainee' struct to reflect the actual client hard-coded max skill count (100) - applies to all currently supported clients (6.2->RoF)
+
+== 11/11/2014 ==
+Uleat: Third attempt at a fix for GM trainer zone crashes... (this is starting to look like a KLS fix...)
+
+== 11/10/2014 ==
+Uleat: Fix for GM Trainer crashing server (really!)
+JJ: Yellow faction messages.
+
+== 11/09/2014 ==
+Kayen: Implemented support for spell target type (45) 'Target Rings' on Underfoot (does work earlier expansions). Thanks to Lecht for figuring out the op_code side.
+JJ: Implement new Live-like faction adjustment message using rule Client:UseLiveFactionMessage.
+Optional SQL: utils/sql/git/optional/2014_11_09_LiveFactionMessages.sql
+
+== 11/06/2014 ==
+demonstar55: Tracking default sort will now be correct order
+Trevius: Fixed dynamic merchant list loading.  Allows any merchant to be used in any zone.
+
+== 11/03/2014 ==
+Secrets: Fixed an overflow in melee lifetap calculations (int16 vs int32)
+Secrets: Fixed overflow on AC and ATK values that can go out of range.
+Secrets: Merc/Bot fixes for previous updates.
+Secrets: Changed a lot of int16s for stat-related functions to int32 because they were causing combat formula overflows (int16/int32 mismatch).
+Secrets: Linux fix?
+
+== 11/02/2014 ==
+Akkadius: Added out of range checking for Spell Save/Loads
+
+== 11/01/2014 ==
+Trevius: Fixed potential crash related to Pets/Mercs buffs when targeting themselves.
+JJ: (noudess) Revamped faction system. See https://github.com/EQEmu/Server/pull/256
+
+== 10/28/2014 ==
+Uleat: Added Client::InterrogateInventory(). Can be invoked by #interrogateinv and is also called when Handle_OP_MoveItem() calls for SwapItemResync()
+
+== 10/22/2014 ==
+Uleat: Fix for stacking items in a world object..added a new command option: #peekinv world - will show world container contents, if one is in use by target.
+
+== 10/20/2014 ==
+demonstar55: Inspect Buffs rank 1 will now show NPC buffs in target window (SoD+)
+
+== 10/19/2014 ==
+Uleat: Updated command #peekinv to display item links properly in RoF clients
+demonstar55: Group Mentoring in raids
+demonstar55: Inspect Buffs (text only version) works in raid groups
+demonstar55: Make use of the Inspect Buffs op/packet. 62 SOL until someone finds its op
+
+== 10/18/2014==
+demonstar55: Implement group mentor, sharing leadership exp (SoF+ only)
+demonstar55: Add gaining of group leadership while in raids
+
+== 10/16/2014 ==
+Uleat: Fixed the auto-conversion view naming error and renamed the views in the script files. Added a fix sql for databases that auto-converted.
+Fix SQL: ../sql/git/bots/deprecated/2014_10_16_Lower_Case_View_Fix.sql
+
+== 10/15/2014 ==
+Uleat: Cleaned up load/drop bots sqls, added '../utils/sql/git/bots/deprecated' and '../deprecated/load_bots_old.sql' (use this file on pre-player blob conversion databases.)
+Notes: I modifed the behavior of both load and drop bots to fail on the first operation if their modifications have been performed already.
+       'load_bots.sql' will explicitly add bot schema, while 'drop_bots.sql' will explicitly drop it. I also added a few lines to change
+	   a few altered tables back to their original state - as of the date in the file.
+
+== 10/13/2014 ==
+demonstar55: Partially implement leadership and raids
+	Currently working: client side only effects and stat bonuses.
+	Not working: Mark NPC, and other stuff that need extra server side support
+	Currently only UF tested (Tit and 62 may just work, others need packet work)
+
+== 10/12/2014 ==
+Akkadius: Fix for LDON Character Stat load
+
+== 10/11/2014 ==
+demonstar55: Implement Raid MOTD for UF
+	Don't forget 2014_10_11_RaidMOTD.sql!
+
+== 10/09/2014 ==
+Uleat: Added 'BOTS' conversion code to supplement the database 'PlayerProfile' blob conversion that Akkadius recently implemented.
+Note: This automatic conversion uses the view `vwbotcharactermobs` as an update vector. If you need/would like for the converter to run on
+previously and/or manually changed code, or just have a need for it to re-run, change the following in the database view and save:
+	"c.`last_login`,"				to	"c.`timelaston`,"
+	"c.`zone_id`"					to	"c.`zoneid`"
+	"FROM `character_data` AS c"	to	"FROM `character_old` AS c"
+** This will only work if you haven't deleted your `character_old` table **
+
+== 10/07/2014 ==
+demonstar55: Identified tutorial flag in all charcreate packets, reworked logic to correctly set homes binds
+
+== 10/05/2014 ==
+Uleat: Added Server<->Corpse slot translators needed for re-enumeration (inactive until phased in)
+
+== 10/03/2014 ==
+Uleat: Fixed Ti(6.2) OP_AugmentInfo translation that I broke (does not currently need and I mis-read a process)
+Uleat: Moved client patch OP_LootItem slot translation to external handlers
+
+== 10/02/2014 ==
+Kayen: Exported to PERL $client->SendSpellAnim(targetid, spellid)
+This function sends the spell graphic of a spell without actually having to cast the spell.
+
+== 10/02/2014 ==
+Uleat: First round of Ti/6.2 translators added - needed for re-enumeration
+
+== 10/01/2014 ==
+Kayen: Exported to PERL $client->SendColoredText(color, msg)
+demonstar55: Exported SendColoredText to lua
+
+== 09/30/2014 ==
+Uleat: Implemented click-casting from bag slots for clients that natively support it (RoF)
+
+== 09/28/2014 ==
+demonstar55: Add support for post June 18, 2014 Hundred Hands Effect spells (they changed the formula and stuff)
+set Spells:Jun182014HundredHandsRevamp to true if you're using a spell file from June 18, 2014+
+
+== 09/27/2014 ==
+Kayen: Implemented perl function $mob->GetSpellStat(spell_id, identifier, slot);
+Note: identifier is the stat field in spells_new, slot is used for certain effects like effectid, base,base2, max ect.
+Example $mob->GetSpellStat(121, "range"); //Returns spell range
+Example $mob->GetSpellStat(121, "effectid", 1); //Returns the the value of effectid1
+This will allow you to pull almost all the data for any spell in quest files.
+demonstar55: Move the client's SetAttackTimer to the end of Client::CalcBonuses to keep the haste in sync
+demonstar55: Correct haste/slow "stacking" rules
+demonstar55: Correct SE_AttackSpeed4 to respect unslowable
+demonstar55: Make the haste be between 1-225 like the client (<100 = slow, >100 = haste) to ...
+demonstar55: Correct Hundred Hands effect and use formula provided by devs
+
+== 09/24/2014 ==
+Uleat: Re-ordered server opcodes and handlers to give them some predictability of location (I need this for the inventory re-enumeration.)
+demonstar55: Added helper function bool EQEmu::IsTradeskill(uint32 skill)
+
+== 09/23/2014 ==
+Kayen: Spell recourse effects will now be applied AFTER the base spells effects have been applied (consistent with live).
+Kayen: SE_ApplySpell and SE_TriggerSpell will now be applied based on which effect slot they are used in (instead of always before all spell effects are checked).
+Note: If a spell has multiple SE_TriggerSpell effects within it. Only one will be able to trigger. (If you want multiple spells use SE_ApplySpell)
+
+== 09/22/2014 ==
+Akkadius: #resetaa now covers the function of #resetaa and #refundaa
+	- #resetaa will wipe all AA data, refund the spent points into the available points and send character to character select properly
+Akkadius: Removed #refundaa
+Akkadius: Removed a lot of debug code for blob conversion
+Akkadius: Changed status logging for loads/saves to Debug category
+
+== 09/21/2014 == 
+Akkadius: Player Profile Blob to Database Conversion
+	- Summary: HUGE difference in database speeds reads/writes and 1:10 datasize difference
+		- The new character storage engine unlike the character_ table before, is able to properly index data and make use of 
+			proper MySQL/MariaDB caching optimizations and performance has increased phenominally
+		PERFORMANCE AND STATISTICS FIGURES (Varies on hardware):
+		- EZ Server Character data size of 2.6GB `character_` table alone now takes up approx 600MB
+		- Character Data Loads take approx .03 seconds BEFORE MySQL/MariaDB cache
+		- Character Data Loads take approx .001-.0035 seconds AFTER MySQL/MariaDB cache
+		- Character Data Saves take approx .0001 - .003 for any particular save operation
+		- Database Auto Conversion: When the 'character_' table exists, World boot-up will queue an auto-conversion prompt and convert all of your characters, BACKUP
+			YOUR DATABASE BEFORE CONVERTING, here is an EASY backup script: http://wiki.eqemulator.org/p?MySQL_DB_Backup_Script
+			- On auto conversion, the following tables are created automatically:
+				- Table: `character_skills` - Stores Character Skills
+				- Table: `character_languages` - Stores Character Language
+				- Table: `character_bind` - Stores Character Bind point and Home Bind point designated by is_home bool field
+				- Table: `character_alternate_abilities` - Stores all Character AA
+				- Table: `character_currency` - Stores all Platinum/Gold/Silver/Copper and character related currencies
+				- Table: `character_data` - Stores basic character data (Fields from `character_` table migrated to this table)
+				- Table: `character_spells` - Stores character spells
+				- Table: `character_memmed_spells` - Stores character memorized spells
+				- Table: `character_disciplines` - Stores character disciplines
+				- Table: `character_material` - Stores character armor dye textures
+				- Table: `character_tribute` - Stores character tributes
+				- Table: `character_bandolier` - Stores character bandoliers
+				- Table: `character_inspect_messages` - Stores character inspection messages (Moved from `character_` table)
+				- Table: `character_leadership_abilities` - Stores character Leadership AAs
+	- Loads: Majority of Player profile loads now occur at Client::Handle_Connect_OP_ZoneEntry
+		LoadCharacterFactionValues(uint32 character_id, faction_map & val_list);
+		LoadCharacterSpellBook(uint32 character_id, PlayerProfile_Struct* pp);
+		LoadCharacterMemmedSpells(uint32 character_id, PlayerProfile_Struct* pp);
+		LoadCharacterLanguages(uint32 character_id, PlayerProfile_Struct* pp);
+		LoadCharacterDisciplines(uint32 character_id, PlayerProfile_Struct* pp);
+		LoadCharacterSkills(uint32 character_id, PlayerProfile_Struct* pp);
+		LoadCharacterData(uint32 character_id, PlayerProfile_Struct* pp, ExtendedProfile_Struct* m_epp);
+		LoadCharacterCurrency(uint32 character_id, PlayerProfile_Struct* pp);
+		LoadCharacterBindPoint(uint32 character_id, PlayerProfile_Struct* pp);
+		LoadCharacterMaterialColor(uint32 character_id, PlayerProfile_Struct* pp);
+		LoadCharacterBandolier(uint32 character_id, PlayerProfile_Struct* pp);
+		LoadCharacterTribute(uint32 character_id, PlayerProfile_Struct* pp);
+		LoadCharacterPotions(uint32 character_id, PlayerProfile_Struct* pp);
+		LoadCharacterLeadershipAA(uint32 character_id, PlayerProfile_Struct* pp);
+	- Saves: Occur all over the code now instead of calling full saves
+		SaveCharacterBindPoint(uint32 character_id, uint32 zone_id, uint32 instance_id, float x, float y, float z, float heading, uint8 is_home);
+		SaveCharacterCurrency(uint32 character_id, PlayerProfile_Struct* pp);
+		SaveCharacterData(uint32 character_id, uint32 account_id, PlayerProfile_Struct* pp, ExtendedProfile_Struct* m_epp);
+		SaveCharacterAA(uint32 character_id, uint32 aa_id, uint32 current_level);
+		SaveCharacterSpell(uint32 character_id, uint32 spell_id, uint32 slot_id);
+		SaveCharacterMemorizedSpell(uint32 character_id, uint32 spell_id, uint32 slot_id);
+		SaveCharacterMaterialColor(uint32 character_id, uint32 slot_id, uint32 color); 
+		SaveCharacterSkill(uint32 character_id, uint32 skill_id, uint32 value);
+		SaveCharacterLanguage(uint32 character_id, uint32 lang_id, uint32 value);
+		SaveCharacterDisc(uint32 character_id, uint32 slot_id, uint32 disc_id);
+		SaveCharacterTribute(uint32 character_id, PlayerProfile_Struct* pp);
+		SaveCharacterBandolier(uint32 character_id, uint8 bandolier_id, uint8 bandolier_slot, uint32 item_id, uint32 icon, const char* bandolier_name);
+		SaveCharacterPotionBelt(uint32 character_id, uint8 potion_id, uint32 item_id, uint32 icon);
+		SaveCharacterLeadershipAA(uint32 character_id, PlayerProfile_Struct* pp);
+	- Deletes:
+		DeleteCharacterSpell(uint32 character_id, uint32 spell_id, uint32 slot_id);
+		DeleteCharacterMemorizedSpell(uint32 character_id, uint32 spell_id, uint32 slot_id);
+		DeleteCharacterDisc(uint32 character_id, uint32 slot_id); 
+		DeleteCharacterBandolier(uint32 character_id, uint32 band_id);
+		DeleteCharacterLeadershipAAs(uint32 character_id);
+	- Now occur all over the code and only trigger when necessary
+	- Two FULL saves when looting a corpse, this has been reduced to just currency saves on initial loot and trimmed to one save since AddToMoneyPP did it already
+	- Every time a player moves coin with any situation (Splits/Trades/Merchant/Skills/Bank Coin Exchange/Coin Moves), a full save is made, this is now just a currency save
+	- Every time a player skilled up at a skill vendor, a full blob save hit was made, this is not just a currency hit
+	- Every time an AA was purchased, a full save was made
+	- Every time a spell was scribed/swapped, disc was trained
+	- When a client exists a zone, when a client enters a zone
+	- NOTE: These amount of excessive saves have caused scalability issues that cause the `character_` table to hang which causes process hangs that affect the whole server
+		because of the slowness of the `character_` table and the blob not allowing any indexing to occur
+	- All functions that once depended on the `character_` table are now rewritten to appropriately read from the `character_data` table
+	- Database query errors that occur during conversion or from and load/save/delete character functions are now leveraged via ThrowDBError and logs now go to 
+		Server_Folder_Root/eqemu_query_error_log.txt (You cannot log errors natively through MySQL)
+	- DBASYNC IS NOW COMPLETELY REMOVED - This was mainly for Character data async loads/saves and merchantlist loads
+	- Side implementations: 
+		Perl Exports:
+			- quest::crosszonesetentityvariablebynpctypeid(npctype_id, id, m_var) - Sets entity variables world wide with specified npctype_id
+			- quest::crosszonesignalnpcbynpctypeid(npctype_id, data) - Signals all NPC entities world wide with specified npctype_id
+			- $client->GetTaskActivityDoneCount(TaskID, ActivityID) - Gets task activity done count by task id and activity id for client entity
+	
+	VIEW TABLE SIZE AFTER CONVERT:
+		
+	SELECT CONCAT(table_schema, '.', table_name) as table_name,
+		   CONCAT(ROUND(table_rows / 1000000, 2), 'M')                                    rows,
+		   CONCAT(ROUND(data_length / ( 1024 * 1024 * 1024 ), 2), 'G')                    DATA,
+		   CONCAT(ROUND(index_length / ( 1024 * 1024 * 1024 ), 2), 'G')                   idx,
+		   CONCAT(ROUND(( data_length + index_length ) / ( 1024 * 1024 * 1024 ), 2), 'G') total_size,
+		   ROUND(index_length / data_length, 2)                                           idxfrac
+	FROM   information_schema.TABLES
+	WHERE `table_name` LIKE 'character_%'
+	ORDER  BY DATA DESC;
+
+== 09/20/2014 ==
+demonstar55: Fix crash in SendEnterWorld on illegally long names
+demonstar55: The client only lets you enter 15 characters for your name (UF at least)
+demonstar55: Add rule Spells:SHDProcIDOffByOne for pre-UF spell file, set to true, UF+ set to false
+KLS: #suspend and #ban now have required messages to record the reason for the ban/suspension.
+
+== 09/19/2014 ==
+demonstar55: Added Client::Tell_StringID (used in tell queue messages)
+demonstar55: Tell queues (and offline) messages now show correctly
+demonstar55: Fix starting with capital check
+
+== 09/18/2014==
+demonstar55: Implement tell queues
+	Currently set to a limit of 20 by default (World:TellQueueSize) I was unable to hit the limit on live though (100+)
+	The required SQL nukes the old tell queue table, which may or may not be in your DB
+	Optional SQL adds the rule to the DB to allow easy of change
+	Note: this does not play well with multiple sessions with the same name on (crash and relog and have multiple sessions) but normal tells don't play well either
+
+== 09/16/2014 ==
+demonstar55: Implement spell formula 137 (BER AA Desperation)
+Uleat (NateDog): Fix for LoadBuffs() crash when a spell with a non-persistent Illusion effect was loaded.
+demonstar55: Fix some effect calcs + implement more (derived from the client)
+
+== 09/15/2014 ==
+Kayen: Nimbus effects will now be reapplied after zoning and will be removed when associated buff fades.
+
+== 09/13/2014 ==
+demonstar55: Fix rogues not having Thieves' Cant
+
+== 09/09/2014 ==
+demonstar55: Incrase Mob kick/bash timer by 3
+	see: http://www.eqemulator.org/forums/showthread.php?t=38734
+demonstar55: Fix slow effect on NPC special attack reuse timers
+	see: http://www.eqemulator.org/forums/showthread.php?t=38734
+demonstar55: Slow fixes to bots!
+demonstar55: Revamped how NPC attack rate is set
+	SQL: 2014_09_09_attack_delay.sql
+demonstar55: Added attackdelay to #npcedit
+
+== 09/08/2014 ==
+demonstar55: Fix slow calc
+	see: http://www.eqemulator.org/forums/showthread.php?t=38734
+
+== 09/07/2014 ==
+Akkadius: Fixed ROF Augment item dupe with not checking for available slots properly and adding items to the virtual instance
+
+== 09/06/2014 ==
+Uleat: Tweaked 'Smart' trading code to return main slots before sub slots in stackable and free space search processes. (If enough people ask for it, I'll add an optional rule to allow 'bag packing' - the original implementation behavior)
+
+== 09/05/2014 ==
+Uleat: Fix for cursor item loss when zoning. (Thanks to the other devs who traced and fixed the 'macro' issue!)
+demonstar55: Fix size getting nuked with lua's SendIllusionPacket
+
+== 09/03/2014 ==
+Secrets: Identified the routines needed to augment items in RoF. Currently, only Insert and Remove are supported. Swap and Destroy do not work due to missing functions related to the cursor.
+demonstar55: Added work around command to show numhits on your buffs (#shownumhits)
+Uleat: Fix for timer issue introduced by Zone::ShutDown() fix.
+
+== 09/02/2014 ==
+Secrets: Identified OP_GuildPromote for RoF clients.
+Secrets: Fixed promotion, demotion, transferring a leader and displaying of client ranks in the Rain of Fear client. The rain of fear client, as such, will only have 3 ranks like the other clients, but supports a theoretical 8 ranks later.
+Secrets/Akkadius: Fixed an issue involving character name lookup in the new DB code.
+demonstar55: crash fix checking DivineAura in hate_list.cpp
+Secrets: Reverted some code that got in the main branch that shouldn't have gotten there.
+Uleat: Changed #loc to report the same precision as /loc for Cartesians
+
+== 08/31/2014 ==
+KLS: Fixed a bug in fishing in S3D zones
+KLS: Fixed a bug in turnins with new any abstraction
+KLS: Fixed a few quest related inconsistencies.
+KLS: Added Lua EntityList::ChannelMessage(from, type, msg, language)
+
+== 08/30/2014 ==
+demonstar55: (noudess) Merchants should be more descriptive of why they don't sell to you
+
+== 08/26/2014 ==
+Uleat: Implemented 'Smart' Player Trade transfers. Trades are processed by containers, stackables and then all remaining. QueryServ logs have been updated to match these transactions.
+Note: QueryServ logs previously listed 'Items' on the main entry table. This indicated the number of slots affected and not the actual number of items.
+This field now indicates the actual number of items transferred. For non-stackable, the value is '1' and stackable is the number of charges. A _detail_count
+property has been added to both 'Trade' and 'Handin' structs to indicate the number of details recorded..though, not tracked..it could be added.
+
+== 08/24/2014 ==
+Uleat: Fix (attempted) for zone crashes related to zone shut-down. This change disables all Mob AI and disables/deletes all Mob timers once Zone::ShutDown() is called. More areas will be addressed as reports come in.
+Note: Perl and Lua quests tested to work..please post any aberrant behavior. (I finally set my spell-check to US English...)
+Akkadius: Character creation process crash fix and query cleanup
+Akkadius: Created `character_lookup` table for applications that mirrors all `character_` table fields minus blob fields for application lookups
+	- A 2.4GB character_ table will take 7 seconds to query on a SSD versus .1s on the character_lookup table
+	- This also causes applications like Magelo to burst reads of the entire character table because of the blob fields that come with the reads, as much as 500-600MB/s even if a indexed id filter is provided
+	- This field is synchronized on player save and has 0.001s DB hit
+	- When we split out from the blob, ideally this table can be removed
+	- Required SQL: utils\sql\git\required\2014_08_24_character_lookup.sql
+
+== 08/23/2014 ==
+Akkadius: Changed zone process window title format, example: 'crushbone :: clients: 6 inst_id: 1 inst_ver: 0 :: port: 7015'
+Akkadius: Most of the following changes are QueryServ related, fully implemented its original functionality to be able to offload
+	intensive or metric based logging to a remote server process that could exist on another server entirely
+Akkadius: Implemented Player Event Logging Types (Go to table `qs_player_events`):
+			1 = Player_Log_Quest,
+			2 = Player_Log_Zoning,
+			3 = Player_Log_Deaths,
+			4 = Player_Log_Connect_State,
+			5 = Player_Log_Levels,
+			6 = Player_Log_Keyring_Addition,
+			7 = Player_Log_QGlobal_Update,
+			8 = Player_Log_Task_Updates,
+			9 = Player_Log_AA_Purchases,
+			10 = Player_Log_Trade_Skill_Events,
+			11 = Player_Log_Issued_Commands,
+			12 = Player_Log_Money_Transactions,
+			13 = Player_Log_Alternate_Currency_Transactions,
+		- All QueryServ logging will be implemented with a front end in EoC 2.0 very soon
+		- Architecture page: http://wiki.eqemulator.org/p?QueryServ_Architecture
+Akkadius: Changed all QS Error related logging to 'QUERYSERV__ERROR'
+Akkadius: (Natedog) (Crash Fix) Legacy MySQL bug revert for loading AA's COALESCE( from COALESCE (
+Akkadius: Implemented Perl Quest objects (LUA still needed to be exported):
+	- quest::qs_send_query("MySQL query") - Will send a raw query to the QueryServ process, useful for custom logging
+	- quest::qs_player_event(char_id, event_desc); - Will process a quest type event to table `qs_player_events` 
+Akkadius: Added MySQL Tables
+	- `qs_player_aa_rate_hourly`
+	- `qs_player_events` 
+	- Source table structures from:
+		- utils\sql\git\queryserv\required\08_23_2014_player_events_and_player_aa_rate_hourly
+		To get the complete QueryServ schema, source from here:
+		- utils\sql\git\queryserv\required\Complete_QueryServ_Table_Structures.sql
+Akkadius: Added rules for each logging type, source rules here with them enabled by default:
+	- utils\sql\git\queryserv\required\Complete_QueryServ_Rules_Enabled.sql
+Akkadius: Spawn related logging cleanup
+Akkadius: General code cleanup
+Akkadius: More to come for QueryServ 
+
+== 08/22/2014 ==
+Uleat: Rework of Trade::FinishedTrade() and Trade::ResetTrade() to parse items a little more intelligently.
+
+Trade window items are now sent to client inventory in this order:
+	- Bags
+	- Partial stack movements
+	- All remaining items
+
+If any of these procedures cause any problems, please post them immediately.
+
+== 08/20/2014 ==
+Uleat: Rework of Trade::AddEntity() - function used to move items into the trade window. Now accepts argument for 'stack_size' and updates client properly.
+Note: I tested trade with Titanium:{SoF,SoD,UF,RoF} in both directions and no client generated an OP_MoveItem event for attempting to place a stackable
+onto a partial stack already in the trade window. The only way to achieve stacking is to click on the receiving client. If there is a partial stack remaining
+on the cursor after the OP_MoveItem event, and there is room available, the client will generate subsequent events to move the remaining count.
+
+== 08/19/2014 ==
+Akkadius: Implemented a Stop_Return feature (Accidental item handin prevention) that will be symmetrically used with plugin::return_items that I am currently running live testing on EZ before releasing to EQEmu. This does not hurt to have this in the source.
+Akkadius: Fixed crash where 'attacker' validation is not being checked
+Akkadius: Removed petition console spam that does not follow traditional logging and is useless
+Akkadius: Made fix with SympatheticProcChances where it was checking for TempItem->Focus.Effect instead of TempItemAug->Focus.Effect
+
+== 08/18/2014 ==
+Uleat: Fix for https://github.com/EQEmu/Server/issues/127 -- also activated a remarked action in doors.cpp to eliminate a memory leak.
+
+== 08/16/2014 ==
+KLS: (addmoreice) Trying out some unstable DB changes.  Do backup your database before trying them as master will be considered unstable for a few days at least.
+Uleat (Noudness): Fixed a floating-point comparison error that led to the notorious 'client bounce' (this is not related to the
+'mob falling' due to not having maps installed.) This fix also eliminates a sizeable amount of unnecessary out-going packets due
+to invalid orientation corrections.
+Note: This patch is probably of significant enough importance that admins may wish to manually apply this to older server builds.
+The number of packets reduced per second should be approximately (num_stationary_close_clients * (num_close_clients - 1)). This will
+likely have the most effect in zones like: Nexus, Bazaar, Guilds (Halls) and RAID INSTANCES - where players don't move around a lot.
+
+== 08/15/2014 ==
+Uleat: Reactivated the Bot::Spawn() code for sending post-spawn wear change updates..temporary until I can sort out the proper usage.
+
+== 08/13/2014 ==
+Uleat (Kingly_Krab): Fix for bot chest armor graphic glitch. (fix also caused RoF #wc to work properly)
+
+== 08/02/2014 ==
+Kayen: Implemented spell_news fields
+- npc_no_los (check if LOS is required for spells) 
+- InCombat, OutofCombat - Used together to restrict spells to only be cast while 
+in/out of combat (beneficial) or if target is in/out of combat (detrimental).
+-min_dist, min_dist_mod, max_dist, max_dist_mod - Scales spell power based on targets distance from caster.
+*This will require further work to fully implement but will work with 90% of live spells as is.
+*If making custom spells do not include effects that can't be scaled (like a spell trigger)
+- min_rage sets minimum distance range that must be away from target.
+
+Required SQL: utils/sql/git/required/2014_08_02_spells_new.sql
+
+== 07/31/2014 ==
+Uleat: More inventory slot constant conversions. This should be the bulk of everything..but, due to the size of the server code, there
+may be some hidden ones. (client_packet.cpp and the client translators still need a thorough review.)
+Note: Please report any abnormal behaviour with inventory-related content..each diff file was reviewed 3 times..but, things CAN be missed.
+Uleat: Test fix for client crashes in Bazaar, while actively selling, with a charm in the Trader's Satchel.
+
+== 07/27/2014 ==
+Uleat: More updates to the dictionary. Added a 'constants' file for each client translator..these will tie-in to the dictionary. Started
+replacement of hard-coded numeric values with a pre-defined constant. This will help in the transition.
+
+== 07/16/2014 ==
+Uleat: Initial commit of new client/server 'dictionaries' - work in-progress... Changed equipment slot references to reflect new naming
+conventions. Lua enumerations maintain both the old and new names as to not break existing scripts..but, the old names are deprecated.
+
+
+== 07/14/2014 ==
+KLS: Changes to CMake build
+	-Lua builds by default now
+	-Common has been renamed common
+	-Binary files will now be put into ${CMAKE_BINARY_DIR}/bin instead of ${CMAKE_BINARY_DIR}/Bin
+	The last two are of note to people on non-windows systems as case sensitivity is important.  Edit your scripts accordingly, thank you.
+
+
+== 07/10/2014 ==
+Kayen: Updated table npc_spells to now support defensive and ranged procs. 
+Note: Proc rate modifier work as it does for spell effects (ie 200 = 200% baseline chance modifier)
+Table is also now contains 12 AI spell casting variables that can be set to fine tune casting behaviors per spell set.
+Global default rules have also been added that can further fine tune all content if no specific variables are set.
+
+Descriptions of new AI casting fields in npc_spells
+'fail_recast' AI spell recast time(MS) when an spell is cast but fails (ie stunned)
+'engaged_no_sp_recast_min' AI spell recast time(MS) checked when no spell is cast while engaged in combat. (min time in random)
+'engaged_no_sp_recast_max' AI spell recast time(MS) checked when no spell is cast while engaged in combat. (max time in random)
+'engaged_b_self_chance' Chance during first AI Cast check to do a beneficial spell on self (ie check to heal self)
+'engaged_b_other_chance' Chance during second AI Cast check to do a beneficial spell on others.(ie check to heal others)
+'engaged_d_chance' 'Chance during third AI Cast check to do a determental spell on others (ie check to nuke others)
+'pursue_no_sp_recast_min' AI spell recast time(MS) checked when no spell is cast while chasing target. (min time in random)
+'pursue_no_sp_recast_max' AI spell recast time(MS) checked when no spell is cast while chasing target. (max time in random)
+'pursue_d_chance' Chance while chasing target to cast a detrimental spell.
+'idle_no_sp_recast_min' AI spell recast time(MS) checked when no spell is cast while idle. (min time in random)
+'idle_no_sp_recast_max' AI spell recast time(MS) checked when no spell is cast while idle. (max time in random)
+'idle_b_chance' Chance to cast a beneficial spell while idle (ie cast heal on self while out of combat).
+
+Kayen: Updated table npc_types, adding field 'ranged_type' and 'ammo_idfile'
+'ranged_type' Will set what skill / animation is used when NPC uses a ranged attacked (special ability 11)
+'ammo_idfile' Will set what projectile graphic an NPC uses in a ranged attacked (special ability 11) Format IT#### (same as item 'idfile')
+(*Set to IT11118 for some fun*)
+Added parameters: SPECATK_RANGED_ATK = 11
+Param0: Min Ranged distance (default: 25)
+Param1: Max Ranged distance (default: 250)
+Param2: Percent Chance to Hit modifier
+Param3: Percent Total Damage modifier
+
+Kayen: Updated to Chance to Hit code with how bonuses are applied to be consistent for all effects.
+Added field to npc_types 'Avoidance' which will modify chance to avoid melee 
+Added rules to set max and min chance to hit from melee/ranged (Default 95% / 5%)
+
+Required SQL: utils/sql/git/required/2014_07_10_npc_spells.sql
+Optional SQL: utils/sql/git/optional/2014_07_10_AICastingRules.sql
+
+
+== 07/5/2014 ==
+Kayen: Updated SE_Sanctuary - Adjust way hate lowering effect worked to be more accurate
+Kayen: Updated SE_SympatheticProc - Revised proc rate formula to be accurate to live.
+Sympathetic foci on items with proc rate mod will now benefit from that modifier.
+Sympathetic foci can now be placed on AA's (This should always be slot1 in the AA)
+Kayen: Implemented SE_IllusionPersistence- Allows illusions to last until you die or the illusion is forcibly removed.
+Kayen: Added rule 'PreNerftBardAEDot' for SE_BardAEDot to allow it to once again do damage to moving targets. (Set to true)
+Kayen: Completely revised SE_SkillProc, SE_LimitToSkill, SE_SkillProcSuccess to overall just work better and more accurately, AA support. 
+
+Required SQL: utils/sql/git/required/2014_07_04_AA_Update.sql
+
+
+== 07/2/2014 ==
+Kayen: Implemented SE_Sanctuary - Places caster at bottom hate list, effect fades if caster cast spell on targets other than self.
+Kayen: Implemented SE_ResourceTap - Coverts a percent of dmg from dmg spells(DD/DoT) to hp/mana/end.
+Kayen: Implemented SE_FactionModPct - Modifies faction gains and losses by percent.
+Kayen: Re-Implemented SE_TriggerMeleeThreshold and SE_TriggerSpellThreshold correctly - Trigger spell if owner of buff
+takes more than the specified damage amount in a SINGLE hit, then fade the buff.
+Kayen: Implemented SE_LimitSpellClass - Focus Limits spell to pre defined categories. (3=Cures,3=Offensive, 6=Lifetap)
+Kayen: Changed SE_LimitMaxMana to SE_MeleeVulnerability - Weakness/Mitigation verse melee damage
+(Despite lives SPA lable as the former it clearly is not what the effect does from all spell examples)
+Kayen: Updated SE_BardAEDot to no longer damage target while target is moving (consistent with live)
+Kayen: Update SE_InterruptCasting: Will now work for instant spells (as well as over time).
+
+== 06/25/2014 ==
+Kayen: Updated SE_Hate (Renamed from SE_Hate2) to now properly work for instant +/- hate spells.
+Kayen: Updated SE_FadingMemories - Base value will be properly utilized to set % chance for fade effect to work.
+Kayen: Implemented SE_StrikeThough (Was incorrectly defined as implemented previously) - Works same as item bonus.
+Kayen: Update SE_Taunt - Limit value if present will now add instant hate.
+Kayen: Implemented SE_MassGroupBuff - Allows next group buff cast to be a MGB (AA now uses this)
+Kayen: Implemented SE_IllusionOther - Allows next Illusion buff (self only) cast to be cast on target. (AA now uses this)
+Kayen: Update SE_AETaunt - Base value will now determine AE taunt range (This will not result in any change to currently used spells).
+Kayen: Udpated SE_ReclaimPet - Correct forumla for mana returned to properly return 75% of actual pet spell mana cost.
+Kayen: Implemented SE_ImprovedReclaimEnergy - Modifies % mana returned from SE_ReclaimPet.
+Kayen: Implemented SE_HeadShot, SE_HeadShotLevel - Defines headshot damage and level requirements.
+Revised HeadShot mechanic so damage now receives all archery bonuses, proc chance can be set to either (lives new Proc Per minute
+system, or flat chance based on dex (formula updated).
+Kayen: Implemented SE_Assassinate, SE_AssassinateLevel - Defines assassinate damage and level requirements.
+Revised Assassinate mechanic so damage now receives all backstab bonuses, proc chance can be set to either (lives new Proc Per minute
+system, or flat chance based on dex (formula updated). Assassinate can now proc from THROW if behind target, various other adjustments.
+Kayen: Fix to AA Finishing Blow missing aa_effects data, update required SQL.
+Revised Finishing blow so that damage now receives all melee bonus. Support also for this effect if placed on items or spells.
+Kayen: Implemented SE_PetMeleeMitigation - Bonus applied to pet owner. Gives AC to owner's pet.
+
+Required SQL: utils/sql/git/required/2014_06_25_AA_Update.sql
+Optional SQL: utils/sql/git/optiional/2014_06_29_HeadShotRules.sql
+
+
+== 06/17/2014 ==
+Kayen: Implemented SE_AStacker, SE_BStacker, SE_CStacker, SE_DStacker.
+These effects when present in buffs prevent each other from stacking, 
+Any effect with B prevents A, C prevents B, D prevents C.
+Kayen: Implemented SE_DamageModifier2 (Stacks with SE_DamageModifier, mods damage by skill type)
+Kayen: Implemented SE_AddHatePct (Modifies +/- your total hate on NPC by percent)
+Kayen: Implemented SE_AddHateOverTimePct (Modifies +/- your total hate on NPC by percent over time)
+Kayen: Implemented SE_DoubleRiposte (Modifies +/- your double riposte chance) *Not used in any live effects
+Kayen: Implemented SE_Berserk (Sets client as 'Berserk' giving chance to crippling blow) *Not used in any live effects
+Kayen: Implemented SE_Vampirsm (Stackable lifetap from melee effect) *Not used in any live effects
+Kayen: Minor fixes to how lifetap from melee effects are calced. Removed arbitrary hard cap of 100%, Negative value will now dmg client.
+Kayen: Fix to issue that prevented NPC's from receiving HP Regeneration derived from spell buffs.
+Kayen: Fixes and Updates for melee and spell mitigation runes.
+Kayen: Update to SE_NegateAttack, 'max' value can now set upper limit of damage absorbed. DOT ticks will no longer be absorbed.
+Kayen: Implemented SE_Metabolism - Modifies food/drink consumption rates. [Data for AA is already in database]
+Kayen: Update to SE_BalanaceMana, SE_BalanceHP to support limit value which caps max mana/hp that can be taken per player.
+
 == 06/13/2014 ==
 Kayen: For table 'npc_spell_effects_entries' setting se_max for damage shield effects (59) will now determine the DS Type (ie burning)
 Setting se_max to 1 for SkillDamageTaken effects (127) will allow for stackable mitigation/weakness same as quest function ModSkillDmgTaken.

client_files/export/CMakeLists.txt

@@ -11,15 +11,17 @@ ADD_EXECUTABLE(export_client_files ${export_sources} ${export_headers})
 
 INSTALL(TARGETS export_client_files RUNTIME DESTINATION ${CMAKE_INSTALL_PREFIX})
 
-TARGET_LINK_LIBRARIES(export_client_files Common debug ${MySQL_LIBRARY_DEBUG} optimized ${MySQL_LIBRARY_RELEASE} ${ZLIB_LIBRARY})
+TARGET_LINK_LIBRARIES(export_client_files common ${PERF_LIBS} debug ${MySQL_LIBRARY_DEBUG} optimized ${MySQL_LIBRARY_RELEASE} ${ZLIB_LIBRARY})
 
 IF(MSVC)
 	SET_TARGET_PROPERTIES(export_client_files PROPERTIES LINK_FLAGS_RELEASE "/OPT:REF /OPT:ICF")
 	TARGET_LINK_LIBRARIES(export_client_files "Ws2_32.lib")
+	TARGET_LINK_LIBRARIES(export_client_files "rpcrt4")
 ENDIF(MSVC)
 
 IF(MINGW)
 	TARGET_LINK_LIBRARIES(export_client_files "WS2_32")
+	TARGET_LINK_LIBRARIES(export_client_files "rpcrt4")
 ENDIF(MINGW)
 
 IF(UNIX)
@@ -30,7 +32,8 @@ IF(UNIX)
 		TARGET_LINK_LIBRARIES(export_client_files "rt")
 	ENDIF(NOT DARWIN)
 	TARGET_LINK_LIBRARIES(export_client_files "pthread")
+	TARGET_LINK_LIBRARIES(export_client_files "uuid")
 	ADD_DEFINITIONS(-fPIC)
 ENDIF(UNIX)
 
-SET(EXECUTABLE_OUTPUT_PATH ${PROJECT_BINARY_DIR}/Bin)
+SET(EXECUTABLE_OUTPUT_PATH ${PROJECT_BINARY_DIR}/bin)

client_files/export/main.cpp

@@ -17,13 +17,17 @@
 */
 
 #include <stdio.h>
-#include "../../common/debug.h"
+
+#include "../../common/eqemu_logsys.h"
+#include "../../common/global_define.h"
 #include "../../common/shareddb.h"
-#include "../../common/EQEmuConfig.h"
+#include "../../common/eqemu_config.h"
 #include "../../common/platform.h"
 #include "../../common/crash.h"
 #include "../../common/rulesys.h"
-#include "../../common/StringUtil.h"
+#include "../../common/string_util.h"
+
+EQEmuLogSys Log;
 
 void ExportSpells(SharedDatabase *db);
 void ExportSkillCaps(SharedDatabase *db);
@@ -31,118 +35,116 @@ void ExportBaseData(SharedDatabase *db);
 
 int main(int argc, char **argv) {
 	RegisterExecutablePlatform(ExePlatformClientExport);
+	Log.LoadLogSettingsDefaults();
 	set_exception_handler();
-	
-	LogFile->write(EQEMuLog::Status, "Client Files Export Utility");
+
+	Log.Out(Logs::General, Logs::Status, "Client Files Export Utility");
 	if(!EQEmuConfig::LoadConfig()) {
-		LogFile->write(EQEMuLog::Error, "Unable to load configuration file.");
+		Log.Out(Logs::General, Logs::Error, "Unable to load configuration file.");
 		return 1;
 	}
 
 	const EQEmuConfig *config = EQEmuConfig::get();
-	if(!load_log_settings(config->LogSettingsFile.c_str())) {
-		LogFile->write(EQEMuLog::Error, "Warning: unable to read %s.", config->LogSettingsFile.c_str());
-	}
 
 	SharedDatabase database;
-	LogFile->write(EQEMuLog::Status, "Connecting to database...");
+	Log.Out(Logs::General, Logs::Status, "Connecting to database...");
 	if(!database.Connect(config->DatabaseHost.c_str(), config->DatabaseUsername.c_str(),
 		config->DatabasePassword.c_str(), config->DatabaseDB.c_str(), config->DatabasePort)) {
-		LogFile->write(EQEMuLog::Error, "Unable to connect to the database, cannot continue without a "
+		Log.Out(Logs::General, Logs::Error, "Unable to connect to the database, cannot continue without a "
 			"database connection");
 		return 1;
 	}
-	
+
+	/* Register Log System and Settings */
+	database.LoadLogSettings(Log.log_settings);
+	Log.StartFileLogs();
+
 	ExportSpells(&database);
 	ExportSkillCaps(&database);
 	ExportBaseData(&database);
-	
+
+	Log.CloseFileLogs();
+
 	return 0;
 }
 
 void ExportSpells(SharedDatabase *db) {
-	LogFile->write(EQEMuLog::Status, "Exporting Spells...");
+	Log.Out(Logs::General, Logs::Status, "Exporting Spells...");
 
 	FILE *f = fopen("export/spells_us.txt", "w");
 	if(!f) {
-		LogFile->write(EQEMuLog::Error, "Unable to open export/spells_us.txt to write, skipping.");
+		Log.Out(Logs::General, Logs::Error, "Unable to open export/spells_us.txt to write, skipping.");
 		return;
 	}
 
-	char errbuf[MYSQL_ERRMSG_SIZE];
-	char *query = "SELECT * FROM spells_new ORDER BY id";
-	MYSQL_RES *result;
-	MYSQL_ROW row;
-	if(db->RunQuery(query, strlen(query), errbuf, &result)) {
-		while(row = mysql_fetch_row(result)) {
+	const std::string query = "SELECT * FROM spells_new ORDER BY id";
+	auto results = db->QueryDatabase(query);
+
+	if(results.Success()) {
+        for (auto row = results.begin(); row != results.end(); ++row) {
 			std::string line;
-			unsigned int fields = mysql_num_fields(result);
+			unsigned int fields = results.ColumnCount();
 			for(unsigned int i = 0; i < fields; ++i) {
 				if(i != 0) {
 					line.push_back('^');
 				}
-				
-				line += row[i];
+
+				if(row[i] != nullptr) {
+					line += row[i];
+				}
 			}
-			
+
 			fprintf(f, "%s\n", line.c_str());
 		}
-		mysql_free_result(result);
 	} else {
-		LogFile->write(EQEMuLog::Error, "Error in ExportSpells query '%s' %s", query, errbuf);
 	}
-	
+
 	fclose(f);
 }
 
 bool SkillUsable(SharedDatabase *db, int skill_id, int class_id) {
-	char errbuf[MYSQL_ERRMSG_SIZE];
-	char *query = nullptr;
-	MYSQL_RES *result;
-	MYSQL_ROW row;
-	bool res = false;
-	if(db->RunQuery(query, MakeAnyLenString(&query, "SELECT max(cap) FROM skill_caps WHERE class=%d AND skillID=%d",
-		class_id, skill_id), errbuf, &result)) {
-		if(row = mysql_fetch_row(result)) {
-			if(row[0] && atoi(row[0]) > 0) {
-				res = true;
-			}
-		}
-		mysql_free_result(result);
-	} else {
-		LogFile->write(EQEMuLog::Error, "Error in skill_usable query '%s' %s", query, errbuf);
-	}
 
-	safe_delete_array(query);
-	return res;
+	bool res = false;
+
+	std::string query = StringFormat("SELECT max(cap) FROM skill_caps WHERE class=%d AND skillID=%d",
+                                    class_id, skill_id);
+	auto results = db->QueryDatabase(query);
+	if(!results.Success()) {
+        return false;
+    }
+
+    if (results.RowCount() == 0)
+        return false;
+
+    auto row = results.begin();
+    if(row[0] && atoi(row[0]) > 0)
+        return true;
+
+    return false;
 }
 
 int GetSkill(SharedDatabase *db, int skill_id, int class_id, int level) {
-	char errbuf[MYSQL_ERRMSG_SIZE];
-	char *query = nullptr;
-	MYSQL_RES *result;
-	MYSQL_ROW row;
-	int res = 0;
-	if(db->RunQuery(query, MakeAnyLenString(&query, "SELECT cap FROM skill_caps WHERE class=%d AND skillID=%d AND level=%d",
-		class_id, skill_id, level), errbuf, &result)) {
-		if(row = mysql_fetch_row(result)) {
-			res = atoi(row[0]);
-		}
-		mysql_free_result(result);
-	} else {
-		LogFile->write(EQEMuLog::Error, "Error in get_skill query '%s' %s", query, errbuf);
-	}
 
-	safe_delete_array(query);
-	return res;
+	std::string query = StringFormat("SELECT cap FROM skill_caps WHERE class=%d AND skillID=%d AND level=%d",
+                                    class_id, skill_id, level);
+    auto results = db->QueryDatabase(query);
+    if (!results.Success()) {
+        return 0;
+    }
+
+    if (results.RowCount() == 0)
+        return 0;
+
+    auto row = results.begin();
+	return atoi(row[0]);
 }
 
 void ExportSkillCaps(SharedDatabase *db) {
-	LogFile->write(EQEMuLog::Status, "Exporting Skill Caps...");
+	Log.Out(Logs::General, Logs::Status, "Exporting Skill Caps...");
 
 	FILE *f = fopen("export/SkillCaps.txt", "w");
 	if(!f) {
-		LogFile->write(EQEMuLog::Error, "Unable to open export/SkillCaps.txt to write, skipping.");
+		Log.Out(Logs::General, Logs::Error, "Unable to open export/SkillCaps.txt to write, skipping.");
 		return;
 	}
 
@@ -167,35 +169,32 @@ void ExportSkillCaps(SharedDatabase *db) {
 }
 
 void ExportBaseData(SharedDatabase *db) {
-	LogFile->write(EQEMuLog::Status, "Exporting Base Data...");
+	Log.Out(Logs::General, Logs::Status, "Exporting Base Data...");
 
 	FILE *f = fopen("export/BaseData.txt", "w");
 	if(!f) {
-		LogFile->write(EQEMuLog::Error, "Unable to open export/BaseData.txt to write, skipping.");
+		Log.Out(Logs::General, Logs::Error, "Unable to open export/BaseData.txt to write, skipping.");
 		return;
 	}
 
-	char errbuf[MYSQL_ERRMSG_SIZE];
-	char *query = "SELECT * FROM base_data ORDER BY level, class";
-	MYSQL_RES *result;
-	MYSQL_ROW row;
-	if(db->RunQuery(query, strlen(query), errbuf, &result)) {
-		while(row = mysql_fetch_row(result)) {
+	const std::string query = "SELECT * FROM base_data ORDER BY level, class";
+	auto results = db->QueryDatabase(query);
+	if(results.Success()) {
+        for (auto row = results.begin();row != results.end();++row) {
 			std::string line;
-			unsigned int fields = mysql_num_fields(result);
-			for(unsigned int i = 0; i < fields; ++i) {
-				if(i != 0) {
+			unsigned int fields = results.ColumnCount();
+			for(unsigned int rowIndex = 0; rowIndex < fields; ++rowIndex) {
+				if(rowIndex != 0)
 					line.push_back('^');
-				}
 
-				line += row[i];
+				if(row[rowIndex] != nullptr) {
+					line += row[rowIndex];
+				}
 			}
 
 			fprintf(f, "%s\n", line.c_str());
 		}
-		mysql_free_result(result);
 	} else {
-		LogFile->write(EQEMuLog::Error, "Error in ExportBaseData query '%s' %s", query, errbuf);
 	}
 
 	fclose(f);

client_files/import/CMakeLists.txt

@@ -11,15 +11,17 @@ ADD_EXECUTABLE(import_client_files ${import_sources} ${import_headers})
 
 INSTALL(TARGETS import_client_files RUNTIME DESTINATION ${CMAKE_INSTALL_PREFIX})
 
-TARGET_LINK_LIBRARIES(import_client_files Common debug ${MySQL_LIBRARY_DEBUG} optimized ${MySQL_LIBRARY_RELEASE} ${ZLIB_LIBRARY})
+TARGET_LINK_LIBRARIES(import_client_files common ${PERF_LIBS} debug ${MySQL_LIBRARY_DEBUG} optimized ${MySQL_LIBRARY_RELEASE} ${ZLIB_LIBRARY})
 
 IF(MSVC)
 	SET_TARGET_PROPERTIES(import_client_files PROPERTIES LINK_FLAGS_RELEASE "/OPT:REF /OPT:ICF")
 	TARGET_LINK_LIBRARIES(import_client_files "Ws2_32.lib")
+	TARGET_LINK_LIBRARIES(import_client_files "rpcrt4")
 ENDIF(MSVC)
 
 IF(MINGW)
 	TARGET_LINK_LIBRARIES(import_client_files "WS2_32")
+	TARGET_LINK_LIBRARIES(import_client_files "rpcrt4")
 ENDIF(MINGW)
 
 IF(UNIX)
@@ -30,7 +32,8 @@ IF(UNIX)
 		TARGET_LINK_LIBRARIES(import_client_files "rt")
 	ENDIF(NOT DARWIN)
 	TARGET_LINK_LIBRARIES(import_client_files "pthread")
+	TARGET_LINK_LIBRARIES(import_client_files "uuid")
 	ADD_DEFINITIONS(-fPIC)
 ENDIF(UNIX)
 
-SET(EXECUTABLE_OUTPUT_PATH ${PROJECT_BINARY_DIR}/Bin)
+SET(EXECUTABLE_OUTPUT_PATH ${PROJECT_BINARY_DIR}/bin)

client_files/import/main.cpp

@@ -16,13 +16,16 @@
 	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
 
-#include "../../common/debug.h"
+#include "../../common/eqemu_logsys.h"
+#include "../../common/global_define.h"
 #include "../../common/shareddb.h"
-#include "../../common/EQEmuConfig.h"
+#include "../../common/eqemu_config.h"
 #include "../../common/platform.h"
 #include "../../common/crash.h"
 #include "../../common/rulesys.h"
-#include "../../common/StringUtil.h"
+#include "../../common/string_util.h"
+
+EQEmuLogSys Log;
 
 void ImportSpells(SharedDatabase *db);
 void ImportSkillCaps(SharedDatabase *db);
@@ -30,63 +33,77 @@ void ImportBaseData(SharedDatabase *db);
 
 int main(int argc, char **argv) {
 	RegisterExecutablePlatform(ExePlatformClientImport);
+	Log.LoadLogSettingsDefaults();
 	set_exception_handler();
-	
-	LogFile->write(EQEMuLog::Status, "Client Files Import Utility");
+
+	Log.Out(Logs::General, Logs::Status, "Client Files Import Utility");
 	if(!EQEmuConfig::LoadConfig()) {
-		LogFile->write(EQEMuLog::Error, "Unable to load configuration file.");
+		Log.Out(Logs::General, Logs::Error, "Unable to load configuration file.");
 		return 1;
 	}
 
 	const EQEmuConfig *config = EQEmuConfig::get();
-	if(!load_log_settings(config->LogSettingsFile.c_str())) {
-		LogFile->write(EQEMuLog::Error, "Warning: unable to read %s.", config->LogSettingsFile.c_str());
-	}
 
 	SharedDatabase database;
-	LogFile->write(EQEMuLog::Status, "Connecting to database...");
+	Log.Out(Logs::General, Logs::Status, "Connecting to database...");
 	if(!database.Connect(config->DatabaseHost.c_str(), config->DatabaseUsername.c_str(),
 		config->DatabasePassword.c_str(), config->DatabaseDB.c_str(), config->DatabasePort)) {
-		LogFile->write(EQEMuLog::Error, "Unable to connect to the database, cannot continue without a "
+		Log.Out(Logs::General, Logs::Error, "Unable to connect to the database, cannot continue without a "
 			"database connection");
 		return 1;
 	}
 
+	database.LoadLogSettings(Log.log_settings);
+	Log.StartFileLogs();
+
 	ImportSpells(&database);
 	ImportSkillCaps(&database);
 	ImportBaseData(&database);
+
+	Log.CloseFileLogs();
 	
 	return 0;
 }
 
 int GetSpellColumns(SharedDatabase *db) {
-	char errbuf[MYSQL_ERRMSG_SIZE];
-	char *query = "DESCRIBE spells_new";
-	MYSQL_RES *result;
-	MYSQL_ROW row;
-	int res = 0;
-	if(db->RunQuery(query, (uint32)strlen(query), errbuf, &result)) {
-		while(row = mysql_fetch_row(result)) {
-			++res;
-		}
-		mysql_free_result(result);
-	} else {
-		LogFile->write(EQEMuLog::Error, "Error in GetSpellColumns query '%s' %s", query, errbuf);
-	}
 
-	return res;
+	const std::string query = "DESCRIBE spells_new";
+	auto results = db->QueryDatabase(query);
+	if(!results.Success()) {
+        return 0;
+    }
+
+	return results.RowCount();
+}
+
+bool IsStringField(int i) {
+	switch(i)
+	{
+	case 1:
+	case 2:
+	case 3:
+	case 4:
+	case 5:
+	case 6:
+	case 7:
+	case 8:
+		return true;
+		break;
+	default:
+		return false;
+	}
 }
 
 void ImportSpells(SharedDatabase *db) {
-	LogFile->write(EQEMuLog::Status, "Importing Spells...");
+	Log.Out(Logs::General, Logs::Status, "Importing Spells...");
 	FILE *f = fopen("import/spells_us.txt", "r");
 	if(!f) {
-		LogFile->write(EQEMuLog::Error, "Unable to open import/spells_us.txt to read, skipping.");
+		Log.Out(Logs::General, Logs::Error, "Unable to open import/spells_us.txt to read, skipping.");
 		return;
 	}
 
-	std::string delete_sql = "DELETE FROM spells_new";
-	db->RunQuery(delete_sql.c_str(), (uint32)delete_sql.length());
+	std::string query = "DELETE FROM spells_new";
+	db->QueryDatabase(query);
 
 	int columns = GetSpellColumns(db);
 	int spells_imported = 0;
@@ -103,8 +120,8 @@ void ImportSpells(SharedDatabase *db) {
 		std::string escaped = ::EscapeString(buffer);
 		auto split = SplitString(escaped, '^');
 		int line_columns = (int)split.size();
+
 		std::string sql;
-		
 		if(line_columns >= columns) {
 			sql = "INSERT INTO spells_new VALUES(";
 			for(int i = 0; i < columns; ++i) {
@@ -114,7 +131,12 @@ void ImportSpells(SharedDatabase *db) {
 					sql += "'";
 				}
 
-				sql += split[i];
+				if(split[i].compare("") == 0 && !IsStringField(i)) {
+					sql += "0";
+				}
+				else {
+					sql += split[i];
+				}
 				sql += "'";
 			}
 
@@ -129,7 +151,12 @@ void ImportSpells(SharedDatabase *db) {
 					sql += "'";
 				}
 
-				sql += split[i];
+				if(split[i].compare("") == 0 && !IsStringField(i)) {
+					sql += "0";
+				} else {
+					sql += split[i];
+				}
+
 				sql += "'";
 			}
 
@@ -140,68 +167,68 @@ void ImportSpells(SharedDatabase *db) {
 			sql += ");";
 		}
 
-		db->RunQuery(sql.c_str(), (uint32)sql.length());
+		db->QueryDatabase(sql);
 
 		spells_imported++;
 		if(spells_imported % 1000 == 0) {
-			LogFile->write(EQEMuLog::Status, "%d spells imported.", spells_imported);
+			Log.Out(Logs::General, Logs::Status, "%d spells imported.", spells_imported);
 		}
 	}
 
 	if(spells_imported % 1000 != 0) {
-		LogFile->write(EQEMuLog::Status, "%d spells imported.", spells_imported);
+		Log.Out(Logs::General, Logs::Status, "%d spells imported.", spells_imported);
 	}
 
 	fclose(f);
 }
 
 void ImportSkillCaps(SharedDatabase *db) {
-	LogFile->write(EQEMuLog::Status, "Importing Skill Caps...");
+	Log.Out(Logs::General, Logs::Status, "Importing Skill Caps...");
 
 	FILE *f = fopen("import/SkillCaps.txt", "r");
 	if(!f) {
-		LogFile->write(EQEMuLog::Error, "Unable to open import/SkillCaps.txt to read, skipping.");
+		Log.Out(Logs::General, Logs::Error, "Unable to open import/SkillCaps.txt to read, skipping.");
 		return;
 	}
 
 	std::string delete_sql = "DELETE FROM skill_caps";
-	db->RunQuery(delete_sql.c_str(), (uint32)delete_sql.length());
+	db->QueryDatabase(delete_sql);
 
 	char buffer[2048];
 	while(fgets(buffer, 2048, f)) {
 		auto split = SplitString(buffer, '^');
-		
+
 		if(split.size() < 4) {
 			continue;
 		}
 
-		std::string sql;
+
 		int class_id, skill_id, level, cap;
 		class_id = atoi(split[0].c_str());
 		skill_id = atoi(split[1].c_str());
 		level = atoi(split[2].c_str());
 		cap = atoi(split[3].c_str());
 
-		StringFormat(sql, "INSERT INTO skill_caps(class, skillID, level, cap) VALUES(%d, %d, %d, %d)",
+		std::string sql = StringFormat("INSERT INTO skill_caps(class, skillID, level, cap) VALUES(%d, %d, %d, %d)",
 			class_id, skill_id, level, cap);
 
-		db->RunQuery(sql.c_str(), (uint32)sql.length());
+		db->QueryDatabase(sql);
 	}
 
 	fclose(f);
 }
 
 void ImportBaseData(SharedDatabase *db) {
-	LogFile->write(EQEMuLog::Status, "Importing Base Data...");
+	Log.Out(Logs::General, Logs::Status, "Importing Base Data...");
 
 	FILE *f = fopen("import/BaseData.txt", "r");
 	if(!f) {
-		LogFile->write(EQEMuLog::Error, "Unable to open import/BaseData.txt to read, skipping.");
+		Log.Out(Logs::General, Logs::Error, "Unable to open import/BaseData.txt to read, skipping.");
 		return;
 	}
 
 	std::string delete_sql = "DELETE FROM base_data";
-	db->RunQuery(delete_sql.c_str(), (uint32)delete_sql.length());
+	db->QueryDatabase(delete_sql);
 
 	char buffer[2048];
 	while(fgets(buffer, 2048, f)) {
@@ -226,12 +253,12 @@ void ImportBaseData(SharedDatabase *db) {
 		mana_fac = atof(split[8].c_str());
 		end_fac = atof(split[9].c_str());
 
-		StringFormat(sql, "INSERT INTO base_data(level, class, hp, mana, end, unk1, unk2, hp_fac, "
+		sql = StringFormat("INSERT INTO base_data(level, class, hp, mana, end, unk1, unk2, hp_fac, "
 			"mana_fac, end_fac) VALUES(%d, %d, %f, %f, %f, %f, %f, %f, %f, %f)",
 			level, class_id, hp, mana, end, unk1, unk2, hp_fac, mana_fac, end_fac);
 
-		db->RunQuery(sql.c_str(), (uint32)sql.length());
+		db->QueryDatabase(sql);
 	}
 
 	fclose(f);
-}
+}

common/CMakeLists.txt

@@ -1,76 +1,76 @@
 CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
 
 SET(common_sources
-	BasePacket.cpp
+	base_packet.cpp
 	classes.cpp
-	Condition.cpp
+	condition.cpp
 	crash.cpp
-	CRC16.cpp
+	crc16.cpp
 	crc32.cpp
 	database.cpp
-	dbasync.cpp
+	database_conversions.cpp
+	database_instances.cpp
 	dbcore.cpp
-	debug.cpp
 	emu_opcodes.cpp
-	EmuTCPConnection.cpp
-	EmuTCPServer.cpp
-	EQDB.cpp
-	EQDBRes.cpp
+	emu_tcp_connection.cpp
+	emu_tcp_server.cpp
+	eq_dictionary.cpp
+	eqdb.cpp
+	eqdb_res.cpp
 	eqemu_exception.cpp
-	EQEmuConfig.cpp
-	EQEMuError.cpp
-	EQPacket.cpp
-	EQStream.cpp
-	EQStreamFactory.cpp
-	EQStreamIdent.cpp
-	EQStreamProxy.cpp
+	eqemu_config.cpp
+	eqemu_logsys.cpp
+	eq_packet.cpp
+	eq_stream.cpp
+	eq_stream_factory.cpp
+	eq_stream_ident.cpp
+	eq_stream_proxy.cpp
 	eqtime.cpp
 	extprofile.cpp
 	faction.cpp
 	guild_base.cpp
 	guilds.cpp
 	ipc_mutex.cpp
-	Item.cpp
-	logsys.cpp
-	logsys_eqemu.cpp
+	item.cpp
 	md5.cpp
 	memory_mapped_file.cpp
 	misc.cpp
-	MiscFunctions.cpp
-	moremath.cpp
-	Mutex.cpp
-	opcode_map.cpp
+	misc_functions.cpp
+	mutex.cpp
+	mysql_request_result.cpp
+	mysql_request_row.cpp
 	opcodemgr.cpp
 	packet_dump.cpp
 	packet_dump_file.cpp
 	packet_functions.cpp
-	perl_EQDB.cpp
-	perl_EQDBRes.cpp
-	ProcLauncher.cpp
+	perl_eqdb.cpp
+	perl_eqdb_res.cpp
+	proc_launcher.cpp
 	ptimer.cpp
 	races.cpp
-	rdtsc.cpp
 	rulesys.cpp
 	serverinfo.cpp
 	shareddb.cpp
+	skills.cpp
 	spdat.cpp
-    StringUtil.cpp
-	StructStrategy.cpp
-	TCPConnection.cpp
-	TCPServer.cpp
+	string_util.cpp
+	struct_strategy.cpp
+	tcp_connection.cpp
+	tcp_server.cpp
 	timeoutmgr.cpp
 	timer.cpp
 	unix.cpp
+	uuid.cpp
 	worldconn.cpp
-	XMLParser.cpp
+	xml_parser.cpp
 	platform.cpp
-	patches/Client62.cpp
 	patches/patches.cpp
-	patches/SoD.cpp
-	patches/SoF.cpp
-	patches/RoF.cpp
-	patches/Titanium.cpp
-	patches/Underfoot.cpp
+	patches/sod.cpp
+	patches/sof.cpp
+	patches/rof.cpp
+	patches/rof2.cpp
+	patches/titanium.cpp
+	patches/uf.cpp
 	SocketLib/Base64.cpp
 	SocketLib/File.cpp
 	SocketLib/HttpdCookies.cpp
@@ -90,40 +90,40 @@ SET(common_sources
 )
 
 SET(common_headers
-	BasePacket.h
+	any.h
+	base_packet.h
 	base_data.h
 	bodytypes.h
-	breakdowns.h
 	classes.h
-	Condition.h
+	condition.h
 	crash.h
-	CRC16.h
+	crc16.h
 	crc32.h
+	data_verification.h
 	database.h
-	dbasync.h
 	dbcore.h
-	debug.h
 	deity.h
 	emu_opcodes.h
 	emu_oplist.h
-	EmuTCPConnection.h
-	EmuTCPServer.h
+	emu_tcp_connection.h
+	emu_tcp_server.h
 	eq_constants.h
+	eq_dictionary.h
 	eq_packet_structs.h
-	EQDB.h
-	EQDBRes.h
+	eqdb.h
+	eqdb_res.h
 	eqemu_exception.h
-	EQEmuConfig.h
-	EQEmuConfig_elements.h
-	EQEMuError.h
-	EQPacket.h
-	EQStream.h
-	EQStreamFactory.h
-	EQStreamIdent.h
-	EQStreamIntf.h
-	EQStreamLocator.h
-	EQStreamProxy.h
-	EQStreamType.h
+	eqemu_config.h
+	eqemu_config_elements.h
+	eqemu_logsys.h
+	eq_packet.h
+	eq_stream.h
+	eq_stream_factory.h
+	eq_stream_ident.h
+	eq_stream_intf.h
+	eq_stream_locator.h
+	eq_stream_proxy.h
+	eq_stream_type.h
 	eqtime.h
 	errmsg.h
 	extprofile.h
@@ -131,36 +131,36 @@ SET(common_headers
 	features.h
 	fixed_memory_hash_set.h
 	fixed_memory_variable_hash_set.h
+	global_define.h
 	guild_base.h
 	guilds.h
 	ipc_mutex.h
-	Item.h
+	item.h
 	item_fieldlist.h
 	item_struct.h
 	languages.h
 	linked_list.h
-	logsys.h
-	logtypes.h
 	loottable.h
 	mail_oplist.h
 	md5.h
 	memory_mapped_file.h
 	misc.h
-	MiscFunctions.h
-	moremath.h
-	Mutex.h
+	misc_functions.h
+	mutex.h
+	mysql_request_result.h
+	mysql_request_row.h
 	op_codes.h
 	opcode_dispatch.h
 	opcodemgr.h
 	packet_dump.h
 	packet_dump_file.h
 	packet_functions.h
-	ProcLauncher.h
-	profiler.h
+	platform.h
+	proc_launcher.h
 	ptimer.h
 	queue.h
 	races.h
-	rdtsc.h
+	random.h
 	rulesys.h
 	ruletypes.h
 	seperator.h
@@ -169,50 +169,56 @@ SET(common_headers
 	shareddb.h
 	skills.h
 	spdat.h
-    StringUtil.h
-	StructStrategy.h
-	TCPBasicServer.h
-	TCPConnection.h
-	TCPServer.h
+    string_util.h
+	struct_strategy.h
+	tcp_basic_server.h
+	tcp_connection.h
+	tcp_server.h
 	timeoutmgr.h
 	timer.h
 	types.h
 	unix.h
 	useperl.h
+	uuid.h
 	version.h
 	worldconn.h
-	XMLParser.h
-	ZoneNumbers.h
-	platform.h
-	patches/Client62.h
-	patches/Client62_itemfields.h
-	patches/Client62_ops.h
-	patches/Client62_structs.h
+	xml_parser.h
+	zone_numbers.h
 	patches/patches.h
-	patches/SoD.h
-	patches/SoD_itemfields.h
-	patches/SoD_ops.h
-	patches/SoD_structs.h
-	patches/SoF.h
-	patches/SoF_itemfields.h
-	patches/SoF_opcode_list.h
-	patches/SoF_ops.h
-	patches/SoF_structs.h
-	patches/SSDeclare.h
-	patches/SSDefine.h
-	patches/SSRegister.h
-	patches/RoF.h
-	patches/RoF_itemfields.h
-	patches/RoF_ops.h
-	patches/RoF_structs.h
-	patches/Titanium.h
-	patches/Titanium_itemfields.h
-	patches/Titanium_ops.h
-	patches/Titanium_structs.h
-	patches/Underfoot.h
-	patches/Underfoot_itemfields.h
-	patches/Underfoot_ops.h
-	patches/Underfoot_structs.h
+	patches/sod.h
+	patches/sod_constants.h
+	patches/sod_itemfields.h
+	patches/sod_ops.h
+	patches/sod_structs.h
+	patches/sof.h
+	patches/sof_constants.h
+	patches/sof_itemfields.h
+	patches/sof_opcode_list.h
+	patches/sof_ops.h
+	patches/sof_structs.h
+	patches/ss_declare.h
+	patches/ss_define.h
+	patches/ss_register.h
+	patches/rof.h
+	patches/rof_constants.h
+	patches/rof_itemfields.h
+	patches/rof_ops.h
+	patches/rof_structs.h
+	patches/rof2.h
+	patches/rof2_constants.h
+	patches/rof2_itemfields.h
+	patches/rof2_ops.h
+	patches/rof2_structs.h
+	patches/titanium.h
+	patches/titanium_constants.h
+	patches/titanium_itemfields.h
+	patches/titanium_ops.h
+	patches/titanium_structs.h
+	patches/uf.h
+	patches/uf_constants.h
+	patches/uf_itemfields.h
+	patches/uf_ops.h
+	patches/uf_structs.h
 	SocketLib/Base64.h
 	SocketLib/File.h
 	SocketLib/HttpdCookies.h
@@ -231,42 +237,48 @@ SET(common_headers
 )
 
 SOURCE_GROUP(Patches FILES
-	patches/Client62.h
-	patches/Client62_itemfields.h
-	patches/Client62_ops.h
-	patches/Client62_structs.h
 	patches/patches.h
-	patches/SoD.h
-	patches/SoD_itemfields.h
-	patches/SoD_ops.h
-	patches/SoD_structs.h
-	patches/SoF.h
-	patches/SoF_itemfields.h
-	patches/SoF_opcode_list.h
-	patches/SoF_ops.h
-	patches/SoF_structs.h
-	patches/SSDeclare.h
-	patches/SSDefine.h
-	patches/SSRegister.h
-	patches/RoF.h
-	patches/RoF_itemfields.h
-	patches/RoF_ops.h
-	patches/RoF_structs.h
-	patches/Titanium.h
-	patches/Titanium_itemfields.h
-	patches/Titanium_ops.h
-	patches/Titanium_structs.h
-	patches/Underfoot.h
-	patches/Underfoot_itemfields.h
-	patches/Underfoot_ops.h
-	patches/Underfoot_structs.h
-	patches/Client62.cpp
+	patches/sod.h
+	patches/sod_itemfields.h
+	patches/sod_ops.h
+	patches/sod_constants.h
+	patches/sod_structs.h
+	patches/sof.h
+	patches/sof_itemfields.h
+	patches/sof_opcode_list.h
+	patches/sof_ops.h
+	patches/sof_constants.h
+	patches/sof_structs.h
+	patches/ss_declare.h
+	patches/ss_define.h
+	patches/ss_register.h
+	patches/rof.h
+	patches/rof_itemfields.h
+	patches/rof_ops.h
+	patches/rof_constants.h
+	patches/rof_structs.h
+	patches/rof2.h
+	patches/rof2_itemfields.h
+	patches/rof2_ops.h
+	patches/rof2_constants.h
+	patches/rof2_structs.h
+	patches/titanium.h
+	patches/titanium_itemfields.h
+	patches/titanium_ops.h
+	patches/titanium_constants.h
+	patches/titanium_structs.h
+	patches/uf.h
+	patches/uf_itemfields.h
+	patches/uf_ops.h
+	patches/uf_constants.h
+	patches/uf_structs.h
 	patches/patches.cpp
-	patches/SoD.cpp
-	patches/SoF.cpp
-	patches/RoF.cpp
-	patches/Titanium.cpp
-	patches/Underfoot.cpp
+	patches/sod.cpp
+	patches/sof.cpp
+	patches/rof.cpp
+	patches/rof2.cpp
+	patches/titanium.cpp
+	patches/uf.cpp
 )
 
 SOURCE_GROUP(SocketLib FILES
@@ -311,11 +323,13 @@ SOURCE_GROUP(TinyXML FILES
 
 INCLUDE_DIRECTORIES(Patches SocketLib StackWalker TinyXML)
 
-ADD_LIBRARY(Common ${common_sources} ${common_headers})
+ADD_LIBRARY(common ${common_sources} ${common_headers})
 
 IF(UNIX)
 	ADD_DEFINITIONS(-fPIC)
-	SET_SOURCE_FILES_PROPERTIES("patches/SoD.cpp" "patches/SoF.cpp" "patches/RoF.cpp" "patches/Underfoot.cpp" PROPERTIES COMPILE_FLAGS -O0)
+	SET_SOURCE_FILES_PROPERTIES("SocketLib/Mime.cpp" PROPERTY COMPILE_FLAGS -Wno-unused-result)
+	SET_SOURCE_FILES_PROPERTIES("patches/sod.cpp" "patches/sof.cpp" "patches/rof.cpp"  "patches/rof2.cpp" "patches/uf.cpp" PROPERTIES COMPILE_FLAGS -O0)
 ENDIF(UNIX)
 
-SET(LIBRARY_OUTPUT_PATH ${PROJECT_BINARY_DIR}/Bin)
+
+SET(LIBRARY_OUTPUT_PATH ${PROJECT_BINARY_DIR}/bin)

common/EQEMuError.cpp

@@ -1,135 +0,0 @@
-/*	EQEMu: Everquest Server Emulator
-	Copyright (C) 2001-2006 EQEMu Development Team (http://eqemulator.net)
-
-	This program 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; version 2 of the License.
-
-	This program is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY except by those people which sell it, which
-	are required to give you total support for your newly bought product;
-	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 this program; if not, write to the Free Software
-	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-*/
-#ifdef _WINDOWS
-#include <windows.h>
-#endif
-#include "EQEMuError.h"
-#include "linked_list.h"
-#include "Mutex.h"
-#include "MiscFunctions.h"
-#include <stdio.h>
-#include <string.h>
-#ifdef _WINDOWS
-	#include <conio.h>
-#endif
-
-void UpdateWindowTitle(char* iNewTitle = 0);
-void CatchSignal(int sig_num);
-
-const char* EQEMuErrorText[EQEMuError_MaxErrorID] = { "ErrorID# 0, No Error",
-	"MySQL Error #1405 or #2001 means your mysql server rejected the username and password you presented it.",
-	"MySQL Error #2003 means you were unable to connect to the mysql server.",
-	"MySQL Error #2005 means you there are too many connections on the mysql server. The server is overloaded.",
-	"MySQL Error #2007 means you the server is out of memory. The server is overloaded.",
-	};
-
-LinkedList<char*>* EQEMuErrorList;
-Mutex* MEQEMuErrorList;
-AutoDelete< LinkedList<char*> > ADEQEMuErrorList(&EQEMuErrorList);
-AutoDelete<Mutex> ADMEQEMuErrorList(&MEQEMuErrorList);
-
-const char* GetErrorText(uint32 iError) {
-	if (iError >= EQEMuError_MaxErrorID)
-		return "ErrorID# out of range";
-	else
-		return EQEMuErrorText[iError];
-}
-
-void AddEQEMuError(eEQEMuError iError, bool iExitNow) {
-	if (!iError)
-		return;
-	if (!EQEMuErrorList) {
-		EQEMuErrorList = new LinkedList<char*>;
-		MEQEMuErrorList = new Mutex;
-	}
-	LockMutex lock(MEQEMuErrorList);
-
-	LinkedListIterator<char*> iterator(*EQEMuErrorList);
-	iterator.Reset();
-	while (iterator.MoreElements()) {
-		if (iterator.GetData()[0] == 1) {
-//Umm... this gets a big WTF...
-//			if (*((uint32*) iterator.GetData()[1]) == iError)
-//not sure whats going on, using a character as a pointer....
-			if (*((eEQEMuError*) &(iterator.GetData()[1])) == iError)
-				return;
-		}
-		iterator.Advance();
-	}
-
-	char* tmp = new char[6];
-	tmp[0] = 1;
-	tmp[5] = 0;
-	*((uint32*) &tmp[1]) = iError;
-	EQEMuErrorList->Append(tmp);
-
-	if (iExitNow)
-		CatchSignal(2);
-}
-
-void AddEQEMuError(char* iError, bool iExitNow) {
-	if (!iError)
-		return;
-	if (!EQEMuErrorList) {
-		EQEMuErrorList = new LinkedList<char*>;
-		MEQEMuErrorList = new Mutex;
-	}
-	LockMutex lock(MEQEMuErrorList);
-	char* tmp = strcpy(new char[strlen(iError) + 1], iError);
-	EQEMuErrorList->Append(tmp);
-
-	if (iExitNow)
-		CatchSignal(2);
-}
-
-uint32 CheckEQEMuError() {
-	if (!EQEMuErrorList)
-		return 0;
-	uint32 ret = 0;
-	char* tmp = 0;
-	bool HeaderPrinted = false;
-	LockMutex lock(MEQEMuErrorList);
-
-	while ((tmp = EQEMuErrorList->Pop() )) {
-		if (!HeaderPrinted) {
-			fprintf(stdout, "===============================\nRuntime errors:\n\n");
-			HeaderPrinted = true;
-		}
-		if (tmp[0] == 1) {
-			fprintf(stdout, "%s\n", GetErrorText(*((uint32*) &tmp[1])));
-			fprintf(stdout, "For more information on this error, visit http://www.eqemu.net/eqemuerror.php?id=%u\n\n", *((uint32*) &tmp[1]));
-		}
-		else {
-			fprintf(stdout, "%s\n\n", tmp);
-		}
-		safe_delete(tmp);
-		ret++;
-	}
-	return ret;
-}
-
-void CheckEQEMuErrorAndPause() {
-#ifdef _WINDOWS
-	if (CheckEQEMuError()) {
-		fprintf(stdout, "Hit any key to exit\n");
-		UpdateWindowTitle("Error");
-		getch();
-	}
-#endif
-}
-

common/EQEmuConfig.cpp

@@ -1,448 +0,0 @@
-/*	EQEMu: Everquest Server Emulator
-	Copyright (C) 2001-2006 EQEMu Development Team (http://eqemulator.net)
-
-	This program 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; version 2 of the License.
-
-	This program is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY except by those people which sell it, which
-	are required to give you total support for your newly bought product;
-	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 this program; if not, write to the Free Software
-	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-*/
-#include "../common/debug.h"
-#include "EQEmuConfig.h"
-#include "MiscFunctions.h"
-#include <iostream>
-#include <sstream>
-
-std::string EQEmuConfig::ConfigFile = "eqemu_config.xml";
-EQEmuConfig *EQEmuConfig::_config = nullptr;
-
-void EQEmuConfig::do_world(TiXmlElement *ele) {
-	const char *text;
-	TiXmlElement * sub_ele;;
-
-	text= ParseTextBlock(ele,"shortname");
-	if (text)
-		ShortName=text;
-
-	text = ParseTextBlock(ele,"longname");
-	if (text)
-		LongName=text;
-
-	text = ParseTextBlock(ele,"address",true);
-	if (text)
-		WorldAddress=text;
-
-	text = ParseTextBlock(ele,"localaddress",true);
-	if (text)
-		LocalAddress=text;
-
-	text = ParseTextBlock(ele,"maxclients",true);
-	if (text)
-		MaxClients=atoi(text);
-
-	// Get the <key> element
-	text = ParseTextBlock(ele,"key",true);
-	if (text)
-		SharedKey=text;
-
-	// Get the <loginserver> element
-	sub_ele = ele->FirstChildElement("loginserver");
-	if (sub_ele) {
-		text=ParseTextBlock(sub_ele,"host",true);
-		if (text)
-			LoginHost=text;
-
-		text=ParseTextBlock(sub_ele,"port",true);
-		if (text)
-			LoginPort=atoi(text);
-
-		text=ParseTextBlock(sub_ele,"account",true);
-		if (text)
-			LoginAccount=text;
-
-		text=ParseTextBlock(sub_ele,"password",true);
-		if (text)
-			LoginPassword=text;
-	} else {
-		char	str[32];
-		do {
-			sprintf(str, "loginserver%i", ++LoginCount);
-			sub_ele = ele->FirstChildElement(str);
-			if (sub_ele) {
-				LoginConfig* loginconfig = new LoginConfig;
-				text=ParseTextBlock(sub_ele,"host",true);
-				if (text)
-					loginconfig->LoginHost=text;
-
-				text=ParseTextBlock(sub_ele,"port",true);
-				if (text)
-					loginconfig->LoginPort=atoi(text);
-
-				text=ParseTextBlock(sub_ele,"account",true);
-				if (text)
-					loginconfig->LoginAccount=text;
-
-				text=ParseTextBlock(sub_ele,"password",true);
-				if (text)
-					loginconfig->LoginPassword=text;
-				loginlist.Insert(loginconfig);
-			}
-		} while(sub_ele);
-	}
-
-	// Check for locked
-	sub_ele = ele->FirstChildElement("locked");
-	if (sub_ele != nullptr)
-		Locked=true;
-
-	// Get the <tcp> element
-	sub_ele = ele->FirstChildElement("tcp");
-	if(sub_ele != nullptr) {
-
-		text = sub_ele->Attribute("ip");
-		if (text)
-			WorldIP=text;
-
-		text = sub_ele->Attribute("port");
-		if (text)
-			WorldTCPPort=atoi(text);
-
-		text = sub_ele->Attribute("telnet");
-		if (text && !strcasecmp(text,"enabled"))
-			TelnetEnabled=true;
-
-	}
-
-	// Get the <http> element
-	sub_ele = ele->FirstChildElement("http");
-	if(sub_ele != nullptr) {
-
-//		text = sub_ele->Attribute("ip");
-//		if (text)
-//			WorldIP=text;
-
-		text = sub_ele->Attribute("mimefile");
-		if (text)
-			WorldHTTPMimeFile=text;
-
-		text = sub_ele->Attribute("port");
-		if (text)
-			WorldHTTPPort=atoi(text);
-
-		text = sub_ele->Attribute("enabled");
-		if (text && !strcasecmp(text,"true"))
-			WorldHTTPEnabled=true;
-
-	}
-}
-
-void EQEmuConfig::do_chatserver(TiXmlElement *ele) {
-	const char *text;
-
-	text=ParseTextBlock(ele,"host",true);
-	if (text)
-		ChatHost=text;
-
-	text=ParseTextBlock(ele,"port",true);
-	if (text)
-		ChatPort=atoi(text);
-}
-
-void EQEmuConfig::do_mailserver(TiXmlElement *ele) {
-	const char *text;
-
-	text=ParseTextBlock(ele,"host",true);
-	if (text)
-		MailHost=text;
-
-	text=ParseTextBlock(ele,"port",true);
-	if (text)
-		MailPort=atoi(text);
-}
-
-void EQEmuConfig::do_database(TiXmlElement *ele) {
-	const char *text;
-
-	text=ParseTextBlock(ele,"host",true);
-	if (text)
-		DatabaseHost=text;
-
-	text=ParseTextBlock(ele,"port",true);
-	if (text)
-		DatabasePort=atoi(text);
-
-	text=ParseTextBlock(ele,"username",true);
-	if (text)
-		DatabaseUsername=text;
-
-	text=ParseTextBlock(ele,"password",true);
-	if (text)
-		DatabasePassword=text;
-
-	text=ParseTextBlock(ele,"db",true);
-	if (text)
-		DatabaseDB=text;
-}
-
-
-void EQEmuConfig::do_qsdatabase(TiXmlElement *ele) {
-	const char *text;
-
-	text=ParseTextBlock(ele,"host",true);
-	if (text)
-		QSDatabaseHost=text;
-
-	text=ParseTextBlock(ele,"port",true);
-	if (text)
-		QSDatabasePort=atoi(text);
-
-	text=ParseTextBlock(ele,"username",true);
-	if (text)
-		QSDatabaseUsername=text;
-
-	text=ParseTextBlock(ele,"password",true);
-	if (text)
-		QSDatabasePassword=text;
-
-	text=ParseTextBlock(ele,"db",true);
-	if (text)
-		QSDatabaseDB=text;
-}
-
-void EQEmuConfig::do_zones(TiXmlElement *ele) {
-	const char *text;
-	TiXmlElement *sub_ele;
-//	TiXmlNode *node,*sub_node;
-
-	text=ParseTextBlock(ele,"defaultstatus",true);
-	if (text)
-		DefaultStatus=atoi(text);
-
-	// Get the <ports> element
-	sub_ele = ele->FirstChildElement("ports");
-	if(sub_ele != nullptr) {
-
-		text = sub_ele->Attribute("low");
-		if (text)
-			ZonePortLow=atoi(text);;
-
-		text = sub_ele->Attribute("high");
-		if (text)
-			ZonePortHigh=atoi(text);
-	}
-}
-
-void EQEmuConfig::do_files(TiXmlElement *ele) {
-	const char *text;
-
-	text=ParseTextBlock(ele,"spells",true);
-	if (text)
-		SpellsFile=text;
-
-	text=ParseTextBlock(ele,"opcodes",true);
-	if (text)
-		OpCodesFile=text;
-
-	text=ParseTextBlock(ele,"logsettings",true);
-	if (text)
-		LogSettingsFile=text;
-
-	text=ParseTextBlock(ele,"eqtime",true);
-	if (text)
-		EQTimeFile=text;
-}
-
-void EQEmuConfig::do_directories(TiXmlElement *ele) {
-	const char *text;
-
-	text=ParseTextBlock(ele,"maps",true);
-	if (text)
-		MapDir=text;
-
-	text=ParseTextBlock(ele,"quests",true);
-	if (text)
-		QuestDir=text;
-
-	text=ParseTextBlock(ele,"plugins",true);
-	if (text)
-		PluginDir=text;
-
-}
-
-void EQEmuConfig::do_launcher(TiXmlElement *ele) {
-	const char *text;
-	TiXmlElement *sub_ele;
-
-	text=ParseTextBlock(ele,"logprefix",true);
-	if (text)
-		LogPrefix = text;
-
-	text=ParseTextBlock(ele,"logsuffix",true);
-	if (text)
-		LogSuffix = text;
-
-	// Get the <exe> element
-	text = ParseTextBlock(ele,"exe",true);
-	if (text)
-		ZoneExe = text;
-
-	// Get the <timers> element
-	sub_ele = ele->FirstChildElement("timers");
-	if(sub_ele != nullptr) {
-		text = sub_ele->Attribute("restart");
-		if (text)
-			RestartWait = atoi(text);
-
-		text = sub_ele->Attribute("reterminate");
-		if (text)
-			TerminateWait = atoi(text);
-
-		text = sub_ele->Attribute("initial");
-		if (text)
-			InitialBootWait = atoi(text);
-
-		text = sub_ele->Attribute("interval");
-		if (text)
-			ZoneBootInterval = atoi(text);
-	}
-}
-
-std::string EQEmuConfig::GetByName(const std::string &var_name) const {
-	if(var_name == "ShortName")
-		return(ShortName);
-	if(var_name == "LongName")
-		return(LongName);
-	if(var_name == "WorldAddress")
-		return(WorldAddress);
-	if(var_name == "LoginHost")
-		return(LoginHost);
-	if(var_name == "LoginAccount")
-		return(LoginAccount);
-	if(var_name == "LoginPassword")
-		return(LoginPassword);
-	if(var_name == "LoginPort")
-		return(itoa(LoginPort));
-	if(var_name == "Locked")
-		return(Locked?"true":"false");
-	if(var_name == "WorldTCPPort")
-		return(itoa(WorldTCPPort));
-	if(var_name == "WorldIP")
-		return(WorldIP);
-	if(var_name == "TelnetEnabled")
-		return(TelnetEnabled?"true":"false");
-	if(var_name == "WorldHTTPPort")
-		return(itoa(WorldHTTPPort));
-	if(var_name == "WorldHTTPMimeFile")
-		return(WorldHTTPMimeFile);
-	if(var_name == "WorldHTTPEnabled")
-		return(WorldHTTPEnabled?"true":"false");
-	if(var_name == "ChatHost")
-		return(ChatHost);
-	if(var_name == "ChatPort")
-		return(itoa(ChatPort));
-	if(var_name == "MailHost")
-		return(MailHost);
-	if(var_name == "MailPort")
-		return(itoa(MailPort));
-	if(var_name == "DatabaseHost")
-		return(DatabaseHost);
-	if(var_name == "DatabaseUsername")
-		return(DatabaseUsername);
-	if(var_name == "DatabasePassword")
-		return(DatabasePassword);
-	if(var_name == "DatabaseDB")
-		return(DatabaseDB);
-	if(var_name == "DatabasePort")
-		return(itoa(DatabasePort));
-	if(var_name == "QSDatabaseHost")
-		return(QSDatabaseHost);
-	if(var_name == "QSDatabaseUsername")
-		return(QSDatabaseUsername);
-	if(var_name == "QSDatabasePassword")
-		return(QSDatabasePassword);
-	if(var_name == "QSDatabaseDB")
-		return(QSDatabaseDB);
-	if(var_name == "QSDatabasePort")
-		return(itoa(QSDatabasePort));
-	if(var_name == "SpellsFile")
-		return(SpellsFile);
-	if(var_name == "OpCodesFile")
-		return(OpCodesFile);
-	if(var_name == "EQTimeFile")
-		return(EQTimeFile);
-	if(var_name == "LogSettingsFile")
-		return(LogSettingsFile);
-	if(var_name == "MapDir")
-		return(MapDir);
-	if(var_name == "QuestDir")
-		return(QuestDir);
-	if(var_name == "PluginDir")
-		return(PluginDir);
-	if(var_name == "LogPrefix")
-		return(LogPrefix);
-	if(var_name == "LogSuffix")
-		return(LogSuffix);
-	if(var_name == "ZoneExe")
-		return(ZoneExe);
-	if(var_name == "ZonePortLow")
-		return(itoa(ZonePortLow));
-	if(var_name == "ZonePortHigh")
-		return(itoa(ZonePortHigh));
-	if(var_name == "DefaultStatus")
-		return(itoa(DefaultStatus));
-//	if(var_name == "DynamicCount")
-//		return(itoa(DynamicCount));
-	return("");
-}
-
-void EQEmuConfig::Dump() const
-{
-	std::cout << "ShortName = " << ShortName << std::endl;
-	std::cout << "LongName = " << LongName << std::endl;
-	std::cout << "WorldAddress = " << WorldAddress << std::endl;
-	std::cout << "LoginHost = " << LoginHost << std::endl;
-	std::cout << "LoginAccount = " << LoginAccount << std::endl;
-	std::cout << "LoginPassword = " << LoginPassword << std::endl;
-	std::cout << "LoginPort = " << LoginPort << std::endl;
-	std::cout << "Locked = " << Locked << std::endl;
-	std::cout << "WorldTCPPort = " << WorldTCPPort << std::endl;
-	std::cout << "WorldIP = " << WorldIP << std::endl;
-	std::cout << "TelnetEnabled = " << TelnetEnabled << std::endl;
-	std::cout << "WorldHTTPPort = " << WorldHTTPPort << std::endl;
-	std::cout << "WorldHTTPMimeFile = " << WorldHTTPMimeFile << std::endl;
-	std::cout << "WorldHTTPEnabled = " << WorldHTTPEnabled << std::endl;
-	std::cout << "ChatHost = " << ChatHost << std::endl;
-	std::cout << "ChatPort = " << ChatPort << std::endl;
-	std::cout << "MailHost = " << MailHost << std::endl;
-	std::cout << "MailPort = " << MailPort << std::endl;
-	std::cout << "DatabaseHost = " << DatabaseHost << std::endl;
-	std::cout << "DatabaseUsername = " << DatabaseUsername << std::endl;
-	std::cout << "DatabasePassword = " << DatabasePassword << std::endl;
-	std::cout << "DatabaseDB = " << DatabaseDB << std::endl;
-	std::cout << "DatabasePort = " << DatabasePort << std::endl;
-	std::cout << "QSDatabaseHost = " << QSDatabaseHost << std::endl;
-	std::cout << "QSDatabaseUsername = " << QSDatabaseUsername << std::endl;
-	std::cout << "QSDatabasePassword = " << QSDatabasePassword << std::endl;
-	std::cout << "QSDatabaseDB = " << QSDatabaseDB << std::endl;
-	std::cout << "QSDatabasePort = " << QSDatabasePort << std::endl;
-	std::cout << "SpellsFile = " << SpellsFile << std::endl;
-	std::cout << "OpCodesFile = " << OpCodesFile << std::endl;
-	std::cout << "EQTimeFile = " << EQTimeFile << std::endl;
-	std::cout << "LogSettingsFile = " << LogSettingsFile << std::endl;
-	std::cout << "MapDir = " << MapDir << std::endl;
-	std::cout << "QuestDir = " << QuestDir << std::endl;
-	std::cout << "PluginDir = " << PluginDir << std::endl;
-	std::cout << "ZonePortLow = " << ZonePortLow << std::endl;
-	std::cout << "ZonePortHigh = " << ZonePortHigh << std::endl;
-	std::cout << "DefaultStatus = " << (int)DefaultStatus << std::endl;
-//	std::cout << "DynamicCount = " << DynamicCount << std::endl;
-}
-

common/EQEmuConfig.h

@@ -1,227 +0,0 @@
-/*	EQEMu: Everquest Server Emulator
-	Copyright (C) 2001-2006 EQEMu Development Team (http://eqemulator.net)
-
-	This program 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; version 2 of the License.
-
-	This program is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY except by those people which sell it, which
-	are required to give you total support for your newly bought product;
-	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 this program; if not, write to the Free Software
-	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-*/
-#ifndef __EQEmuConfig_H
-#define __EQEmuConfig_H
-
-#include "XMLParser.h"
-#include "linked_list.h"
-
-struct LoginConfig {
-	std::string LoginHost;
-	std::string LoginAccount;
-	std::string LoginPassword;
-	uint16 LoginPort;
-};
-
-class EQEmuConfig : public XMLParser {
-public:
-	virtual std::string GetByName(const std::string &var_name) const;
-
-	// From <world/>
-	std::string ShortName;
-	std::string LongName;
-	std::string WorldAddress;
-	std::string LocalAddress;
-	std::string LoginHost;
-	std::string LoginAccount;
-	std::string LoginPassword;
-	uint16 LoginPort;
-	uint32 LoginCount;
-	LinkedList<LoginConfig*> loginlist;
-	bool Locked;
-	uint16 WorldTCPPort;
-	std::string WorldIP;
-	bool TelnetEnabled;
-	int32 MaxClients;
-	bool WorldHTTPEnabled;
-	uint16 WorldHTTPPort;
-	std::string WorldHTTPMimeFile;
-	std::string SharedKey;
-
-	// From <chatserver/>
-	std::string ChatHost;
-	uint16 ChatPort;
-
-	// From <mailserver/>
-	std::string MailHost;
-	uint16 MailPort;
-
-	// From <database/>
-	std::string DatabaseHost;
-	std::string DatabaseUsername;
-	std::string DatabasePassword;
-	std::string DatabaseDB;
-	uint16 DatabasePort;
-
-	// From <qsdatabase> // QueryServ
-	std::string QSDatabaseHost;
-	std::string QSDatabaseUsername;
-	std::string QSDatabasePassword;
-	std::string QSDatabaseDB;
-	uint16 QSDatabasePort;
-
-	// From <files/>
-	std::string SpellsFile;
-	std::string OpCodesFile;
-	std::string EQTimeFile;
-	std::string LogSettingsFile;
-
-	// From <directories/>
-	std::string MapDir;
-	std::string QuestDir;
-	std::string PluginDir;
-
-	// From <launcher/>
-	std::string LogPrefix;
-	std::string LogSuffix;
-	std::string ZoneExe;
-	uint32 RestartWait;
-	uint32 TerminateWait;
-	uint32 InitialBootWait;
-	uint32 ZoneBootInterval;
-
-	// From <zones/>
-	uint16 ZonePortLow;
-	uint16 ZonePortHigh;
-	uint8 DefaultStatus;
-
-//	uint16 DynamicCount;
-
-//	map<string,uint16> StaticZones;
-
-protected:
-
-	static EQEmuConfig *_config;
-
-	static std::string ConfigFile;
-
-#define ELEMENT(name) \
-	void do_##name(TiXmlElement *ele);
-	#include "EQEmuConfig_elements.h"
-
-
-	EQEmuConfig() {
-		// import the needed handler prototypes
-#define ELEMENT(name) \
-		Handlers[#name]=(ElementHandler)&EQEmuConfig::do_##name;
-	#include "EQEmuConfig_elements.h"
-
-		// Set sane defaults
-
-		// Login server
-		LoginHost="eqemulator.net";
-		LoginPort=5998;
-
-		// World
-		Locked=false;
-		WorldTCPPort=9000;
-		TelnetEnabled=false;
-		WorldHTTPEnabled=false;
-		WorldHTTPPort=9080;
-		WorldHTTPMimeFile="mime.types";
-		SharedKey = "";	//blank disables authentication
-
-		// Mail
-		ChatHost="eqchat.eqemulator.net";
-		ChatPort=7778;
-
-		// Mail
-		MailHost="eqmail.eqemulator.net";
-		MailPort=7779;
-
-		// Mysql
-		DatabaseHost="localhost";
-		DatabasePort=3306;
-		DatabaseUsername="eq";
-		DatabasePassword="eq";
-		DatabaseDB="eq";
-
-		// QueryServ Database
-		QSDatabaseHost="localhost";
-		QSDatabasePort=3306;
-		QSDatabaseUsername="eq";
-		QSDatabasePassword="eq";
-		QSDatabaseDB="eq";
-
-		// Files
-		SpellsFile="spells_us.txt";
-		OpCodesFile="opcodes.conf";
-		EQTimeFile="eqtime.cfg";
-		LogSettingsFile="log.ini";
-
-		// Dirs
-		MapDir="Maps";
-		QuestDir="quests";
-		PluginDir="plugins";
-
-		// Launcher
-		LogPrefix = "logs/zone-";
-		LogSuffix = ".log";
-		RestartWait = 10000;		//milliseconds
-		TerminateWait = 10000;		//milliseconds
-		InitialBootWait = 20000;	//milliseconds
-		ZoneBootInterval = 2000;	//milliseconds
-#ifdef WIN32
-		ZoneExe = "zone.exe";
-#else
-		ZoneExe = "./zone";
-#endif
-
-		// Zones
-		ZonePortLow=7000;
-		ZonePortHigh=7999;
-		DefaultStatus=0;
-
-		// For where zones need to connect to.
-		WorldIP="127.0.0.1";
-
-		// Dynamics to start
-		//DynamicCount=5;
-
-		MaxClients=-1;
-
-		LoginCount=0;
-
-	}
-	virtual ~EQEmuConfig() {}
-
-public:
-
-	// Produce a const singleton
-	static const EQEmuConfig *get() {
-		if (_config == nullptr)
-			LoadConfig();
-		return(_config);
-	}
-
-	// Allow the use to set the conf file to be used.
-	static void SetConfigFile(std::string file) { EQEmuConfig::ConfigFile = file; }
-
-	// Load the config
-	static bool LoadConfig() {
-		if (_config != nullptr)
-			delete _config;
-		_config=new EQEmuConfig;
-
-		return _config->ParseFile(EQEmuConfig::ConfigFile.c_str(),"server");
-	}
-
-	void Dump() const;
-};
-
-#endif

common/EQNetwork.cpp

@@ -1,405 +0,0 @@
-/*	EQEMu: Everquest Server Emulator
-	Copyright (C) 2001-2002 EQEMu Development Team (http://eqemu.org)
-
-	This program 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; version 2 of the License.
-
-	This program is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY except by those people which sell it, which
-	are required to give you total support for your newly bought product;
-	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 this program; if not, write to the Free Software
-	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-*/
-/*
- * EQStream classes, by Quagmire
-*/
-
-#include "../common/debug.h"
-
-#include <iostream>
-#include <iomanip>
-#ifdef WIN32
-	#include <process.h>
-#else
-	#include <arpa/inet.h>
-	#include <unistd.h>
-	#include <sys/socket.h>
-	#include <netinet/in.h>
-	#include <fcntl.h>
-	#include <stdlib.h>
-	#include <string.h>
-	#include <pthread.h>
-	#include "../common/unix.h"
-	#define SOCKET_ERROR -1
-#endif
-#include "EQNetwork.h"
-#include "EQStream.h"
-#include "../common/packet_dump.h"
-#include "../common/packet_dump_file.h"
-#include "../common/packet_functions.h"
-#include "../common/MiscFunctions.h"
-#include "../common/crc32.h"
-#include "../common/eq_packet_structs.h"
-
-#define EQN_DEBUG			0
-#define EQN_DEBUG_Error		0
-#define EQN_DEBUG_Packet	0
-#define EQN_DEBUG_Fragment	0
-#define EQN_DEBUG_ACK		0
-#define EQN_DEBUG_Unknown	0
-#define EQN_DEBUG_NewStream	0
-#define LOG_PACKETS			0
-#define LOG_RAW_PACKETS_OUT	0
-#define LOG_RAW_PACKETS_IN	0
-//#define PRIORITYTEST
-
-template <typename type>					// LO_BYTE
-type LO_BYTE (type a) {return (a&=0xff);}
-template <typename type>					// HI_BYTE
-type HI_BYTE (type a) {return (a&=0xff00);}
-template <typename type>					// LO_WORD
-type LO_WORD (type a) {return (a&=0xffff);}
-template <typename type>					// HI_WORD
-type HI_WORD (type a) {return (a&=0xffff0000);}
-template <typename type>					// HI_LOSWAPshort
-type HI_LOSWAPshort (type a) {return (LO_BYTE(a)<<8) | (HI_BYTE(a)>>8);}
-template <typename type>					// HI_LOSWAPlong
-type HI_LOSWAPlong (type x) {return (LO_WORD(a)<<16) | (HIWORD(a)>>16);}
-
-EQStreamServer::EQStreamServer(uint16 iPort) {
-	RunLoop = false;
-	pPort = iPort;
-	pOpen = false;
-#ifdef WIN32
-	WORD version = MAKEWORD (1,1);
-	WSADATA wsadata;
-	WSAStartup (version, &wsadata);
-#endif
-	sock = 0;
-}
-
-EQStreamServer::~EQStreamServer() {
-	Close();
-	RunLoop = false;
-	MLoopRunning.lock();
-	MLoopRunning.unlock();
-#ifdef WIN32
-	WSACleanup();
-#endif
-	connection_list.clear();
-	while (!NewQueue.empty())
-		NewQueue.pop(); // they're deleted with the list, clear this queue so it doesnt try to delete them again
-}
-
-bool EQStreamServer::Open(uint16 iPort) {
-	LockMutex lock(&MOpen);
-	if (iPort && pPort != iPort) {
-		if (pOpen)
-			return false;
-		pPort = iPort;
-	}
-	if (!RunLoop) {
-		RunLoop = true;
-#ifdef WIN32
-		_beginthread(EQStreamServerLoop, 0, this);
-#else
-		pthread_t thread;
-		pthread_create(&thread, NULL, &EQStreamServerLoop, this);
-#endif
-	}
-	if (pOpen) {
-		return true;
-	}
-	else {
-		struct sockaddr_in address;
-//		int reuse_addr = 1;
-		int bufsize = 64 * 1024; // 64kbyte send/recieve buffers, up from default of 8k
-#ifdef WIN32
-		unsigned long nonblocking = 1;
-#endif
-
-		/* Setup internet address information.
-		This is used with the bind() call */
-		memset((char *) &address, 0, sizeof(address));
-		address.sin_family = AF_INET;
-		address.sin_port = htons(pPort);
-		address.sin_addr.s_addr = htonl(INADDR_ANY);
-
-		/* Setting up UDP port for new clients */
-		sock = socket(AF_INET, SOCK_DGRAM, 0);
-		if (sock < 0) {
-			return false;
-		}
-
-//#ifdef WIN32
-//		setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char *) &reuse_addr, sizeof(reuse_addr));
-		setsockopt(sock, SOL_SOCKET, SO_RCVBUF, (char*) &bufsize, sizeof(bufsize));
-		setsockopt(sock, SOL_SOCKET, SO_SNDBUF, (char*) &bufsize, sizeof(bufsize));
-//#else
-//		setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &reuse_addr, sizeof(reuse_addr));
-//		setsockopt(sock, SOL_SOCKET, SO_RCVBUF, &bufsize, sizeof(bufsize));
-//		setsockopt(sock, SOL_SOCKET, SO_SNDBUF, &bufsize, sizeof(bufsize));
-//#endif
-
-		if (bind(sock, (struct sockaddr *) &address, sizeof(address)) < 0) {
-#ifdef WIN32
-			closesocket(sock);
-#else
-			close(sock);
-#endif
-			return false;
-		}
-
-#ifdef WIN32
-		ioctlsocket (sock, FIONBIO, &nonblocking);
-#else
-		fcntl(sock, F_SETFL, O_NONBLOCK);
-#endif
-		pOpen = true;
-		return true;
-	}
-}
-
-void EQStreamServer::Close() {
-	SetOpen(false);
-	if (sock) {
-#ifdef WIN32
-		closesocket(sock);
-#else
-		close(sock);
-#endif
-	}
-	sock = 0;
-}
-
-bool EQStreamServer::IsOpen() {
-	MOpen.lock();
-	bool ret = pOpen;
-	MOpen.unlock();
-	return ret;
-}
-
-void EQStreamServer::SetOpen(bool iOpen) {
-	MOpen.lock();
-	pOpen = iOpen;
-	MOpen.unlock();
-}
-
-void EQStreamServer::Process() {
-	_CP(EQStreamServer_Process);
-	if (!IsOpen()) {
-		if (sock) {
-#ifdef WIN32
-			closesocket(sock);
-#else
-			close(sock);
-#endif
-			sock = 0;
-		}
-		return;
-	}
-
-	uchar		buffer[1518];
-
-	int			status;
-	struct sockaddr_in	from;
-	unsigned int	fromlen;
-
-	from.sin_family = AF_INET;
-	fromlen = sizeof(from);
-
-	while (1) {
-#ifdef WIN32
-		status = recvfrom(sock, (char *) buffer, sizeof(buffer), 0,(struct sockaddr*) &from, (int *) &fromlen);
-#else
-		status = recvfrom(sock, buffer, sizeof(buffer), 0,(struct sockaddr*) &from, &fromlen);
-#endif
-		if (status >= 1) {
-			cout << "Got data from recvfrom" << endl;
-			RecvData(buffer, status, from.sin_addr.s_addr, from.sin_port);
-		}
-		else {
-			break;
-		}
-	}
-
-	std::map <std::string, EQStream*>::iterator connection;
-	for (connection = connection_list.begin(); connection != connection_list.end();) {
-		if (!connection->second) {
-			connection = connection_list.erase(connection);
-			continue;
-		}
-		EQStream* eqs_data = connection->second;
-		if (eqs_data->IsFree() && (!eqs_data->CheckNetActive())) {
-			safe_delete(eqs_data);
-			connection = connection_list.erase(connection);
-		} else if (!eqs_data->RunLoop) {
-			eqs_data->Process(sock);
-			++connection;
-		}
-	}
-}
-
-void EQStreamServer::RecvData(uchar* data, uint32 size, uint32 irIP, uint16 irPort) {
-/*
-	CHANGE HISTORY
-
-	Version		Author		Date		Comment
-	1			Unknown		Unknown		Initial Revision
-	2			Joolz		05-Jan-2003	Optimised
-	3			Quagmire	05-Feb-2003	Changed so 2 connection objects wouldnt be created for the same ip/port pair, often happened
-*/
-
-	// Check for invalid data
-	if (!data || size <= 4) return;
-	//if (CRC32::Generate(data, size-4) != ntohl(*((uint32*) &data[size-4]))) {
-#if EQN_DEBUG_Error >= 1
-		//cout << "Incomming Packet failed checksum" << endl;
-#endif
-		//return;
-	//}
-
-	char temp[25];
-	sprintf(temp,"%lu:%u",(unsigned long)irIP,irPort);
-	cout << "Data from " << temp << endl;
-	EQStream* tmp = NULL;
-	std::map <std::string, EQStream*>::iterator connection;
-	if ((connection=connection_list.find(temp))!=connection_list.end())
-		tmp=connection->second;
-	if(tmp != NULL && tmp->GetrPort() == irPort)
-	{
-		tmp->RecvData(data, size);
-		return;
-	}
-	else if(tmp != NULL && tmp->GetrPort() != irPort)
-	{
-		printf("Conflicting IPs & Ports: IP %i and Port %i is conflicting with IP %i and Port %i\n",irIP,irPort,tmp->GetrIP(),tmp->GetrPort());
-		return;
-	}
-
-	if (data[1]==0x01) {
-		cout << "New EQStream Connection." << endl;
-		EQStream* tmp = new EQStream(irIP, irPort);
-		tmp->RecvData(data, size);
-		connection_list[temp]=tmp;
-		if (connection_list.find(temp)==connection_list.end()) {
-			cerr <<"Could not find new connection we just added!" << endl;
-		}
-		MNewQueue.lock();
-		NewQueue.push(tmp);
-		MNewQueue.unlock();
-		return;
-	}
-#if EQN_DEBUG >= 4
-	struct in_addr	in;
-	in.s_addr = irIP;
-	cout << "WARNING: Stray packet? " << inet_ntoa(in) << ":" << irPort << endl;
-#endif
-}
-
-EQStream* EQStreamServer::NewQueuePop() {
-	EQStream* ret = 0;
-	MNewQueue.lock();
-	if (!NewQueue.empty()) {
-		ret = NewQueue.front();
-		NewQueue.pop();
-	}
-	MNewQueue.unlock();
-	return ret;
-}
-
-#ifdef WIN32
-	void EQStreamServerLoop(void* tmp)
-#else
-	void* EQStreamServerLoop(void* tmp)
-#endif
-{
-#ifdef WIN32
-	SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_ABOVE_NORMAL);
-#endif
-	EQStreamServer* eqns = (EQStreamServer*) tmp;
-	eqns->MLoopRunning.lock();
-	while (eqns->RunLoop) {
-		{
-			_CP(EQStreamServerLoop);
-			eqns->Process();
-		}
-		Sleep(1);
-	}
-	eqns->MLoopRunning.unlock();
-#ifdef WIN32
-	_endthread();
-#else
-	return 0;
-#endif
-}
-
-#ifdef WIN32
-	void EQStreamInLoop(void* tmp)
-#else
-	void* EQStreamInLoop(void* tmp)
-#endif
-{
-	EQStream* eqs = (EQStream*) tmp;
-#ifdef _DEBUG
-	if (eqs->ConnectionType != Outgoing) {
-		ThrowError("EQStreamInLoop: eqs->ConnectionType != Outgoing");
-	}
-#endif
-	eqs->MLoopRunning.lock();
-	Timer* tmp_timer = new Timer(100);
-	tmp_timer->Start();
-	while (eqs->RunLoop) {
-		{
-			_CP(EQStreamInLoop);
-			if(tmp_timer->Check())
-				eqs->DoRecvData();
-		}
-		Sleep(1);
-	}
-	safe_delete(tmp_timer);
-	eqs->MLoopRunning.unlock();
-#ifdef WIN32
-	_endthread();
-#else
-	return 0;
-#endif
-}
-
-#ifdef WIN32
-	void EQStreamOutLoop(void* tmp)
-#else
-	void* EQStreamOutLoop(void* tmp)
-#endif
-{
-	EQStream* eqs = (EQStream*) tmp;
-#ifdef _DEBUG
-	if (eqs->ConnectionType != Outgoing) {
-		ThrowError("EQStreamOutLoop: eqs->ConnectionType != Outgoing");
-	}
-#endif
-	eqs->MLoopRunning.lock();
-	Timer* tmp_timer = new Timer(100);
-	tmp_timer->Start();
-	while (eqs->RunLoop) {
-		{
-			_CP(EQStreamOutLoop);
-			if(tmp_timer->Check())
-				eqs->Process(eqs->outsock);
-		}
-		Sleep(1);
-	}
-	safe_delete(tmp_timer);
-	eqs->MLoopRunning.unlock();
-#ifdef WIN32
-	_endthread();
-#else
-	return 0;
-#endif
-}
-

common/EQNetwork.h

@@ -1,120 +0,0 @@
-/*	EQEMu: Everquest Server Emulator
-	Copyright (C) 2001-2002 EQEMu Development Team (http://eqemu.org)
-
-	This program 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; version 2 of the License.
-
-	This program is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY except by those people which sell it, which
-	are required to give you total support for your newly bought product;
-	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 this program; if not, write to the Free Software
-	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-*/
-#ifndef EQNETWORK_H
-#define EQNETWORK_H
-
-#include "../common/debug.h"
-
-//uncomment this to enable the packet profiler. Counts the number
-//of each type of packet sent or received on a connection.
-#ifdef ZONE
-//#define PACKET_PROFILER 1
-#endif
-
-#include <string.h>
-#include <map>
-#include <list>
-#include <queue>
-
-#include "../common/types.h"
-#include "../common/timer.h"
-#include "../common/linked_list.h"
-#include "../common/queue.h"
-#include "../common/Mutex.h"
-#include "../common/packet_functions.h"
-#include "EQStream.h"
-#ifdef PACKET_PROFILER
-#include "../common/rdtsc.h"
-#endif
-
-#define EQNC_TIMEOUT	60000
-#define NAS_TIMER	100
-#define KA_TIMER	400 /* keeps the lag bar constant */
-#define MAX_HEADER_SIZE	39 // Quag: 39 is the max header + opcode + crc32 + unknowns size
-
-class EQStreamServer;
-class EQStream;
-class EQStreamPacket;
-class EQStreamFragmentGroupList;
-class EQStreamFragmentGroup;
-typedef EQStreamServer				EQNServer;
-typedef EQStream			EQNConnection;
-typedef EQStreamPacket				EQNPacket;
-typedef EQStreamFragmentGroupList	EQNFragmentGroupList;
-typedef EQStreamFragmentGroup		EQNFragmentGroup;
-
-#define	FLAG_COMPRESSED 0x1000
-#define	FLAG_COMBINED	0x2000
-#define	FLAG_ENCRYPTED	0x4000
-#define	FLAG_IMPLICIT	0x8000
-#define FLAG_ALL		0xF000
-#define StripFlags(x)	(x & ~FLAG_ALL)
-
-// Optimistic compression, used for guessing pre-alloc size on debug output
-#define BEST_COMPR_RATIO 300
-
-enum eappCompressed { appNormal, appInflated, appDeflated };
-
-#ifdef WIN32
-	void EQStreamServerLoop(void* tmp);
-	void EQStreamInLoop(void* tmp);
-	void EQStreamOutLoop(void* tmp);
-#else
-	void* EQStreamServerLoop(void* tmp);
-	void* EQStreamInLoop(void* tmp);
-	void* EQStreamOutLoop(void* tmp);
-#endif
-class EQStreamServer {
-public:
-	EQStreamServer(uint16 iPort = 0);
-	virtual ~EQStreamServer();
-
-	bool	Open(uint16 iPort = 0);			// opens the port
-	void	Close();	// closes the port
-	void	KillAll();						// kills all clients
-	inline uint16	GetPort()		{ return pPort; }
-
-	EQStream* NewQueuePop();
-protected:
-#ifdef WIN32
-	friend void EQStreamServerLoop(void* tmp);
-#else
-	friend void* EQStreamServerLoop(void* tmp);
-#endif
-	void		Process();
-	bool		IsOpen();
-	void		SetOpen(bool iOpen);
-	bool		RunLoop;
-	Mutex		MLoopRunning;
-private:
-	void		RecvData(uchar* data, uint32 size, uint32 irIP, uint16 irPort);
-#ifdef WIN32
-	SOCKET	sock;
-#else
-	int		sock;
-#endif
-	uint16	pPort;
-	bool	pOpen;
-	Mutex	MNewQueue;
-	Mutex	MOpen;
-
-	std::map<std::string,EQStream*> connection_list;
-	std::queue<EQStream *>		NewQueue;
-};
-
-#endif

common/SocketLib/HTTPSocket.cpp

@@ -40,13 +40,13 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 #ifdef _WIN32
 #pragma warning(disable:4786)
 #endif
-#include "../debug.h"
+#include "../global_define.h"
 #include <stdio.h>
 #include <string>
 #include <stdarg.h>
 #include "Parse.h"
 #include "HTTPSocket.h"
-#include "../TCPConnection.h"
+#include "../tcp_connection.h"
 #include <cstdlib>
 #include <cstring>
 

common/SocketLib/HTTPSocket.h

@@ -42,7 +42,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
 #include <map>
 #include <string>
-#include "../TCPConnection.h"
+#include "../tcp_connection.h"
 
 
 #ifdef SOCKETS_NAMESPACE

common/SocketLib/HttpdCookies.cpp

@@ -26,7 +26,7 @@ along with this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */
 
-#include "../debug.h"
+#include "../global_define.h"
 #ifdef _WIN32
 #pragma warning(disable:4786)
 #endif

common/SocketLib/HttpdSocket.cpp

@@ -28,7 +28,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 #ifdef _WIN32
 #pragma warning(disable:4786)
 #endif
-#include "../debug.h"
+#include "../global_define.h"
 #include "Utility.h"
 #include "HttpdCookies.h"
 #include "HttpdForm.h"
@@ -194,7 +194,6 @@ void HttpdSocket::OnHeaderComplete()
 
 void HttpdSocket::OnData(const char *p,size_t l)
 {
-//printf("Got %d bytes: %.*s\n", l, l, p);
 	if (m_file)
 	{
 		m_file -> fwrite(p,1,l);

common/SocketLib/MemFile.cpp

@@ -110,7 +110,6 @@ size_t MemFile::fread(char *ptr, size_t size, size_t nmemb)
 	size_t sz = size * nmemb;
 	if (p + sz < BLOCKSIZE)
 	{
-//printf("Read @ %d(%d). %d bytes. (%c)\n", m_read_ptr, p, sz, *(m_current_read -> data + p));
 		memcpy(ptr, m_current_read -> data + p, sz);
 		m_read_ptr += sz;
 	}
@@ -142,7 +141,6 @@ size_t MemFile::fwrite(const char *ptr, size_t size, size_t nmemb)
 	size_t sz = size * nmemb;
 	if (p + sz < BLOCKSIZE)
 	{
-//printf("Write @ %d(%d). %d bytes.\n", m_write_ptr, p, sz);
 		memcpy(m_current_write -> data + p, ptr, sz);
 		m_write_ptr += sz;
 	}

common/SocketLib/socket_include.h

@@ -211,7 +211,7 @@ typedef unsigned short port_t;
 #endif
 
 #ifdef _THREADSAFE_SOCKETS
-#include "Mutex.h"
+#include "mutex.h"
 #include "Lock.h"
 #endif
 

common/StackWalker/StackWalker.cpp

@@ -1128,7 +1128,6 @@ BOOL __stdcall StackWalker::myReadProcMem(
     SIZE_T st;
     BOOL bRet = ReadProcessMemory(hProcess, (LPVOID) qwBaseAddress, lpBuffer, nSize, &st);
     *lpNumberOfBytesRead = (DWORD) st;
-    //printf("ReadMemory: hProcess: %p, baseAddr: %p, buffer: %p, size: %d, read: %d, result: %d\n", hProcess, (LPVOID) qwBaseAddress, lpBuffer, nSize, (DWORD) st, (DWORD) bRet);
     return bRet;
   }
   else

common/any.h

@@ -0,0 +1,190 @@
+/*
+ *  Boost Software License - Version 1.0 - August 17th, 2003
+ *  
+ *  Permission is hereby granted, free of charge, to any person or organization
+ *  obtaining a copy of the software and accompanying documentation covered by
+ *  this license (the "Software") to use, reproduce, display, distribute,
+ *  execute, and transmit the Software, and to prepare derivative works of the
+ *  Software, and to permit third-parties to whom the Software is furnished to
+ *  do so, all subject to the following:
+ *  
+ *  The copyright notices in the Software and this entire statement, including
+ *  the above license grant, this restriction and the following disclaimer,
+ *  must be included in all copies of the Software, in whole or in part, and
+ *  all derivative works of the Software, unless such copies or derivative
+ *  works are solely in the form of machine-executable object code generated by
+ *  a source language processor.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+ *  SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+ *  FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ *  ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ *  DEALINGS IN THE SOFTWARE.
+ */
+
+// EQEmu::Any is a modified version of Boost::Any and as such retains the Boost licensing.
+
+#ifndef EQEMU_COMMON_ANY_H
+#define EQEMU_COMMON_ANY_H
+
+#include <algorithm>
+#include <typeinfo>
+
+namespace EQEmu
+{
+	class Any
+	{
+	public:
+		Any()
+			: content(nullptr) 
+		{
+		}
+
+		template<typename ValueType>
+		Any(const ValueType &value)
+			: content(new Holder<ValueType>(value))
+		{
+		}
+
+		Any(const Any &other)
+			: content(other.content ? other.content->clone() : 0)
+		{
+		}
+		
+		~Any()
+		{
+			if(content)
+				delete content;
+		}
+
+		Any& swap(Any &rhs)
+		{
+			std::swap(content, rhs.content);
+			return *this;
+		}
+
+		template<typename ValueType>
+		Any& operator=(const ValueType &rhs)
+		{
+			Any(rhs).swap(*this);
+			return *this;
+		}
+
+		Any& operator=(Any rhs)
+		{
+			rhs.swap(*this);
+			return *this;
+		}
+
+		bool empty() const
+		{
+			return !content;
+		}
+
+		const std::type_info& type() const
+		{
+			return content ? content->type() : typeid(void);
+		}
+
+		class Placeholder
+		{
+		public:
+			virtual ~Placeholder()
+			{
+			}
+
+			virtual const std::type_info& type() const = 0;
+			virtual Placeholder* clone() const = 0;
+		};
+
+
+		template<typename ValueType>
+		class Holder : public Placeholder
+		{
+		public:
+			Holder(const ValueType &value)
+				: held(value)
+			{
+			}
+
+			virtual const std::type_info& type() const
+			{
+				return typeid(ValueType);
+			}
+
+			virtual Placeholder* clone() const
+			{
+				return new Holder(held);
+			}
+
+			 ValueType held;
+
+		private:
+			Holder& operator=(const Holder&);
+		};
+
+	private:
+		template<typename ValueType>
+		friend ValueType* any_cast(Any*);
+
+		template<typename ValueType>
+		friend ValueType* unsafe_any_cast(Any*);
+
+		Placeholder* content;
+	};
+
+	class bad_any_cast : public std::bad_cast
+	{
+	public:
+		virtual const char * what() const throw()
+		{
+			return "DBI::bad_any_cast: failed conversion using DBI::any_cast";
+		}
+	};
+
+	template<typename ValueType>
+	ValueType* any_cast(Any* operand)
+	{
+		return operand && 
+			operand->type() == typeid(ValueType) ? &static_cast<Any::Holder<ValueType>*>(operand->content)->held : nullptr;
+	}
+
+	template<typename ValueType>
+	inline const ValueType* any_cast(const Any* operand)
+	{
+		return any_cast<ValueType>(const_cast<Any*>(operand));
+	}
+
+	template<typename ValueType>
+	ValueType any_cast(Any& operand)
+	{
+		typedef typename std::remove_reference<ValueType>::type nonref;
+		nonref* result = any_cast<nonref>(&operand);
+		if(!result)
+			throw bad_any_cast();
+		return *result;
+	}
+	
+	template<typename ValueType>
+	inline ValueType any_cast(const Any& operand)
+	{
+		typedef typename std::remove_reference<ValueType>::type nonref;
+		return any_cast<const nonref&>(const_cast<Any&>(operand));
+	}
+
+	template<typename ValueType>
+	inline ValueType* unsafe_any_cast(Any* operand)
+	{
+		return &static_cast<Any::Holder<ValueType>*>(operand->content)->held;
+	}
+
+	template<typename ValueType>
+	inline const ValueType* unsafe_any_cast(const Any* operand)
+	{
+		return unsafe_any_cast<ValueType>(const_cast<Any*>(operand));
+	}
+}
+
+#endif

common/base_packet.cpp

@@ -15,13 +15,12 @@
 	along with this program; if not, write to the Free Software
 	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
-#include "debug.h"
-#include "BasePacket.h"
+
+#include "global_define.h"
+#include "base_packet.h"
 #include "misc.h"
 #include "packet_dump.h"
 
-
-
 BasePacket::BasePacket(const unsigned char *buf, uint32 len)
 {
 	this->pBuffer=nullptr;

common/base_packet.h

@@ -21,7 +21,6 @@
 #include "types.h"
 #include <stdio.h>
 #include <string.h>
-#include <string>
 
 #ifdef WIN32
 	#include <time.h>

common/breakdowns.h

@@ -1,134 +0,0 @@
-/*	EQEMu: Everquest Server Emulator
-	Copyright (C) 2001-2006 EQEMu Development Team (http://eqemulator.net)
-
-	This program 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; version 2 of the License.
-
-	This program is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY except by those people which sell it, which
-	are required to give you total support for your newly bought product;
-	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 this program; if not, write to the Free Software
-	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-*/
-#ifndef BREAKDOWNS_H_
-#define BREAKDOWNS_H_
-
-#include "types.h"
-
-
-#pragma pack(1)
-struct uint16_breakdown {
-	union {
-		uint16 all;
-		struct {
-			uint8 b1;
-			uint8 b2;
-		} bytes;
-	};
-	inline uint16&	operator=(const uint16& val) { return (all=val); }
-	inline uint16*	operator&() { return &all; }
-	inline operator	uint16&() { return all; }
-	inline uint8&	b1()	{ return bytes.b1; }
-	inline uint8&	b2()	{ return bytes.b2; }
-};
-
-struct uint32_breakdown {
-	union {
-		uint32 all;
-		struct {
-			uint16 w1;
-			uint16 w2;
-		} words;
-		struct {
-			uint8 b1;
-			union {
-				struct {
-					uint8 b2;
-					uint8 b3;
-				} middle;
-				uint16 w2_3; // word bytes 2 to 3
-			};
-			uint8 b4;
-		} bytes;
-	};
-	inline uint32&	operator=(const uint32& val) { return (all=val); }
-	inline uint32*	operator&() { return &all; }
-	inline operator	uint32&() { return all; }
-
-	inline uint16&	w1()	{ return words.w1; }
-	inline uint16&	w2()	{ return words.w2; }
-	inline uint16&	w2_3()	{ return bytes.w2_3; }
-	inline uint8&	b1()	{ return bytes.b1; }
-	inline uint8&	b2()	{ return bytes.middle.b2; }
-	inline uint8&	b3()	{ return bytes.middle.b3; }
-	inline uint8&	b4()	{ return bytes.b4; }
-};
-/*
-struct uint64_breakdown {
-	union {
-		uint64	all;
-		struct {
-			uint16	w1;	// 1 2
-			uint16	w2;	// 3 4
-			uint16	w3; // 5 6
-			uint16	w4; // 7 8
-		};
-		struct {
-			uint32	dw1; // 1 4
-			uint32	dw2; // 5 6
-		};
-		struct {
-			uint8	b1;
-			union {
-				struct {
-					uint16	w2_3;
-					uint16	w4_5;
-					uint16	w6_7;
-				};
-				uint32	dw2_5;
-				struct {
-					uint8	b2;
-					union {
-						uint32	dw3_6;
-						struct {
-							uint8	b3;
-							union {
-								uint32	dw4_7;
-								struct {
-									uint8	b4;
-									uint8	b5;
-									uint8	b6;
-									uint8	b7;
-								};
-							};
-						};
-					};
-				};
-			};
-		};
-	};
-	inline uint64* operator&() { return &all; }
-	inline operator uint64&() { return all; }
-};
-*/
-#pragma pack()
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-#endif /*BREAKDOWNS_H_*/

common/classes.cpp

@@ -14,8 +14,8 @@
 	You should have received a copy of the GNU General Public License
 	along with this program; if not, write to the Free Software
 	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-*/
-#include "../common/debug.h"
+	*/
+#include "../common/global_define.h"
 #include "../common/classes.h"
 
 const char* GetEQClassName(uint8 class_, uint8 level) {
@@ -290,50 +290,3 @@ const char* GetEQClassName(uint8 class_, uint8 level) {
 	}
 }
 
-uint32 GetArrayEQClass(uint8 eqclass) {
-	switch (eqclass) {
-		case WARRIOR:
-			return WARRIOR;
-		case CLERIC:
-			return CLERIC;
-		case PALADIN:
-			return PALADIN;
-		case RANGER:
-			return RANGER;
-		case SHADOWKNIGHT:
-			return SHADOWKNIGHT;
-		case DRUID:
-			return DRUID;
-		case MONK:
-			return MONK;
-		case BARD:
-			return BARD;
-		case ROGUE:
-			return ROGUE;
-		case SHAMAN:
-			return SHAMAN;
-		case NECROMANCER:
-			return NECROMANCER;
-		case WIZARD:
-			return WIZARD;
-		case MAGICIAN:
-			return MAGICIAN;
-		case ENCHANTER:
-			return ENCHANTER;
-		case BEASTLORD:
-			return BEASTLORD;
-		case BERSERKER:
-			return BERSERKER;
-		default:
-			return 0;
-	}
-}
-
-uint8 GetEQArrayEQClass(uint8 eqclass) {
-	if (eqclass >= WARRIOR && eqclass <= BERSERKER)
-		return eqclass - WARRIOR;
-	if (eqclass >= WARRIORGM && eqclass <= BERSERKERGM)
-		return eqclass - WARRIORGM;
-	return WARRIOR;
-}
-

common/classes.h

@@ -86,7 +86,5 @@
 #define call_1 65536
 
 const char* GetEQClassName(uint8 class_, uint8 level = 0);
-uint32 GetArrayEQClass(uint8 eqclass);
-uint8 GetEQArrayEQClass(uint8 eqclass);
 #endif
 

common/clientversions.h

@@ -1,27 +1,77 @@
 #ifndef CLIENTVERSIONS_H
 #define CLIENTVERSIONS_H
 
-static const uint32 BIT_Client62 = 1;
-static const uint32 BIT_Titanium = 2;
-static const uint32 BIT_SoF = 4;
-static const uint32 BIT_SoD = 8;
-static const uint32 BIT_Underfoot = 16;
-static const uint32 BIT_RoF = 32;
-static const uint32 BIT_TitaniumAndEarlier = 3;
-static const uint32 BIT_SoFAndLater = 0xFFFFFFFC;
-static const uint32 BIT_SoDAndLater = 0xFFFFFFF8;
-static const uint32 BIT_UnderfootAndLater = 0xFFFFFFF0;
-static const uint32 BIT_RoFAndLater = 0xFFFFFFE0;
-static const uint32 BIT_AllClients = 0xFFFFFFFF;
+#include "types.h"
 
-typedef enum {
-	EQClientUnknown = 0,
-	EQClient62,
-	EQClientTitanium,
-	EQClientSoF,
-	EQClientSoD,
-	EQClientUnderfoot,
-	EQClientRoF
-} EQClientVersion;
+static const uint32 BIT_Client62	= 1;
+static const uint32 BIT_Titanium	= 2;
+static const uint32 BIT_SoF			= 4;
+static const uint32 BIT_SoD			= 8;
+static const uint32 BIT_UF			= 16;
+static const uint32 BIT_RoF			= 32;
+static const uint32 BIT_RoF2		= 64;
+
+static const uint32 BIT_TitaniumAndEarlier	= 0x00000003;
+static const uint32 BIT_SoFAndLater			= 0xFFFFFFFC;
+static const uint32 BIT_SoDAndLater			= 0xFFFFFFF8;
+static const uint32 BIT_UFAndLater			= 0xFFFFFFF0;
+static const uint32 BIT_RoFAndLater			= 0xFFFFFFE0;
+static const uint32 BIT_RoF2AndLater		= 0xFFFFFFC0;
+static const uint32 BIT_AllClients			= 0xFFFFFFFF;
+
+enum class ClientVersion
+{
+	Unknown = 0,
+	Client62,	// Build: 'Aug  4 2005 15:40:59'
+	Titanium,	// Build: 'Oct 31 2005 10:33:37'
+	SoF,		// Build: 'Sep  7 2007 09:11:49'
+	SoD,		// Build: 'Dec 19 2008 15:22:49'
+	UF,			// Build: 'Jun  8 2010 16:44:32'
+	RoF,		// Build: 'Dec 10 2012 17:35:44'
+	RoF2,		// Build: 'May 10 2013 23:30:08'
+
+	MobNPC,
+	MobMerc,
+	MobBot,
+	MobPet,
+};
+
+#define CLIENT_VERSION_COUNT 12
+#define LAST_PC_CLIENT ClientVersion::RoF2
+#define LAST_NPC_CLIENT ClientVersion::MobPet
+
+
+static const char* ClientVersionName(ClientVersion version)
+{
+	switch (version)
+	{
+	case ClientVersion::Unknown:
+		return "ClientVersion::Unknown";
+	case ClientVersion::Client62:
+		return "ClientVersion::Client62";
+	case ClientVersion::Titanium:
+		return "ClientVersion::Titanium";
+	case ClientVersion::SoF:
+		return "ClientVersion::SoF";
+	case ClientVersion::SoD:
+		return "ClientVersion::SoD";
+	case ClientVersion::UF:
+		return "ClientVersion::UF";
+	case ClientVersion::RoF:
+		return "ClientVersion::RoF";
+	case ClientVersion::RoF2:
+		return "ClientVersion::RoF2";
+	case ClientVersion::MobNPC:
+		return "ClientVersion::MobNPC";
+	case ClientVersion::MobMerc:
+		return "ClientVersion::MobMerc";
+	case ClientVersion::MobBot:
+		return "ClientVersion::MobBot";
+	case ClientVersion::MobPet:
+		return "ClientVersion::MobPet";
+	default:
+		return "<ERROR> Invalid ClientVersion";
+	};
+}
 
 #endif /* CLIENTVERSIONS_H */

common/condition.cpp

@@ -16,8 +16,7 @@
 	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
 
-#include "debug.h"
-#include "Condition.h"
+#include "condition.h"
 
 #ifdef _WINDOWS
 

common/condition.h

@@ -18,7 +18,8 @@
 #ifndef __CONDITION_H
 #define __CONDITION_H
 
-#include "debug.h"
+#include "global_define.h"
+#include "mutex.h"
 #ifndef WIN32
 #include <pthread.h>
 #endif

common/crash.cpp

@@ -1,4 +1,5 @@
-#include "debug.h"
+#include "global_define.h"
+#include "eqemu_logsys.h"
 #include "crash.h"
 
 #if defined(_WINDOWS) && defined(CRASH_LOGGING)
@@ -24,7 +25,7 @@ public:
 			}
 		}
 
-		LogFile->write(EQEMuLog::Crash, buffer);
+		Log.Out(Logs::General, Logs::Crash, buffer);
 		StackWalker::OnOutput(szText);
 	}
 };
@@ -34,67 +35,67 @@ LONG WINAPI windows_exception_handler(EXCEPTION_POINTERS *ExceptionInfo)
 	switch(ExceptionInfo->ExceptionRecord->ExceptionCode)
 	{
 		case EXCEPTION_ACCESS_VIOLATION:
-			LogFile->write(EQEMuLog::Crash, "EXCEPTION_ACCESS_VIOLATION");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_ACCESS_VIOLATION");
 			break;
 		case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
-			LogFile->write(EQEMuLog::Crash, "EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
 			break;
 		case EXCEPTION_BREAKPOINT:
-			LogFile->write(EQEMuLog::Crash, "EXCEPTION_BREAKPOINT");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_BREAKPOINT");
 			break;
 		case EXCEPTION_DATATYPE_MISALIGNMENT:
-			LogFile->write(EQEMuLog::Crash, "EXCEPTION_DATATYPE_MISALIGNMENT");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_DATATYPE_MISALIGNMENT");
 			break;
 		case EXCEPTION_FLT_DENORMAL_OPERAND:
-			LogFile->write(EQEMuLog::Crash, "EXCEPTION_FLT_DENORMAL_OPERAND");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_FLT_DENORMAL_OPERAND");
 			break;
 		case EXCEPTION_FLT_DIVIDE_BY_ZERO:
-			LogFile->write(EQEMuLog::Crash, "EXCEPTION_FLT_DIVIDE_BY_ZERO");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_FLT_DIVIDE_BY_ZERO");
 			break;
 		case EXCEPTION_FLT_INEXACT_RESULT:
-			LogFile->write(EQEMuLog::Crash, "EXCEPTION_FLT_INEXACT_RESULT");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_FLT_INEXACT_RESULT");
 			break;
 		case EXCEPTION_FLT_INVALID_OPERATION:
-			LogFile->write(EQEMuLog::Crash, "EXCEPTION_FLT_INVALID_OPERATION");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_FLT_INVALID_OPERATION");
 			break;
 		case EXCEPTION_FLT_OVERFLOW:
-			LogFile->write(EQEMuLog::Crash, "EXCEPTION_FLT_OVERFLOW");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_FLT_OVERFLOW");
 			break;
 		case EXCEPTION_FLT_STACK_CHECK:
-			LogFile->write(EQEMuLog::Crash, "EXCEPTION_FLT_STACK_CHECK");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_FLT_STACK_CHECK");
 			break;
 		case EXCEPTION_FLT_UNDERFLOW:
-			LogFile->write(EQEMuLog::Crash, "EXCEPTION_FLT_UNDERFLOW");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_FLT_UNDERFLOW");
 			break;
 		case EXCEPTION_ILLEGAL_INSTRUCTION:
-			LogFile->write(EQEMuLog::Crash, "EXCEPTION_ILLEGAL_INSTRUCTION");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_ILLEGAL_INSTRUCTION");
 			break;
 		case EXCEPTION_IN_PAGE_ERROR:
-			LogFile->write(EQEMuLog::Crash, "EXCEPTION_IN_PAGE_ERROR");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_IN_PAGE_ERROR");
 			break;
 		case EXCEPTION_INT_DIVIDE_BY_ZERO:
-			LogFile->write(EQEMuLog::Crash, "EXCEPTION_INT_DIVIDE_BY_ZERO");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_INT_DIVIDE_BY_ZERO");
 			break;
 		case EXCEPTION_INT_OVERFLOW:
-			LogFile->write(EQEMuLog::Crash, "EXCEPTION_INT_OVERFLOW");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_INT_OVERFLOW");
 			break;
 		case EXCEPTION_INVALID_DISPOSITION:
-			LogFile->write(EQEMuLog::Crash, "EXCEPTION_INVALID_DISPOSITION");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_INVALID_DISPOSITION");
 			break;
 		case EXCEPTION_NONCONTINUABLE_EXCEPTION:
-			LogFile->write(EQEMuLog::Crash, "EXCEPTION_NONCONTINUABLE_EXCEPTION");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_NONCONTINUABLE_EXCEPTION");
 			break;
 		case EXCEPTION_PRIV_INSTRUCTION:
-			LogFile->write(EQEMuLog::Crash, "EXCEPTION_PRIV_INSTRUCTION");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_PRIV_INSTRUCTION");
 			break;
 		case EXCEPTION_SINGLE_STEP:
-			LogFile->write(EQEMuLog::Crash, "EXCEPTION_SINGLE_STEP");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_SINGLE_STEP");
 			break;
 		case EXCEPTION_STACK_OVERFLOW:
-			LogFile->write(EQEMuLog::Crash, "EXCEPTION_STACK_OVERFLOW");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_STACK_OVERFLOW");
 			break;
 		default:
-			LogFile->write(EQEMuLog::Crash, "Unknown Exception");
+			Log.Out(Logs::General, Logs::Crash, "Unknown Exception");
 			break;
 	}
 

common/data_verification.h

@@ -1,5 +1,5 @@
 /*	EQEMu: Everquest Server Emulator
-	Copyright (C) 2001-2006 EQEMu Development Team (http://eqemulator.net)
+	Copyright (C) 2001-2014 EQEMu Development Team (http://eqemulator.net)
 
 	This program is free software; you can redistribute it and/or modify
 	it under the terms of the GNU General Public License as published by
@@ -15,28 +15,34 @@
 	along with this program; if not, write to the Free Software
 	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
+#ifndef COMMON_DATA_VERIFICATION_H
+#define COMMON_DATA_VERIFICATION_H
 
-#include "debug.h"
-#include "logsys.h"
-#include "StringUtil.h"
+#include <algorithm>
 
-#include <stdarg.h>
-#include <stdio.h>
+namespace EQEmu
+{
 
-#include <string>
-
-void log_message(LogType type, const char *fmt, ...) {
-	va_list args;
-	va_start(args, fmt);
-	log_messageVA(type, fmt, args);
-	va_end(args);
+template <typename T>
+T Clamp(const T& value, const T& lower, const T& upper) {
+	return std::max(lower, std::min(value, upper));
 }
 
-void log_messageVA(LogType type, const char *fmt, va_list args) {
-	std::string prefix_buffer;
-	
-	StringFormat(prefix_buffer, "[%s] ", log_type_info[type].name);
-	
-	LogFile->writePVA(EQEMuLog::Debug, prefix_buffer.c_str(), fmt, args);
+template <typename T>
+T ClampLower(const T& value, const T& lower) {
+	return std::max(lower, value);
 }
 
+template <typename T>
+T ClampUpper(const T& value, const T& upper) {
+	return std::min(value, upper);
+}
+
+template <typename T>
+bool ValueWithin(const T& value, const T& lower, const T& upper) {
+	return value >= lower && value <= upper;
+}
+
+}
+
+#endif

common/database.h

@@ -21,17 +21,14 @@
 #define AUTHENTICATION_TIMEOUT	60
 #define INVALID_ID				0xFFFFFFFF
 
-#include "debug.h"
+#include "global_define.h"
+#include "eqemu_logsys.h"
 #include "types.h"
 #include "dbcore.h"
 #include "linked_list.h"
 #include "eq_packet_structs.h"
-/*#include "EQStream.h"
-#include "guilds.h"
-#include "MiscFunctions.h"
-#include "Mutex.h"
-#include "Item.h"
-#include "extprofile.h"*/
+
+#include <cmath>
 #include <string>
 #include <vector>
 #include <map>
@@ -39,22 +36,9 @@
 //atoi is not uint32 or uint32 safe!!!!
 #define atoul(str) strtoul(str, nullptr, 10)
 
-//class Spawn;
-class Corpse;
-class Spawn2;
-class NPC;
-class SpawnGroupList;
-class Petition;
-class Client;
-class Merc;
-struct Combine_Struct;
-//struct Faction;
-//struct FactionMods;
-//struct FactionValue;
-struct ZonePoint;
-struct NPCType;
 class Inventory;
-class ItemInst;
+class MySQLRequestResult;
+class Client;
 
 struct EventLogDetails_Struct {
 	uint32	id;
@@ -69,36 +53,36 @@ struct EventLogDetails_Struct {
 };
 
 struct CharacterEventLog_Struct {
-uint32	count;
-uint8	eventid;
-EventLogDetails_Struct eld[255];
+	uint32	count;
+	uint8	eventid;
+	EventLogDetails_Struct eld[255];
 };
 
-
-// Added By Hogie
-// INSERT into variables (varname,value) values('decaytime [minlevel] [maxlevel]','[number of seconds]');
-// IE: decaytime 1 54 = Levels 1 through 54
-// decaytime 55 100 = Levels 55 through 100
-// It will always put the LAST time for the level (I think) from the Database
 struct npcDecayTimes_Struct {
 	uint16 minlvl;
 	uint16 maxlvl;
 	uint32 seconds;
 };
-// Added By Hogie -- End
+
 
 struct VarCache_Struct {
-	char varname[26];	// varname is char(25) in database
+	char varname[26];	
 	char value[0];
 };
 
-struct PlayerProfile_Struct;
-struct GuildRankLevel_Struct;
-struct GuildRanks_Struct;
-struct ExtendedProfile_Struct;
-struct GuildMember_Struct;
 class PTimerList;
 
+#ifdef _WINDOWS
+#if _MSC_VER > 1700 // greater than 2012 (2013+)
+#	define _ISNAN_(a) std::isnan(a)
+#else
+#	include <float.h>
+#	define _ISNAN_(a) _isnan(a)
+#endif
+#else
+#	define _ISNAN_(a) std::isnan(a)
+#endif
+
 class Database : public DBcore {
 public:
 	Database();
@@ -106,152 +90,166 @@ public:
 	bool Connect(const char* host, const char* user, const char* passwd, const char* database,uint32 port);
 	~Database();
 
-	/*
-	* General Character Related Stuff
-	*/
+	/* Character Creation */
+
+	bool	AddToNameFilter(const char* name);
+	bool	CreateCharacter(uint32 account_id, char* name, uint16 gender, uint16 race, uint16 class_, uint8 str, uint8 sta, uint8 cha, uint8 dex, uint8 int_, uint8 agi, uint8 wis, uint8 face);
+	bool	DeleteCharacter(char* name);
 	bool	MoveCharacterToZone(const char* charname, const char* zonename);
 	bool	MoveCharacterToZone(const char* charname, const char* zonename,uint32 zoneid);
 	bool	MoveCharacterToZone(uint32 iCharID, const char* iZonename);
-	bool	UpdateName(const char* oldname, const char* newname);
+	bool	ReserveName(uint32 account_id, char* name);
+	bool	SaveCharacterCreate(uint32 character_id, uint32 account_id, PlayerProfile_Struct* pp);
 	bool	SetHackerFlag(const char* accountname, const char* charactername, const char* hacked);
 	bool	SetMQDetectionFlag(const char* accountname, const char* charactername, const char* hacked, const char* zone);
-	bool	AddToNameFilter(const char* name);
-	bool	ReserveName(uint32 account_id, char* name);
-	bool	CreateCharacter(uint32 account_id, char* name, uint16 gender, uint16 race, uint16 class_, uint8 str, uint8 sta, uint8 cha, uint8 dex, uint8 int_, uint8 agi, uint8 wis, uint8 face);
-	bool	StoreCharacter(uint32 account_id, PlayerProfile_Struct* pp, Inventory* inv, ExtendedProfile_Struct *ext);
-	bool	DeleteCharacter(char* name);
-	uint8	CopyCharacter(const char* oldname, const char* newname, uint32 acctid);
+	bool	StoreCharacter(uint32 account_id, PlayerProfile_Struct* pp, Inventory* inv);
+	bool	UpdateName(const char* oldname, const char* newname);
 
-	/*
-	* General Information Getting Queries
-	*/
+	/* General Information Queries */
+
+	bool	AddBannedIP(char* bannedIP, const char* notes); //Add IP address to the Banned_IPs table.
+	bool	AddGMIP(char* ip_address, char* name);
+	bool	CheckBannedIPs(const char* loginIP); //Check incoming connection against banned IP table.
+	bool	CheckGMIPs(const char* loginIP, uint32 account_id);
 	bool	CheckNameFilter(const char* name, bool surname = false);
 	bool	CheckUsedName(const char* name);
+
 	uint32	GetAccountIDByChar(const char* charname, uint32* oCharID = 0);
 	uint32	GetAccountIDByChar(uint32 char_id);
 	uint32	GetAccountIDByName(const char* accname, int16* status = 0, uint32* lsid = 0);
-	uint32	GetGuildDBIDByCharID(uint32 char_id);
+	uint32	GetCharacterID(const char *name);
+	uint32	GetCharacterInfo(const char* iName, uint32* oAccID = 0, uint32* oZoneID = 0, uint32* oInstanceID = 0, float* oX = 0, float* oY = 0, float* oZ = 0);
+	uint32	GetGuildIDByCharID(uint32 char_id);
+
 	void	GetAccountName(uint32 accountid, char* name, uint32* oLSAccountID = 0);
 	void	GetCharName(uint32 char_id, char* name);
-	uint32	GetCharacterInfo(const char* iName, uint32* oAccID = 0, uint32* oZoneID = 0, uint32* oInstanceID = 0,float* oX = 0, float* oY = 0, float* oZ = 0);
-	uint32	GetCharacterID(const char *name);
-	bool	CheckBannedIPs(const char* loginIP); //Lieka Edit: Check incomming connection against banned IP table.
-	bool	AddBannedIP(char* bannedIP, const char* notes); //Lieka Edit: Add IP address to the Banned_IPs table.
-	bool	CheckGMIPs(const char* loginIP, uint32 account_id);
-	bool	AddGMIP(char* ip_address, char* name);
 	void	LoginIP(uint32 AccountID, const char* LoginIP);
 
-	/*
-	* Instancing Stuff
-	*/
-	bool VerifyZoneInstance(uint32 zone_id, uint16 instance_id);
-	bool VerifyInstanceAlive(uint16 instance_id, uint32 char_id);
-	bool CharacterInInstanceGroup(uint16 instance_id, uint32 char_id);
-	void DeleteInstance(uint16 instance_id);
-	bool CheckInstanceExpired(uint16 instance_id);
-	uint32 ZoneIDFromInstanceID(uint16 instance_id);
-	uint32 VersionFromInstanceID(uint16 instance_id);
-	uint32 GetTimeRemainingInstance(uint16 instance_id, bool &is_perma);
-	bool GetUnusedInstanceID(uint16 &instance_id);
-	bool CreateInstance(uint16 instance_id, uint32 zone_id, uint32 version, uint32 duration);
-	void PurgeExpiredInstances();
+	/* Instancing */
+
 	bool AddClientToInstance(uint16 instance_id, uint32 char_id);
+	bool CharacterInInstanceGroup(uint16 instance_id, uint32 char_id);
+	bool CheckInstanceExists(uint16 instance_id);
+	bool CheckInstanceExpired(uint16 instance_id);
+	bool CreateInstance(uint16 instance_id, uint32 zone_id, uint32 version, uint32 duration);
+	bool GetUnusedInstanceID(uint16 &instance_id);
+	bool GlobalInstance(uint16 instance_id);
 	bool RemoveClientFromInstance(uint16 instance_id, uint32 char_id);
 	bool RemoveClientsFromInstance(uint16 instance_id);
-	bool CheckInstanceExists(uint16 instance_id);
-	void BuryCorpsesInInstance(uint16 instance_id);
-	uint16 GetInstanceVersion(uint16 instance_id);
+	bool VerifyInstanceAlive(uint16 instance_id, uint32 char_id);
+	bool VerifyZoneInstance(uint32 zone_id, uint16 instance_id);
+
 	uint16 GetInstanceID(const char* zone, uint32 charid, int16 version);
 	uint16 GetInstanceID(uint32 zone, uint32 charid, int16 version);
-	void GetCharactersInInstance(uint16 instance_id, std::list<uint32> &charid_list);
+	uint16 GetInstanceVersion(uint16 instance_id);
+	uint32 GetTimeRemainingInstance(uint16 instance_id, bool &is_perma);
+	uint32 VersionFromInstanceID(uint16 instance_id);
+	uint32 ZoneIDFromInstanceID(uint16 instance_id);
+
 	void AssignGroupToInstance(uint32 gid, uint32 instance_id);
 	void AssignRaidToInstance(uint32 rid, uint32 instance_id);
+	void BuryCorpsesInInstance(uint16 instance_id);
+	void DeleteInstance(uint16 instance_id);
 	void FlagInstanceByGroupLeader(uint32 zone, int16 version, uint32 charid, uint32 gid);
 	void FlagInstanceByRaidLeader(uint32 zone, int16 version, uint32 charid, uint32 rid);
+	void GetCharactersInInstance(uint16 instance_id, std::list<uint32> &charid_list);
+	void PurgeExpiredInstances();
 	void SetInstanceDuration(uint16 instance_id, uint32 new_duration);
-	bool GlobalInstance(uint16 instance_id);
 
-	/*
-	* Adventure related.
-	*/
+	/* Adventure related. */
+
 	void UpdateAdventureStatsEntry(uint32 char_id, uint8 theme, bool win);
-	bool GetAdventureStats(uint32 char_id, uint32 &guk_w, uint32 &mir_w, uint32 &mmc_w, uint32 &ruj_w, uint32 &tak_w,
-		uint32 &guk_l, uint32 &mir_l, uint32 &mmc_l, uint32 &ruj_l, uint32 &tak_l);
+	bool GetAdventureStats(uint32 char_id, AdventureStats_Struct *as);
+
+	/* Account Related */
 
-	/*
-	* Account Related
-	*/
-	uint32	GetMiniLoginAccount(char* ip);
-	void	GetAccountFromID(uint32 id, char* oAccountName, int16* oStatus);
-	uint32	CheckLogin(const char* name, const char* password, int16* oStatus = 0);
-	int16	CheckStatus(uint32 account_id);
-	uint32	CreateAccount(const char* name, const char* password, int16 status, uint32 lsaccount_id = 0);
 	bool	DeleteAccount(const char* name);
+	bool	GetLiveChar(uint32 account_id, char* cname);
 	bool	SetAccountStatus(const char* name, int16 status);
 	bool	SetLocalPassword(uint32 accid, const char* password);
+	bool	UpdateLiveChar(char* charname, uint32 lsaccount_id);
+
+	int16	CheckStatus(uint32 account_id);
+
+	uint32	CheckLogin(const char* name, const char* password, int16* oStatus = 0);
+	uint32	CreateAccount(const char* name, const char* password, int16 status, uint32 lsaccount_id = 0);
 	uint32	GetAccountIDFromLSID(uint32 iLSID, char* oAccountName = 0, int16* oStatus = 0);
-	bool	UpdateLiveChar(char* charname,uint32 lsaccount_id);
-	bool	GetLiveChar(uint32 account_id, char* cname);
+	uint32	GetMiniLoginAccount(char* ip);
 	uint8	GetAgreementFlag(uint32 acctid);
+
+	void	GetAccountFromID(uint32 id, char* oAccountName, int16* oStatus);
 	void	SetAgreementFlag(uint32 acctid);
 
-	/*
-	* Groups
-	*/
-	uint32	GetGroupID(const char* name);
-	void	SetGroupID(const char* name, uint32 id, uint32 charid, uint32 ismerc = false);
-	void	ClearGroup(uint32 gid = 0);
+
+	/* Groups */
+	
 	char*	GetGroupLeaderForLogin(const char* name,char* leaderbuf);
-
-	void	SetGroupLeaderName(uint32 gid, const char* name);
-	char*	GetGroupLeadershipInfo(uint32 gid, char* leaderbuf, char* maintank = nullptr, char* assist = nullptr, char* puller = nullptr, char *marknpc = nullptr,
-						GroupLeadershipAA_Struct* GLAA = nullptr);
+	char*	GetGroupLeadershipInfo(uint32 gid, char* leaderbuf, char* maintank = nullptr, char* assist = nullptr, char* puller = nullptr, char *marknpc = nullptr, char *mentoree = nullptr, int *mentor_percent = nullptr, GroupLeadershipAA_Struct* GLAA = nullptr);
+	
+	uint32	GetGroupID(const char* name);
+	
+	void	ClearGroup(uint32 gid = 0);
 	void	ClearGroupLeader(uint32 gid = 0);
+	void	SetGroupID(const char* name, uint32 id, uint32 charid, uint32 ismerc = false);
+	void	SetGroupLeaderName(uint32 gid, const char* name);
+
+	/* Raids */
 
-	/*
-	* Raids
-	*/
-	void	ClearRaid(uint32 rid = 0);
-	void	ClearRaidDetails(uint32 rid = 0);
-	uint32	GetRaidID(const char* name);
 	const char *GetRaidLeaderName(uint32 rid);
 
-	/*
-	* Database Variables
-	*/
+	uint32	GetRaidID(const char* name);
+
+	void	ClearRaid(uint32 rid = 0);
+	void	ClearRaidDetails(uint32 rid = 0);
+	void	ClearRaidLeader(uint32 gid = 0xFFFFFFFF, uint32 rid = 0);
+	void	GetGroupLeadershipInfo(uint32 gid, uint32 rid, char* maintank = nullptr, char* assist = nullptr, char* puller = nullptr, char *marknpc = nullptr, char *mentoree = nullptr, int *mentor_percent = nullptr, GroupLeadershipAA_Struct* GLAA = nullptr);
+	void	GetRaidLeadershipInfo(uint32 rid, char* maintank = nullptr, char* assist = nullptr, char* puller = nullptr, char *marknpc = nullptr, RaidLeadershipAA_Struct* RLAA = nullptr);
+	void	SetRaidGroupLeaderInfo(uint32 gid, uint32 rid);
+
+	/* Database Conversions 'database_conversions.cpp' */
+
+	bool	CheckDatabaseConversions();
+	bool	CheckDatabaseConvertBotsPostPPDeblob();
+	bool	CheckDatabaseConvertCorpseDeblob();
+	bool	CheckDatabaseConvertPPDeblob();
+
+	/* Database Variables */
+
 	bool	GetVariable(const char* varname, char* varvalue, uint16 varvalue_len);
 	bool	SetVariable(const char* varname, const char* varvalue);
 	bool	LoadVariables();
 	uint32	LoadVariables_MQ(char** query);
-	bool	LoadVariables_result(MYSQL_RES* result);
+	bool	LoadVariables_result(MySQLRequestResult results);
+
+	/* General Queries */
 
-	/*
-	* General Queries
-	*/
-	bool	LoadZoneNames();
-	bool	GetZoneLongName(const char* short_name, char** long_name, char* file_name = 0, float* safe_x = 0, float* safe_y = 0, float* safe_z = 0, uint32* graveyard_id = 0, uint32* maxclients = 0);
-	bool	GetZoneGraveyard(const uint32 graveyard_id, uint32* graveyard_zoneid = 0, float* graveyard_x = 0, float* graveyard_y = 0, float* graveyard_z = 0, float* graveyard_heading = 0);
-	uint32	GetZoneGraveyardID(uint32 zone_id, uint32 version);
-	uint32	GetZoneID(const char* zonename);
-	uint8	GetPEQZone(uint32 zoneID, uint32 version);
-	const char*	GetZoneName(uint32 zoneID, bool ErrorUnknown = false);
-	uint8	GetServerType();
 	bool	GetSafePoints(const char* short_name, uint32 version, float* safe_x = 0, float* safe_y = 0, float* safe_z = 0, int16* minstatus = 0, uint8* minlevel = 0, char *flag_needed = nullptr);
 	bool	GetSafePoints(uint32 zoneID, uint32 version, float* safe_x = 0, float* safe_y = 0, float* safe_z = 0, int16* minstatus = 0, uint8* minlevel = 0, char *flag_needed = nullptr) { return GetSafePoints(GetZoneName(zoneID), version, safe_x, safe_y, safe_z, minstatus, minlevel, flag_needed); }
-	uint8	GetSkillCap(uint8 skillid, uint8 in_race, uint8 in_class, uint16 in_level);
-	uint8	GetRaceSkill(uint8 skillid, uint8 in_race);
+	bool	GetZoneGraveyard(const uint32 graveyard_id, uint32* graveyard_zoneid = 0, float* graveyard_x = 0, float* graveyard_y = 0, float* graveyard_z = 0, float* graveyard_heading = 0);
+	bool	GetZoneLongName(const char* short_name, char** long_name, char* file_name = 0, float* safe_x = 0, float* safe_y = 0, float* safe_z = 0, uint32* graveyard_id = 0, uint32* maxclients = 0);
 	bool	LoadPTimers(uint32 charid, PTimerList &into);
-	void	ClearPTimers(uint32 charid);
-	void	ClearMerchantTemp();
-	void	SetLFP(uint32 CharID, bool LFP);
-	void	SetLFG(uint32 CharID, bool LFG);
-	void	SetFirstLogon(uint32 CharID, uint8 firstlogon);
-	void	SetLoginFlags(uint32 CharID, bool LFP, bool LFG, uint8 firstlogon);
+	bool	LoadZoneNames();
+
+	const char*	GetZoneName(uint32 zoneID, bool ErrorUnknown = false);
+
+	uint32	GetZoneGraveyardID(uint32 zone_id, uint32 version);
+	uint32	GetZoneID(const char* zonename);
+
+	uint8	GetPEQZone(uint32 zoneID, uint32 version);
+	uint8	GetRaceSkill(uint8 skillid, uint8 in_race);
+	uint8	GetServerType();
+	uint8	GetSkillCap(uint8 skillid, uint8 in_race, uint8 in_class, uint16 in_level);
+
 	void	AddReport(std::string who, std::string against, std::string lines);
+	void	ClearMerchantTemp();
+	void	ClearPTimers(uint32 charid);
+	void	SetFirstLogon(uint32 CharID, uint8 firstlogon);
+	void	SetLFG(uint32 CharID, bool LFG);
+	void	SetLFP(uint32 CharID, bool LFP);
+	void	SetLoginFlags(uint32 CharID, bool LFP, bool LFG, uint8 firstlogon);
 
-
-protected:
-	void	HandleMysqlError(uint32 errnum);
+	/* EQEmuLogSys */
+	void	LoadLogSettings(EQEmuLogSys::LogSettings* log_settings);
 
 private:
 	void DBInitVars();
@@ -262,7 +260,15 @@ private:
 	uint32				varcache_max;
 	VarCache_Struct**	varcache_array;
 	uint32				varcache_lastupdate;
+
+	/* Groups, utility methods. */
+	void    ClearAllGroupLeaders();
+	void    ClearAllGroups();
+
+	/* Raid, utility methods. */
+	void ClearAllRaids();
+	void ClearAllRaidDetails();
+	void ClearAllRaidLeaders();
 };
 
-bool	FetchRowMap(MYSQL_RES *result, std::map<std::string,std::string> &rowmap);
 #endif

common/database_instances.cpp

@@ -0,0 +1,562 @@
+/*	EQEMu: Everquest Server Emulator
+Copyright (C) 2001-2015 EQEMu Development Team (http://eqemulator.net)
+
+This program 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; version 2 of the License.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY except by those people which sell it, which
+are required to give you total support for your newly bought product;
+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 this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+*/
+
+#include "../common/global_define.h"
+#include "../common/rulesys.h"
+#include "../common/string_util.h"
+#include "../common/timer.h"
+
+#include "database.h"
+
+#include <iomanip>
+#include <iostream>
+
+// Disgrace: for windows compile
+#ifdef _WINDOWS
+#include <windows.h>
+#define snprintf	_snprintf
+#define strncasecmp	_strnicmp
+#define strcasecmp	_stricmp
+#else
+#include "unix.h"
+#include <netinet/in.h>
+#include <sys/time.h>
+#endif
+
+bool Database::AddClientToInstance(uint16 instance_id, uint32 char_id)
+{
+	std::string query = StringFormat(
+		"REPLACE INTO `instance_list_player` (id, charid) "
+		"VALUES "
+		"(%lu, %lu)",
+		(unsigned long)instance_id,
+		(unsigned long)char_id
+		);
+	auto results = QueryDatabase(query);
+	return results.Success();
+}
+
+bool Database::CharacterInInstanceGroup(uint16 instance_id, uint32 char_id)
+{
+
+	std::string query = StringFormat("SELECT charid FROM instance_list_player where id=%u AND charid=%u", instance_id, char_id);
+	auto results = QueryDatabase(query);
+
+	if (!results.Success())
+		return false;
+
+	if (results.RowCount() != 1)
+		return false;
+
+	return true;
+}
+
+bool Database::CheckInstanceExists(uint16 instance_id) {
+	std::string query = StringFormat(
+		"SELECT "
+		"`id`  "
+		"FROM  "
+		"`instance_list`  "
+		"WHERE  "
+		"`id` = %u",
+		instance_id
+		);
+	auto results = QueryDatabase(query);
+
+	if (!results.Success())
+		return false;
+
+	if (results.RowCount() == 0)
+		return false;
+
+	return true;
+}
+
+bool Database::CheckInstanceExpired(uint16 instance_id)
+{
+
+	int32 start_time = 0;
+	int32 duration = 0;
+	uint32 never_expires = 0;
+
+	std::string query = StringFormat("SELECT start_time, duration, never_expires FROM instance_list WHERE id=%u", instance_id);
+	auto results = QueryDatabase(query);
+
+	if (!results.Success())
+		return true;
+
+	if (results.RowCount() == 0)
+		return true;
+
+	auto row = results.begin();
+
+	start_time = atoi(row[0]);
+	duration = atoi(row[1]);
+	never_expires = atoi(row[2]);
+
+	if (never_expires == 1)
+		return false;
+
+	timeval tv;
+	gettimeofday(&tv, nullptr);
+
+	if ((start_time + duration) <= tv.tv_sec)
+		return true;
+
+	return false;
+}
+
+bool Database::CreateInstance(uint16 instance_id, uint32 zone_id, uint32 version, uint32 duration)
+{
+	std::string query = StringFormat("INSERT INTO instance_list (id, zone, version, start_time, duration)"
+		" values(%lu, %lu, %lu, UNIX_TIMESTAMP(), %lu)",
+		(unsigned long)instance_id, (unsigned long)zone_id, (unsigned long)version, (unsigned long)duration);
+	auto results = QueryDatabase(query);
+
+	return results.Success();
+}
+
+bool Database::GetUnusedInstanceID(uint16 &instance_id)
+{
+	uint32 count = RuleI(Zone, ReservedInstances);
+	uint32 max = 65535;
+
+	std::string query = StringFormat("SELECT IFNULL(MAX(id),%u)+1 FROM instance_list  WHERE id > %u", count, count);
+	auto results = QueryDatabase(query);
+
+	if (!results.Success())
+	{
+		instance_id = 0;
+		return false;
+	}
+
+	if (results.RowCount() == 0)
+	{
+		instance_id = 0;
+		return false;
+	}
+
+	auto row = results.begin();
+
+	if (atoi(row[0]) <= max)
+	{
+		instance_id = atoi(row[0]);
+		return true;
+	}
+
+	query = StringFormat("SELECT id FROM instance_list where id > %u ORDER BY id", count);
+	results = QueryDatabase(query);
+
+	if (!results.Success())
+	{
+		instance_id = 0;
+		return false;
+	}
+
+	if (results.RowCount() == 0)
+	{
+		instance_id = 0;
+		return false;
+	}
+
+	count++;
+	for (auto row = results.begin(); row != results.end(); ++row)
+	{
+		if (count < atoi(row[0]))
+		{
+			instance_id = count;
+			return true;
+		}
+
+		if (count > max)
+		{
+			instance_id = 0;
+			return false;
+		}
+
+		count++;
+	}
+
+	instance_id = count;
+	return true;
+}
+
+bool Database::GlobalInstance(uint16 instance_id)
+{
+	std::string query = StringFormat(
+		"SELECT "
+		"is_global "
+		"FROM "
+		"instance_list "
+		"WHERE "
+		"id = %u "
+		"LIMIT 1 ",
+		instance_id
+		);
+	auto results = QueryDatabase(query);
+
+	if (!results.Success())
+		return false;
+
+	if (results.RowCount() == 0)
+		return false;
+
+	auto row = results.begin();
+
+	return (atoi(row[0]) == 1) ? true : false;
+}
+
+bool Database::RemoveClientFromInstance(uint16 instance_id, uint32 char_id)
+{
+	std::string query = StringFormat("DELETE FROM instance_list_player WHERE id=%lu AND charid=%lu",
+		(unsigned long)instance_id, (unsigned long)char_id);
+	auto results = QueryDatabase(query);
+
+	return results.Success();
+}
+
+
+bool Database::RemoveClientsFromInstance(uint16 instance_id)
+{
+	std::string query = StringFormat("DELETE FROM instance_list_player WHERE id=%lu", (unsigned long)instance_id);
+	auto results = QueryDatabase(query);
+
+	return results.Success();
+}
+
+bool Database::VerifyInstanceAlive(uint16 instance_id, uint32 char_id)
+{
+	//we are not saved to this instance so set our instance to 0
+	if (!GlobalInstance(instance_id) && !CharacterInInstanceGroup(instance_id, char_id))
+		return false;
+
+	if (CheckInstanceExpired(instance_id))
+	{
+		DeleteInstance(instance_id);
+		return false;
+	}
+
+	return true;
+}
+
+bool Database::VerifyZoneInstance(uint32 zone_id, uint16 instance_id)
+{
+
+	std::string query = StringFormat("SELECT id FROM instance_list where id=%u AND zone=%u", instance_id, zone_id);
+	auto results = QueryDatabase(query);
+
+	if (!results.Success())
+		return false;
+
+	if (results.RowCount() == 0)
+		return false;
+
+	return true;
+}
+
+uint16 Database::GetInstanceID(const char* zone, uint32 character_id, int16 version) {
+
+	std::string query = StringFormat(
+		"SELECT "
+		"instance_list.id "
+		"FROM "
+		"instance_list, "
+		"instance_list_player "
+		"WHERE "
+		"instance_list.zone = %u "
+		"AND instance_list.version = %u "
+		"AND instance_list.id = instance_list_player.id "
+		"AND instance_list_player.charid = %u "
+		"LIMIT 1 ",
+		GetZoneID(zone),
+		version,
+		character_id
+		);
+	auto results = QueryDatabase(query);
+
+	if (!results.Success())
+		return 0;
+
+	if (results.RowCount() == 0)
+		return 0;
+
+	auto row = results.begin();
+	return atoi(row[0]);
+}
+
+uint16 Database::GetInstanceID(uint32 zone, uint32 character_id, int16 version)
+{
+	if (!zone)
+		return 0;
+
+	std::string query = StringFormat(
+		"SELECT "
+		"instance_list.id "
+		"FROM "
+		"instance_list, "
+		"instance_list_player "
+		"WHERE "
+		"instance_list.zone = %u "
+		"AND instance_list.version = %u "
+		"AND instance_list.id = instance_list_player.id "
+		"AND instance_list_player.charid = %u "
+		"LIMIT 1; ",
+		zone,
+		version,
+		character_id
+		);
+	auto results = QueryDatabase(query);
+
+	if (!results.Success())
+		return 0;
+
+	if (results.RowCount() == 0)
+		return 0;
+
+	auto row = results.begin();
+
+	return atoi(row[0]);
+}
+
+uint16 Database::GetInstanceVersion(uint16 instance_id) {
+	if (instance_id == 0)
+		return 0;
+
+	std::string query = StringFormat("SELECT version FROM instance_list where id=%u", instance_id);
+	auto results = QueryDatabase(query);
+
+	if (!results.Success())
+		return 0;
+
+	if (results.RowCount() == 0)
+		return 0;
+
+	auto row = results.begin();
+	return atoi(row[0]);
+}
+
+uint32 Database::GetTimeRemainingInstance(uint16 instance_id, bool &is_perma)
+{
+	uint32 start_time = 0;
+	uint32 duration = 0;
+	uint32 never_expires = 0;
+
+	std::string query = StringFormat("SELECT start_time, duration, never_expires FROM instance_list WHERE id=%u", instance_id);
+	auto results = QueryDatabase(query);
+
+	if (!results.Success())
+	{
+		is_perma = false;
+		return 0;
+	}
+
+	if (results.RowCount() == 0)
+	{
+		is_perma = false;
+		return 0;
+	}
+
+	auto row = results.begin();
+
+	start_time = atoi(row[0]);
+	duration = atoi(row[1]);
+	never_expires = atoi(row[2]);
+
+	if (never_expires == 1)
+	{
+		is_perma = true;
+		return 0;
+	}
+
+	is_perma = false;
+
+	timeval tv;
+	gettimeofday(&tv, nullptr);
+	return ((start_time + duration) - tv.tv_sec);
+}
+
+uint32 Database::VersionFromInstanceID(uint16 instance_id)
+{
+
+	std::string query = StringFormat("SELECT version FROM instance_list where id=%u", instance_id);
+	auto results = QueryDatabase(query);
+
+	if (!results.Success())
+		return 0;
+
+	if (results.RowCount() == 0)
+		return 0;
+
+	auto row = results.begin();
+
+	return atoi(row[0]);
+}
+
+uint32 Database::ZoneIDFromInstanceID(uint16 instance_id)
+{
+
+	std::string query = StringFormat("SELECT zone FROM instance_list where id=%u", instance_id);
+	auto results = QueryDatabase(query);
+
+	if (!results.Success())
+		return 0;
+
+	if (results.RowCount() == 0)
+		return 0;
+
+	auto row = results.begin();
+
+	return atoi(row[0]);
+}
+
+void Database::AssignGroupToInstance(uint32 group_id, uint32 instance_id)
+{
+
+	uint32 zone_id = ZoneIDFromInstanceID(instance_id);
+	uint16 version = VersionFromInstanceID(instance_id);
+
+	std::string query = StringFormat("SELECT `charid` FROM `group_id` WHERE `groupid` = %u", group_id);
+	auto results = QueryDatabase(query);
+
+	if (!results.Success())
+		return;
+
+	for (auto row = results.begin(); row != results.end(); ++row)
+	{
+		uint32 charid = atoi(row[0]);
+		if (GetInstanceID(zone_id, charid, version) == 0)
+			AddClientToInstance(instance_id, charid);
+	}
+}
+
+void Database::AssignRaidToInstance(uint32 raid_id, uint32 instance_id)
+{
+
+	uint32 zone_id = ZoneIDFromInstanceID(instance_id);
+	uint16 version = VersionFromInstanceID(instance_id);
+
+	std::string query = StringFormat("SELECT `charid` FROM `raid_members` WHERE `raidid` = %u", raid_id);
+	auto results = QueryDatabase(query);
+
+	if (!results.Success())
+		return;
+
+	for (auto row = results.begin(); row != results.end(); ++row)
+	{
+		uint32 charid = atoi(row[0]);
+		if (GetInstanceID(zone_id, charid, version) == 0)
+			AddClientToInstance(instance_id, charid);
+	}
+}
+
+void Database::BuryCorpsesInInstance(uint16 instance_id) {
+	std::string query = StringFormat(
+		"UPDATE `character_corpses` "
+		"SET `is_buried` = 1, "
+		"`instance_id` = 0 "
+		"WHERE "
+		"`instance_id` = %u ",
+		instance_id
+		);
+	auto results = QueryDatabase(query);
+}
+
+void Database::DeleteInstance(uint16 instance_id)
+{
+
+	std::string query = StringFormat("DELETE FROM instance_list WHERE id=%u", instance_id);
+	QueryDatabase(query);
+
+	query = StringFormat("DELETE FROM instance_list_player WHERE id=%u", instance_id);
+	QueryDatabase(query);
+
+	query = StringFormat("DELETE FROM respawn_times WHERE instance_id=%u", instance_id);
+	QueryDatabase(query);
+
+	query = StringFormat("DELETE FROM spawn_condition_values WHERE instance_id=%u", instance_id);
+	QueryDatabase(query);
+
+	BuryCorpsesInInstance(instance_id);
+}
+
+void Database::FlagInstanceByGroupLeader(uint32 zone, int16 version, uint32 charid, uint32 gid)
+{
+	uint16 id = GetInstanceID(zone, charid, version);
+	if (id != 0)
+		return;
+
+	char ln[128];
+	memset(ln, 0, 128);
+	strcpy(ln, GetGroupLeadershipInfo(gid, ln));
+	uint32 l_charid = GetCharacterID((const char*)ln);
+	uint16 l_id = GetInstanceID(zone, l_charid, version);
+
+	if (l_id == 0)
+		return;
+
+	AddClientToInstance(l_id, charid);
+}
+
+void Database::FlagInstanceByRaidLeader(uint32 zone, int16 version, uint32 charid, uint32 rid)
+{
+	uint16 id = GetInstanceID(zone, charid, version);
+	if (id != 0)
+		return;
+
+	uint32 l_charid = GetCharacterID(GetRaidLeaderName(rid));
+	uint16 l_id = GetInstanceID(zone, l_charid, version);
+
+	if (l_id == 0)
+		return;
+
+	AddClientToInstance(l_id, charid);
+}
+
+void Database::GetCharactersInInstance(uint16 instance_id, std::list<uint32> &charid_list) {
+
+	std::string query = StringFormat("SELECT `charid` FROM `instance_list_player` WHERE `id` = %u", instance_id);
+	auto results = QueryDatabase(query);
+
+	if (!results.Success())
+		return;
+
+	for (auto row = results.begin(); row != results.end(); ++row)
+		charid_list.push_back(atoi(row[0]));
+}
+
+void Database::PurgeExpiredInstances()
+{
+	std::string query("SELECT id FROM instance_list where (start_time+duration) <= UNIX_TIMESTAMP() and never_expires = 0");
+	auto results = QueryDatabase(query);
+
+	if (!results.Success())
+		return;
+
+	if (results.RowCount() == 0)
+		return;
+
+	for (auto row = results.begin(); row != results.end(); ++row)
+		DeleteInstance(atoi(row[0]));
+}
+
+void Database::SetInstanceDuration(uint16 instance_id, uint32 new_duration)
+{
+	std::string query = StringFormat("UPDATE `instance_list` SET start_time=UNIX_TIMESTAMP(), "
+		"duration=%u WHERE id=%u", new_duration, instance_id);
+	auto results = QueryDatabase(query);
+}

common/dbasync.cpp

@@ -1,669 +0,0 @@
-#include "debug.h"
-#ifdef _WINDOWS
-	#include <windows.h>
-	#include <process.h>
-	#include <winsock2.h>
-#endif
-#include <iostream>
-#include "dbasync.h"
-#include "database.h"
-#include <errmsg.h>
-#include <mysqld_error.h>
-#include <limits.h>
-#include "dbcore.h"
-#include <string.h>
-//#include "../common/MiscFunctions.h"
-#include "StringUtil.h"
-#define ASYNC_LOOP_GRANULARITY 4 //# of ms between checking our work
-
-bool DBAsyncCB_LoadVariables(DBAsyncWork* iWork) {
-	char errbuf[MYSQL_ERRMSG_SIZE];
-	MYSQL_RES* result = 0;
-	DBAsyncQuery* dbaq = iWork->PopAnswer();
-	if (dbaq->GetAnswer(errbuf, &result))
-		iWork->GetDB()->LoadVariables_result(result);
-	else
-		std::cout << "Error: DBAsyncCB_LoadVariables failed: !GetAnswer: '" << errbuf << "'" << std::endl;
-	return true;
-}
-
-void AsyncLoadVariables(DBAsync *dba, Database *db) {
-	char* query = 0;
-	DBAsyncWork* dbaw = new DBAsyncWork(db, &DBAsyncCB_LoadVariables, 0, DBAsync::Read);
-	dbaw->AddQuery(0, &query, db->LoadVariables_MQ(&query));
-	dba->AddWork(&dbaw);
-}
-
-
-//we only need to do anything when somebody puts work on the queue
-//so instead of checking all the time, we will wait on a condition
-//which will get signaled when somebody puts something on the queue
-ThreadReturnType DBAsyncLoop(void* tmp) {
-	DBAsync* dba = (DBAsync*) tmp;
-
-#ifndef WIN32
-	_log(COMMON__THREADS, "Starting DBAsyncLoop with thread ID %d", pthread_self());
-#endif
-
-	dba->MLoopRunning.lock();
-	while (dba->RunLoop()) {
-		//wait before working so we check the loop condition
-		//as soon as were done working
-		dba->CInList.Wait();
-		//we could check dba->RunLoop() again to see if we
-		//got turned off while we were waiting
-		{
-			dba->Process();
-		}
-	}
-	dba->MLoopRunning.unlock();
-
-#ifndef WIN32
-	_log(COMMON__THREADS, "Ending DBAsyncLoop with thread ID %d", pthread_self());
-#endif
-
-	THREAD_RETURN(nullptr);
-}
-
-DBAsync::DBAsync(DBcore* iDBC)
-: Timeoutable(10000)
-{
-	pDBC = iDBC;
-	pRunLoop = true;
-	pNextID = 1;
-#ifdef _WINDOWS
-	_beginthread(DBAsyncLoop, 0, this);
-#else
-	pthread_t thread;
-	pthread_create(&thread, nullptr, DBAsyncLoop, this);
-#endif
-}
-
-DBAsync::~DBAsync() {
-	StopThread();
-}
-
-bool DBAsync::StopThread() {
-	bool ret;
-	MRunLoop.lock();
-	ret = pRunLoop;
-	pRunLoop = false;
-	MRunLoop.unlock();
-
-	//signal the condition so we exit the loop if were waiting
-	CInList.Signal();
-
-	//this effectively waits for the processing thread to finish
-	MLoopRunning.lock();
-	MLoopRunning.unlock();
-
-	return ret;
-}
-
-uint32 DBAsync::AddWork(DBAsyncWork** iWork, uint32 iDelay) {
-	MInList.lock();
-	uint32 ret = GetNextID();
-	if (!(*iWork)->SetWorkID(ret)) {
-		MInList.unlock();
-		return 0;
-	}
-	InList.Append(*iWork);
-	(*iWork)->SetStatus(Queued);
-	if (iDelay)
-		(*iWork)->pExecuteAfter = Timer::GetCurrentTime() + iDelay;
-#if DEBUG_MYSQL_QUERIES >= 2
-	std::cout << "Adding AsyncWork #" << (*iWork)->GetWorkID() << std::endl;
-	std::cout << "ExecuteAfter = " << (*iWork)->pExecuteAfter << " (" << Timer::GetCurrentTime() << " + " << iDelay << ")" << std::endl;
-#endif
-	*iWork = 0;
-	MInList.unlock();
-
-	//wake up the processing thread and tell it to get to work.
-	CInList.Signal();
-
-	return ret;
-}
-
-bool DBAsync::CancelWork(uint32 iWorkID) {
-	if (iWorkID == 0)
-		return false;
-#if DEBUG_MYSQL_QUERIES >= 2
-	std::cout << "DBAsync::CancelWork: " << iWorkID << std::endl;
-#endif
-	MCurrentWork.lock();
-	if (CurrentWork && CurrentWork->GetWorkID() == iWorkID) {
-		CurrentWork->Cancel();
-		MCurrentWork.unlock();
-		return true;
-	}
-	MCurrentWork.unlock();
-	MInList.lock();
-	LinkedListIterator<DBAsyncWork*> iterator(InList);
-
-	iterator.Reset();
-	while (iterator.MoreElements()) {
-		if (iterator.GetData()->GetWorkID() == iWorkID) {
-			iterator.RemoveCurrent(true);
-			MInList.unlock();
-			return true;
-		}
-		iterator.Advance();
-	}
-	MInList.unlock();
-	return false;
-}
-
-bool DBAsync::RunLoop() {
-	bool ret;
-	MRunLoop.lock();
-	ret = pRunLoop;
-	MRunLoop.unlock();
-	return ret;
-}
-
-DBAsyncWork* DBAsync::InListPop() {
-	DBAsyncWork* ret = 0;
-	MInList.lock();
-	LinkedListIterator<DBAsyncWork*> iterator(InList);
-
-	iterator.Reset();
-	while (iterator.MoreElements()) {
-		if (iterator.GetData()->pExecuteAfter <= Timer::GetCurrentTime()) {
-			ret = iterator.GetData();
-#if DEBUG_MYSQL_QUERIES >= 2
-			std::cout << "Poping AsyncWork #" << ret->GetWorkID() << std::endl;
-			std::cout << ret->pExecuteAfter << " <= " << Timer::GetCurrentTime() << std::endl;
-#endif
-			iterator.RemoveCurrent(false);
-			break;
-		}
-		iterator.Advance();
-	}
-	MInList.unlock();
-	return ret;
-}
-
-DBAsyncWork* DBAsync::InListPopWrite() {
-	MInList.lock();
-	LinkedListIterator<DBAsyncWork*> iterator(InList);
-
-	DBAsyncWork* ret = 0;
-	DBAsync::Type tmpType;
-	iterator.Reset();
-	while (iterator.MoreElements()) {
-		tmpType = iterator.GetData()->Type();
-		if (tmpType == Write || tmpType == Both) {
-			ret = iterator.GetData();
-			iterator.RemoveCurrent(false);
-			break;
-		}
-		iterator.Advance();
-	}
-	MInList.unlock();
-	return ret;
-}
-
-void DBAsync::AddFQ(DBAsyncFinishedQueue* iDBAFQ) {
-	MFQList.lock();
-	DBAsyncFinishedQueue** tmp = new DBAsyncFinishedQueue*;
-	*tmp = iDBAFQ;
-	FQList.Append(tmp);
-	MFQList.unlock();
-}
-
-void DBAsync::Process() {
-	DBAsyncWork* tmpWork;
-	MCurrentWork.lock();
-	while ((CurrentWork = InListPop())) {
-		MCurrentWork.unlock();
-		//move from queued to executing
-		Status tmpStatus = CurrentWork->SetStatus(Executing);
-		if (tmpStatus == Queued) {
-			//execute the work
-			ProcessWork(CurrentWork);
-			tmpWork = CurrentWork;
-			MCurrentWork.lock();
-			CurrentWork = 0;
-			MCurrentWork.unlock();
-			//move from executing to finished
-			tmpStatus = tmpWork->SetStatus(DBAsync::Finished);
-			if (tmpStatus != Executing) {
-				if (tmpStatus != Canceled) {
-					std::cout << "Error: Unexpected DBAsyncWork->Status in DBAsync::Process #1" << std::endl;
-				}
-				MCurrentWork.lock();
-				safe_delete(tmpWork);
-			}
-			else {
-				//call callbacks or put results on finished queue
-				DispatchWork(tmpWork);
-				Sleep(25);
-				MCurrentWork.lock();
-			}
-		}
-		else {
-			if (tmpStatus != Canceled) {
-				std::cout << "Error: Unexpected DBAsyncWork->Status in DBAsync::Process #2" << std::endl;
-			}
-			MCurrentWork.lock();
-			safe_delete(CurrentWork);
-		}
-	}
-	MCurrentWork.unlock();
-}
-
-void DBAsync::CheckTimeout() {
-	try{
-		MFQList.lock();
-		LinkedListIterator<DBAsyncFinishedQueue**> iterator(FQList);
-
-		iterator.Reset();
-		while (iterator.MoreElements()) {
-			(*iterator.GetData())->CheckTimeouts();
-			iterator.Advance();
-		}
-		MFQList.unlock();
-	}
-	catch(...){
-
-	}
-}
-
-void DBAsync::CommitWrites() {
-#if DEBUG_MYSQL_QUERIES >= 2
-	std::cout << "DBAsync::CommitWrites() called." << std::endl;
-#endif
-	DBAsyncWork* tmpWork;
-	while ((tmpWork = InListPopWrite())) {
-		Status tmpStatus = tmpWork->SetStatus(Executing);
-		if (tmpStatus == Queued) {
-			ProcessWork(tmpWork);
-			tmpStatus = tmpWork->SetStatus(DBAsync::Finished);
-			if (tmpStatus != Executing) {
-				if (tmpStatus != Canceled) {
-					std::cout << "Error: Unexpected DBAsyncWork->Status in DBAsync::CommitWrites #1" << std::endl;
-				}
-				safe_delete(tmpWork);
-			}
-			else {
-				DispatchWork(tmpWork);
-			}
-		}
-		else {
-			if (tmpStatus != Canceled) {
-				std::cout << "Error: Unexpected DBAsyncWork->Status in DBAsync::CommitWrites #2" << std::endl;
-			}
-			safe_delete(tmpWork);
-		}
-	}
-}
-
-void DBAsync::ProcessWork(DBAsyncWork* iWork, bool iSleep) {
-	DBAsyncQuery* CurrentQuery;
-	while ((CurrentQuery = iWork->PopQuery())) {
-		CurrentQuery->Process(pDBC);
-		iWork->PushAnswer(CurrentQuery);
-		if (iSleep)
-			Sleep(1);
-	}
-}
-
-void DBAsync::DispatchWork(DBAsyncWork* iWork) {
-	//if this work has a callback, call it
-	//otherwise, stick the work on the finish queue
-	if (iWork->pCB) {
-		if (iWork->pCB(iWork))
-			safe_delete(iWork);
-	}
-	else {
-		if (!iWork->pDBAFQ->Push(iWork))
-			safe_delete(iWork);
-	}
-}
-
-
-
-DBAsyncFinishedQueue::DBAsyncFinishedQueue(uint32 iTimeout) {
-	pTimeout = iTimeout;
-}
-
-DBAsyncFinishedQueue::~DBAsyncFinishedQueue() {
-}
-
-void DBAsyncFinishedQueue::CheckTimeouts() {
-	if (pTimeout == 0xFFFFFFFF)
-		return;
-	MLock.lock();
-	LinkedListIterator<DBAsyncWork*> iterator(list);
-
-	iterator.Reset();
-	while (iterator.MoreElements()) {
-		if (iterator.GetData()->CheckTimeout(pTimeout))
-			iterator.RemoveCurrent(true);
-		iterator.Advance();
-	}
-	MLock.unlock();
-}
-
-DBAsyncWork* DBAsyncFinishedQueue::Pop() {
-	DBAsyncWork* ret = 0;
-	MLock.lock();
-	ret = list.Pop();
-	MLock.unlock();
-	return ret;
-}
-
-DBAsyncWork* DBAsyncFinishedQueue::Find(uint32 iWorkID) {
-	DBAsyncWork* ret = 0;
-	MLock.lock();
-	LinkedListIterator<DBAsyncWork*> iterator(list);
-
-	iterator.Reset();
-	while (iterator.MoreElements()) {
-		if (iterator.GetData()->GetWorkID() == iWorkID) {
-			ret = iterator.GetData();
-			iterator.RemoveCurrent(false);
-			break;
-		}
-		iterator.Advance();
-	}
-	MLock.unlock();
-	return ret;
-}
-
-DBAsyncWork* DBAsyncFinishedQueue::PopByWPT(uint32 iWPT) {
-	DBAsyncWork* ret = 0;
-	MLock.lock();
-	LinkedListIterator<DBAsyncWork*> iterator(list);
-
-	iterator.Reset();
-	while (iterator.MoreElements()) {
-		if (iterator.GetData()->WPT() == iWPT) {
-			ret = iterator.GetData();
-			iterator.RemoveCurrent(false);
-			break;
-		}
-		iterator.Advance();
-	}
-	MLock.unlock();
-	return ret;
-}
-
-bool DBAsyncFinishedQueue::Push(DBAsyncWork* iDBAW) {
-	if (!this)
-		return false;
-	MLock.lock();
-	list.Append(iDBAW);
-	MLock.unlock();
-	return true;
-}
-
-
-
-DBAsyncWork::DBAsyncWork(Database *db, DBAsyncFinishedQueue* iDBAFQ, uint32 iWPT, DBAsync::Type iType, uint32 iTimeout)
-: m_db(db)
-{
-	pstatus = DBAsync::AddingWork;
-	pType = iType;
-	pExecuteAfter = 0;
-	pWorkID = 0;
-	pDBAFQ = iDBAFQ;
-	pCB = 0;
-	pWPT = iWPT;
-	pQuestionCount = 0;
-	pAnswerCount = 0;
-	pTimeout = iTimeout;
-	pTSFinish = 0;
-}
-
-DBAsyncWork::DBAsyncWork(Database *db, DBWorkCompleteCallBack iCB, uint32 iWPT, DBAsync::Type iType, uint32 iTimeout)
-: m_db(db)
-{
-	pstatus = DBAsync::AddingWork;
-	pType = iType;
-	pExecuteAfter = 0;
-	pWorkID = 0;
-	pDBAFQ = 0;
-	pCB = iCB;
-	pWPT = iWPT;
-	pQuestionCount = 0;
-	pAnswerCount = 0;
-	pTimeout = iTimeout;
-	pTSFinish = 0;
-}
-
-DBAsyncWork::~DBAsyncWork() {
-	DBAsyncQuery* dbaq = 0;
-	while ((dbaq = todo.pop()))
-		safe_delete(dbaq);
-	while ((dbaq = done.pop()))
-		safe_delete(dbaq);
-	while ((dbaq = todel.pop()))
-		safe_delete(dbaq);
-}
-
-bool DBAsyncWork::AddQuery(DBAsyncQuery** iDBAQ) {
-	bool ret;
-	MLock.lock();
-	if (pstatus != DBAsync::AddingWork)
-		ret = false;
-	else {
-		ret = true;
-		pQuestionCount++;
-		todo.push(*iDBAQ);
-		(*iDBAQ)->pstatus = DBAsync::Queued;
-		*iDBAQ = 0;
-	}
-	MLock.unlock();
-	return ret;
-}
-
-bool DBAsyncWork::AddQuery(uint32 iQPT, char** iQuery, uint32 iQueryLen, bool iGetResultSet, bool iGetErrbuf) {
-	DBAsyncQuery* DBAQ = new DBAsyncQuery(iQPT, iQuery, iQueryLen, iGetResultSet, iGetErrbuf);
-	if (AddQuery(&DBAQ))
-		return true;
-	else {
-		safe_delete(DBAQ);
-		return false;
-	}
-}
-
-bool DBAsyncWork::SetWorkID(uint32 iWorkID) {
-	bool ret = true;
-	MLock.lock();
-	if (pWorkID)
-		ret = false;
-	else
-		pWorkID = iWorkID;
-	MLock.unlock();
-	return ret;
-}
-
-uint32 DBAsyncWork::GetWorkID() {
-	uint32 ret;
-	MLock.lock();
-	ret = pWorkID;
-	MLock.unlock();
-	return ret;
-}
-
-uint32 DBAsyncWork::WPT() {
-	uint32 ret;
-	MLock.lock();
-	ret = pWPT;
-	MLock.unlock();
-	return ret;
-}
-
-DBAsync::Type DBAsyncWork::Type() {
-	DBAsync::Type ret;
-	MLock.lock();
-	ret = pType;
-	MLock.unlock();
-	return ret;
-}
-
-DBAsyncQuery* DBAsyncWork::PopAnswer() {
-	DBAsyncQuery* ret;
-	MLock.lock();
-	ret = done.pop();
-	if (ret)
-		pAnswerCount--;
-	todel.push(ret);
-	MLock.unlock();
-	return ret;
-}
-
-bool DBAsyncWork::CheckTimeout(uint32 iFQTimeout) {
-	if (pTimeout == 0xFFFFFFFF)
-		return false;
-	bool ret = false;
-	MLock.lock();
-	if (pTimeout > iFQTimeout)
-		iFQTimeout = pTimeout;
-	if (Timer::GetCurrentTime() > (pTSFinish + iFQTimeout))
-		ret = true;
-	MLock.unlock();
-	return ret;
-}
-
-//sets the work's status to the supplied value and returns
-//the revious status
-DBAsync::Status DBAsyncWork::SetStatus(DBAsync::Status iStatus) {
-	DBAsync::Status ret;
-	MLock.lock();
-	if (iStatus == DBAsync::Finished)
-		pTSFinish = Timer::GetCurrentTime();
-	ret = pstatus;
-	pstatus = iStatus;
-	MLock.unlock();
-	return ret;
-}
-
-bool DBAsyncWork::Cancel() {
-	bool ret;
-	MLock.lock();
-	if (pstatus != DBAsync::Finished) {
-		pstatus = DBAsync::Canceled;
-		ret = true;
-	}
-	else
-		ret = false;
-	MLock.unlock();
-	return ret;
-}
-
-bool DBAsyncWork::IsCancled() {
-	bool ret;
-	MLock.lock();
-	ret = (bool) (pstatus == DBAsync::Canceled);
-	MLock.unlock();
-	return ret;
-}
-
-DBAsyncQuery* DBAsyncWork::PopQuery() {
-	DBAsyncQuery* ret = 0;
-	MLock.lock();
-	ret = todo.pop();
-	if (ret)
-		pQuestionCount--;
-	MLock.unlock();
-	return ret;
-}
-
-void DBAsyncWork::PushAnswer(DBAsyncQuery* iDBAQ) {
-	MLock.lock();
-	done.push(iDBAQ);
-	pAnswerCount++;
-	MLock.unlock();
-}
-
-
-DBAsyncQuery::DBAsyncQuery(uint32 iQPT, char** iQuery, uint32 iQueryLen, bool iGetResultSet, bool iGetErrbuf) {
-	if (iQueryLen == 0xFFFFFFFF)
-		pQueryLen = strlen(*iQuery);
-	else
-		pQueryLen = iQueryLen;
-	pQuery = *iQuery;
-	*iQuery = 0;
-	Init(iQPT, iGetResultSet, iGetErrbuf);
-}
-
-DBAsyncQuery::DBAsyncQuery(uint32 iQPT, const char* iQuery, uint32 iQueryLen, bool iGetResultSet, bool iGetErrbuf) {
-	if (iQueryLen == 0xFFFFFFFF)
-		pQueryLen = strlen(iQuery);
-	else
-		pQueryLen = iQueryLen;
-	pQuery = strn0cpy(new char[pQueryLen+1], iQuery, pQueryLen+1);
-	Init(iQPT, iGetResultSet, iGetErrbuf);
-}
-
-void DBAsyncQuery::Init(uint32 iQPT, bool iGetResultSet, bool iGetErrbuf) {
-	pstatus = DBAsync::AddingWork;
-	pQPT = iQPT;
-	pGetResultSet = iGetResultSet;
-	pGetErrbuf = iGetErrbuf;
-
-	pmysqlsuccess = false;
-	perrbuf = 0;
-	perrnum = 0;
-	presult = 0;
-	paffected_rows = 0;
-	plast_insert_id = 0;
-}
-
-DBAsyncQuery::~DBAsyncQuery() {
-	safe_delete_array(perrbuf);
-	safe_delete_array(pQuery);
-	if (presult)
-		mysql_free_result(presult);
-}
-
-bool DBAsyncQuery::GetAnswer(char* errbuf, MYSQL_RES** result, uint32* affected_rows, uint32* last_insert_id, uint32* errnum) {
-	if (pstatus != DBAsync::Finished) {
-		if (errbuf)
-			snprintf(errbuf, MYSQL_ERRMSG_SIZE, "Error: Query not finished.");
-		if (errnum)
-			*errnum = UINT_MAX;
-		return false;
-	}
-	if (errbuf) {
-		if (pGetErrbuf) {
-			if (perrbuf)
-				strn0cpy(errbuf, perrbuf, MYSQL_ERRMSG_SIZE);
-			else
-				snprintf(errbuf, MYSQL_ERRMSG_SIZE, "Error message should've been saved, but hasnt. errno: %u", perrnum);
-		}
-		else
-			snprintf(errbuf, MYSQL_ERRMSG_SIZE, "Error message not saved. errno: %u", perrnum);
-	}
-	if (errnum)
-		*errnum = perrnum;
-	if (affected_rows)
-		*affected_rows = paffected_rows;
-	if (last_insert_id)
-		*last_insert_id = plast_insert_id;
-	if (result)
-		*result = presult;
-	return pmysqlsuccess;
-}
-
-void DBAsyncQuery::Process(DBcore* iDBC) {
-	pstatus = DBAsync::Executing;
-	if (pGetErrbuf)
-		perrbuf = new char[MYSQL_ERRMSG_SIZE];
-	MYSQL_RES** resultPP = 0;
-	if (pGetResultSet)
-		resultPP = &presult;
-	pmysqlsuccess = iDBC->RunQuery(pQuery, pQueryLen, perrbuf, resultPP, &paffected_rows, &plast_insert_id, &perrnum);
-	pstatus = DBAsync::Finished;
-}
-
-
-
-
-
-
-
-
-

common/dbasync.h

@@ -1,176 +0,0 @@
-#ifndef DBASYNC_H
-#define DBASYNC_H
-#include "../common/dbcore.h"
-#include "../common/timeoutmgr.h"
-
-
-class DBAsyncFinishedQueue;
-class DBAsyncWork;
-class DBAsyncQuery;
-class Database;
-
-// Big daddy that owns the threads and does the work
-class DBAsync : private Timeoutable {
-public:
-	enum Status { AddingWork, Queued, Executing, Finished, Canceled };
-	enum Type { Read, Write, Both };
-
-	DBAsync(DBcore* iDBC);
-	~DBAsync();
-	bool	StopThread();
-
-	uint32	AddWork(DBAsyncWork** iWork, uint32 iDelay = 0);
-	bool	CancelWork(uint32 iWorkID);
-	void	CommitWrites();
-
-	void	AddFQ(DBAsyncFinishedQueue* iDBAFQ);
-protected:
-	//things related to the processing thread:
-	friend ThreadReturnType DBAsyncLoop(void* tmp);
-	Mutex	MLoopRunning;
-	Condition CInList;
-	bool	RunLoop();
-	void	Process();
-
-private:
-	virtual void CheckTimeout();
-
-	void	ProcessWork(DBAsyncWork* iWork, bool iSleep = true);
-	void	DispatchWork(DBAsyncWork* iWork);
-	inline	uint32	GetNextID()		{ return pNextID++; }
-	DBAsyncWork*	InListPop();
-	DBAsyncWork*	InListPopWrite();	// Ignores delay
-	void			OutListPush(DBAsyncWork* iDBAW);
-
-	Mutex	MRunLoop;
-	bool	pRunLoop;
-
-	DBcore*	pDBC;
-	uint32	pNextID;
-	Mutex	MInList;
-	LinkedList<DBAsyncWork*> InList;
-
-	Mutex	MFQList;
-	LinkedList<DBAsyncFinishedQueue**> FQList;
-
-	// Mutex for outside access to current work & when current work is being changed.
-	// NOT locked when CurrentWork is being accessed by the DBAsync thread.
-	// Never change pointer from outside DBAsync thread!
-	// Only here for access to thread-safe DBAsyncWork functions.
-	Mutex	MCurrentWork;
-	DBAsyncWork* CurrentWork;
-
-};
-
-/*
-	DB Work Complete Callback:
-		This will be called under the DBAsync thread! Never access any non-threadsafe
-		data/functions/classes. (ie: zone, entitylist, client, etc are not threadsafe)
-	Function prototype:
-		return value:	true if we should delete the data, false if we should keep it
-*/
-typedef bool(*DBWorkCompleteCallBack)(DBAsyncWork*);
-
-class DBAsyncFinishedQueue {
-public:
-	DBAsyncFinishedQueue(uint32 iTimeout = 90000);
-	~DBAsyncFinishedQueue();
-
-	DBAsyncWork*	Pop();
-	DBAsyncWork*	PopByWPT(uint32 iWPT);
-	DBAsyncWork*	Find(uint32 iWPT);
-	bool			Push(DBAsyncWork* iDBAW);
-
-	void			CheckTimeouts();
-private:
-	Mutex MLock;
-	uint32 pTimeout;
-	LinkedList<DBAsyncWork*> list;
-};
-
-// Container class for multiple queries
-class DBAsyncWork {
-public:
-	DBAsyncWork(Database *db, DBAsyncFinishedQueue* iDBAFQ, uint32 iWPT = 0, DBAsync::Type iType = DBAsync::Both, uint32 iTimeout = 0);
-	DBAsyncWork(Database *db, DBWorkCompleteCallBack iCB, uint32 iWPT = 0, DBAsync::Type iType = DBAsync::Both, uint32 iTimeout = 0);
-	~DBAsyncWork();
-
-	bool			AddQuery(DBAsyncQuery** iDBAQ);
-	bool			AddQuery(uint32 iQPT, char** iQuery, uint32 iQueryLen = 0xFFFFFFFF, bool iGetResultSet = true, bool iGetErrbuf = true);
-	uint32			WPT();
-	DBAsync::Type	Type();
-
-	// Pops finished queries off the work
-	DBAsyncQuery*	PopAnswer();
-	uint32			QueryCount();
-
-	Database *GetDB() const { return(m_db); }
-
-	bool			CheckTimeout(uint32 iFQTimeout);
-	bool			SetWorkID(uint32 iWorkID);
-	uint32			GetWorkID();
-protected:
-	friend class DBAsync;
-	DBAsync::Status	SetStatus(DBAsync::Status iStatus);
-	bool			Cancel();
-	bool			IsCancled();
-	DBAsyncQuery*	PopQuery();	// Get query to be run
-	void			PushAnswer(DBAsyncQuery* iDBAQ);	// Push answer back into workset
-
-	// not mutex'd cause only to be accessed from dbasync class
-	uint32	pExecuteAfter;
-private:
-	Mutex	MLock;
-	uint32	pQuestionCount;
-	uint32	pAnswerCount;
-	uint32	pWorkID;
-	uint32	pWPT;
-	uint32	pTimeout;
-	uint32	pTSFinish; // timestamp when finished
-	DBAsyncFinishedQueue*	pDBAFQ;		//we do now own this pointer
-	DBWorkCompleteCallBack	pCB;
-	DBAsync::Status			pstatus;
-	DBAsync::Type			pType;
-	MyQueue<DBAsyncQuery>	todo;
-	MyQueue<DBAsyncQuery>	done;
-	MyQueue<DBAsyncQuery>	todel;
-	Database *const			m_db;		//we do now own this pointer
-};
-
-// Container class for the query information
-class DBAsyncQuery {
-public:
-	DBAsyncQuery(uint32 iQPT, char** iQuery, uint32 iQueryLen = 0xFFFFFFFF, bool iGetResultSet = true, bool iGetErrbuf = true);
-	DBAsyncQuery(uint32 iQPT, const char* iQuery, uint32 iQueryLen = 0xFFFFFFFF, bool iGetResultSet = true, bool iGetErrbuf = true);
-	~DBAsyncQuery();
-
-	bool	GetAnswer(char* errbuf = 0, MYSQL_RES** result = 0, uint32* affected_rows = 0, uint32* last_insert_id = 0, uint32* errnum = 0);
-	inline uint32 QPT()	{ return pQPT; }
-protected:
-	friend class DBAsyncWork;
-	uint32		pQPT;
-
-	friend class DBAsync;
-	void		Process(DBcore* iDBC);
-
-	void		Init(uint32 iQPT, bool iGetResultSet, bool iGetErrbuf);
-	DBAsync::Status pstatus;
-	char*		pQuery;
-	uint32		pQueryLen;
-	bool		pGetResultSet;
-	bool		pGetErrbuf;
-
-	bool		pmysqlsuccess;
-	char*		perrbuf;
-	uint32		perrnum;
-	uint32		paffected_rows;
-	uint32		plast_insert_id;
-	MYSQL_RES*	presult;
-};
-
-
-void AsyncLoadVariables(DBAsync *dba, Database *db);
-
-
-#endif
-

common/dbcore.cpp

@@ -1,17 +1,17 @@
-#include "../common/debug.h"
-
 #ifdef _WINDOWS
 #include <winsock2.h>
 #endif
 
-#include <iostream>
-#include <errmsg.h>
-#include <mysqld_error.h>
-#include <limits.h>
+#include "../common/misc_functions.h"
+#include "../common/eqemu_logsys.h"
+
 #include "dbcore.h"
+
+#include <errmsg.h>
+#include <fstream>
+#include <iostream>
+#include <mysqld_error.h>
 #include <string.h>
-#include "../common/MiscFunctions.h"
-#include <cstdlib>
 
 #ifdef _WINDOWS
 	#define snprintf	_snprintf
@@ -58,93 +58,91 @@ void DBcore::ping() {
 	MDatabase.unlock();
 }
 
-bool DBcore::RunQuery(const char* query, uint32 querylen, char* errbuf, MYSQL_RES** result, uint32* affected_rows, uint32* last_insert_id, uint32* errnum, bool retry) {
-	if (errnum)
-		*errnum = 0;
-	if (errbuf)
-		errbuf[0] = 0;
-	bool ret = false;
+MySQLRequestResult DBcore::QueryDatabase(std::string query, bool retryOnFailureOnce)
+{
+	return QueryDatabase(query.c_str(), query.length(), retryOnFailureOnce);
+}
+
+MySQLRequestResult DBcore::QueryDatabase(const char* query, uint32 querylen, bool retryOnFailureOnce)
+{
 	LockMutex lock(&MDatabase);
+
+	// Reconnect if we are not connected before hand.
 	if (pStatus != Connected)
 		Open();
 
-	if (mysql_real_query(&mysql, query, querylen)) {
-		if (mysql_errno(&mysql) == CR_SERVER_GONE_ERROR)
+	// request query. != 0 indicates some kind of error.
+	if (mysql_real_query(&mysql, query, querylen) != 0)
+	{
+		unsigned int errorNumber = mysql_errno(&mysql);
+
+		if (errorNumber == CR_SERVER_GONE_ERROR)
 			pStatus = Error;
-		if (mysql_errno(&mysql) == CR_SERVER_LOST || mysql_errno(&mysql) == CR_SERVER_GONE_ERROR) {
-			if (retry) {
+
+		// error appears to be a disconnect error, may need to try again.
+		if (errorNumber == CR_SERVER_LOST || errorNumber == CR_SERVER_GONE_ERROR)
+		{
+
+			if (retryOnFailureOnce)
+			{
 				std::cout << "Database Error: Lost connection, attempting to recover...." << std::endl;
-				ret = RunQuery(query, querylen, errbuf, result, affected_rows, last_insert_id, errnum, false);
-				if (ret)
+				MySQLRequestResult requestResult = QueryDatabase(query, querylen, false);
+
+				if (requestResult.Success())
+				{
 					std::cout << "Reconnection to database successful." << std::endl;
+					return requestResult;
+				}
+
 			}
-			else {
-				pStatus = Error;
-				if (errnum)
-					*errnum = mysql_errno(&mysql);
-				if (errbuf)
-					snprintf(errbuf, MYSQL_ERRMSG_SIZE, "#%i: %s", mysql_errno(&mysql), mysql_error(&mysql));
-				std::cout << "DB Query Error #" << mysql_errno(&mysql) << ": " << mysql_error(&mysql) << std::endl;
-				ret = false;
-			}
+
+			pStatus = Error;
+
+			char *errorBuffer = new char[MYSQL_ERRMSG_SIZE];
+
+			snprintf(errorBuffer, MYSQL_ERRMSG_SIZE, "#%i: %s", mysql_errno(&mysql), mysql_error(&mysql));
+
+			return MySQLRequestResult(nullptr, 0, 0, 0, 0, (uint32)mysql_errno(&mysql), errorBuffer);
 		}
-		else {
-			if (errnum)
-				*errnum = mysql_errno(&mysql);
-			if (errbuf)
-				snprintf(errbuf, MYSQL_ERRMSG_SIZE, "#%i: %s", mysql_errno(&mysql), mysql_error(&mysql));
-#ifdef _EQDEBUG
-			std::cout << "DB Query Error #" << mysql_errno(&mysql) << ": " << mysql_error(&mysql) << std::endl;
-#endif
-			ret = false;
+
+		char *errorBuffer = new char[MYSQL_ERRMSG_SIZE];
+		snprintf(errorBuffer, MYSQL_ERRMSG_SIZE, "#%i: %s", mysql_errno(&mysql), mysql_error(&mysql));
+
+		/* Implement Logging at the Root */
+		if (mysql_errno(&mysql) > 0 && strlen(query) > 0){
+			if (Log.log_settings[Logs::MySQLError].is_category_enabled == 1)
+				Log.Out(Logs::General, Logs::MySQLError, "%i: %s \n %s", mysql_errno(&mysql), mysql_error(&mysql), query);
 		}
+
+		return MySQLRequestResult(nullptr, 0, 0, 0, 0, mysql_errno(&mysql),errorBuffer);
+
 	}
-	else {
-		if (result && mysql_field_count(&mysql)) {
-			*result = mysql_store_result(&mysql);
-#ifdef _EQDEBUG
-			DBMemLeak::Alloc(*result, query);
-#endif
-		}
-		else if (result)
-			*result = 0;
-		if (affected_rows)
-			*affected_rows = mysql_affected_rows(&mysql);
-		if (last_insert_id)
-			*last_insert_id = mysql_insert_id(&mysql);
-		if (result) {
-			if (*result) {
-				ret = true;
-			}
-			else {
-#ifdef _EQDEBUG
-				std::cout << "DB Query Error: No Result" << std::endl;
-#endif
-				if (errnum)
-					*errnum = UINT_MAX;
-				if (errbuf)
-					strcpy(errbuf, "DBcore::RunQuery: No Result");
-				ret = false;
-			}
-		}
-		else {
-			ret = true;
-		}
-	}
-#if DEBUG_MYSQL_QUERIES >= 1
-	if (ret) {
-		std::cout << "query successful";
-		if (result && (*result))
-			std::cout << ", " << (int) mysql_num_rows(*result) << " rows returned";
-		if (affected_rows)
-			std::cout << ", " << (*affected_rows) << " rows affected";
-		std::cout<< std::endl;
-	}
-	else {
-		std::cout << "QUERY: query FAILED" << std::endl;
-	}
-#endif
-	return ret;
+
+	// successful query. get results.
+	MYSQL_RES* res = mysql_store_result(&mysql);
+	uint32 rowCount = 0;
+
+	if (res != nullptr)
+        rowCount = (uint32)mysql_num_rows(res);
+
+	MySQLRequestResult requestResult(res, (uint32)mysql_affected_rows(&mysql), rowCount, (uint32)mysql_field_count(&mysql), (uint32)mysql_insert_id(&mysql));
+	
+	if (Log.log_settings[Logs::MySQLQuery].is_category_enabled == 1)
+		Log.Out(Logs::General, Logs::MySQLQuery, "%s (%u rows returned)", query, rowCount, requestResult.RowCount());
+
+	return requestResult;
+}
+
+void DBcore::TransactionBegin() {
+	QueryDatabase("START TRANSACTION");
+}
+
+void DBcore::TransactionCommit() {
+	QueryDatabase("COMMIT");
+}
+
+void DBcore::TransactionRollback() {
+	QueryDatabase("ROLLBACK");
 }
 
 uint32 DBcore::DoEscapeString(char* tobuf, const char* frombuf, uint32 fromlen) {

common/dbcore.h

@@ -4,15 +4,14 @@
 #ifdef _WINDOWS
 	#include <winsock.h>
 	#include <windows.h>
-	//#include <winsock.h>
 #endif
-#include <mysql.h>
+
+#include "../common/mutex.h"
+#include "../common/mysql_request_result.h"
 #include "../common/types.h"
-#include "../common/Mutex.h"
-#include "../common/linked_list.h"
-#include "../common/queue.h"
-#include "../common/timer.h"
-#include "../common/Condition.h"
+
+#include <mysql.h>
+#include <string.h>
 
 class DBcore {
 public:
@@ -21,7 +20,11 @@ public:
 	DBcore();
 	~DBcore();
 	eStatus	GetStatus() { return pStatus; }
-	bool	RunQuery(const char* query, uint32 querylen, char* errbuf = 0, MYSQL_RES** result = 0, uint32* affected_rows = 0, uint32* last_insert_id = 0, uint32* errnum = 0, bool retry = true);
+	MySQLRequestResult	QueryDatabase(const char* query, uint32 querylen, bool retryOnFailureOnce = true);
+	MySQLRequestResult	QueryDatabase(std::string query, bool retryOnFailureOnce = true);
+	void TransactionBegin();
+	void TransactionCommit();
+	void TransactionRollback();
 	uint32	DoEscapeString(char* tobuf, const char* frombuf, uint32 fromlen);
 	void	ping();
 	MYSQL*	getMySQL(){ return &mysql; }

common/dbmemshare.cpp

@@ -1,126 +0,0 @@
-// Doors
-#ifdef SHAREMEM
-int32 Database::GetDoorsCount(uint32* oMaxID) {
-	char errbuf[MYSQL_ERRMSG_SIZE];
-	char *query = 0;
-	MYSQL_RES *result;
-	MYSQL_ROW row;
-	query = new char[256];
-	strcpy(query, "SELECT MAX(id), count(*) FROM doors");
-	if (RunQuery(query, strlen(query), errbuf, &result)) {
-		safe_delete(query);
-		row = mysql_fetch_row(result);
-		if (row && row[1]) {
-			int32 ret = atoi(row[1]);
-			if (oMaxID) {
-				if (row[0])
-					*oMaxID = atoi(row[0]);
-				else
-					*oMaxID = 0;
-			}
-			mysql_free_result(result);
-			return ret;
-		}
-	}
-	else {
-		cerr << "Error in GetDoorsCount query '" << query << "' " << errbuf << endl;
-		delete[] query;
-		return -1;
-	}
-
-	return -1;
-}
-
-extern "C" bool extDBLoadDoors(uint32 iDoorCount, uint32 iMaxDoorID) { return database.DBLoadDoors(iDoorCount, iMaxDoorID); }
-const Door* Database::GetDoor(uint8 door_id, const char* zone_name) {
-	for(uint32 i=0; i<max_door_type; i++) {
-		const Door* door = GetDoorDBID(i);
-		if(door && door->door_id == door_id && strcasecmp(door->zone_name, zone_name) == 0)
-			return door;
-	}
-	return 0;
-}
-
-const Door* Database::GetDoorDBID(uint32 db_id) {
-	return EMuShareMemDLL.Doors.GetDoor(db_id);
-}
-
-bool Database::LoadDoors() {
-	if (!EMuShareMemDLL.Load())
-		return false;
-	int32 tmp_max_door_type = -1;
-	uint32 tmp = 0;
-	tmp_max_door_type = GetDoorsCount(&tmp);
-	if (tmp_max_door_type < 0) {
-		cout << "Error: Database::LoadDoors-ShareMem: GetDoorsCount() returned < 0" << endl;
-		return false;
-	}
-	max_door_type = tmp_max_door_type;
-	bool ret = EMuShareMemDLL.Doors.DLLLoadDoors(&extDBLoadDoors, sizeof(Door), max_door_type, tmp);
-	return ret;
-}
-
-bool Database::DBLoadDoors(uint32 iDoorCount, uint32 iMaxDoorID) {
-	cout << "Loading Doors from database..." << endl;
-	char errbuf[MYSQL_ERRMSG_SIZE];
-	char *query = 0;
-	MYSQL_RES *result;
-	MYSQL_ROW row;
-	query = new char[256];
-	strcpy(query, "SELECT MAX(id), Count(*) FROM doors");
-	if (RunQuery(query, strlen(query), errbuf, &result))
-	{
-		safe_delete(query);
-		row = mysql_fetch_row(result);
-		if (row && row[0]) {
-			if (atoi(row[0]) > iMaxDoorID) {
-				cout << "Error: Insufficient shared memory to load doors." << endl;
-				cout << "Max(id): " << atoi(row[0]) << ", iMaxDoorID: " << iMaxDoorID << endl;
-				cout << "Fix this by increasing the MMF_MAX_Door_ID define statement" << endl;
-				return false;
-			}
-			if (atoi(row[1]) != iDoorCount) {
-				cout << "Error: Insufficient shared memory to load doors." << endl;
-				cout << "Count(*): " << atoi(row[1]) << ", iDoorCount: " << iDoorCount << endl;
-				return false;
-			}
-			max_door_type = atoi(row[0]);
-			mysql_free_result(result);
-			Door tmpDoor;
-				MakeAnyLenString(&query, "SELECT id,doorid,zone,name,pos_x,pos_y,pos_z,heading,opentype,guild,lockpick,keyitem,triggerdoor,triggertype from doors");//WHERE zone='%s'", zone_name
-				if (RunQuery(query, strlen(query), errbuf, &result))
-				{
-					safe_delete(query);
-					while((row = mysql_fetch_row(result))) {
-						memset(&tmpDoor, 0, sizeof(Door));
-						tmpDoor.db_id = atoi(row[0]);
-						tmpDoor.door_id = atoi(row[1]);
-						strn0cpy(tmpDoor.zone_name,row[2],32);
-						strn0cpy(tmpDoor.door_name,row[3],32);
-						tmpDoor.pos_x = (float)atof(row[4]);
-						tmpDoor.pos_y = (float)atof(row[5]);
-						tmpDoor.pos_z = (float)atof(row[6]);
-						tmpDoor.heading = atoi(row[7]);
-						tmpDoor.opentype = atoi(row[8]);
-						tmpDoor.guild_id = atoi(row[9]);
-						tmpDoor.lockpick = atoi(row[10]);
-						tmpDoor.keyitem = atoi(row[11]);
-						tmpDoor.trigger_door = atoi(row[12]);
-						tmpDoor.trigger_type = atoi(row[13]);
-						EMuShareMemDLL.Doors.cbAddDoor(tmpDoor.db_id, &tmpDoor);
-						Sleep(0);
-					}
-					mysql_free_result(result);
-				}
-				else
-				{
-					cerr << "Error in DBLoadDoors query '" << query << "' " << errbuf << endl;
-					delete[] query;
-					return false;
-				}
-			}
-		}
-	return true;
-}
-#endif
-

common/debug.cpp

@@ -1,441 +0,0 @@
-#include <iostream>
-#include <string>
-#include <cstdarg>
-#include <time.h>
-
-#ifdef _WINDOWS
-	#include <process.h>
-
-	#define snprintf	_snprintf
-	#define vsnprintf	_vsnprintf
-	#define strncasecmp	_strnicmp
-	#define strcasecmp	_stricmp
-
-#else
-	
-	#include <sys/types.h>
-	#include <unistd.h>
-
-#endif
-
-#include "debug.h"
-#include "StringUtil.h"
-#include "MiscFunctions.h"
-#include "platform.h"
-
-#ifndef va_copy
-	#define va_copy(d,s) ((d) = (s))
-#endif
-
-static volatile bool logFileValid = false;
-static EQEMuLog realLogFile;
-EQEMuLog *LogFile = &realLogFile;
-
-static const char* FileNames[EQEMuLog::MaxLogID] = { "logs/eqemu", "logs/eqemu", "logs/eqemu_error", "logs/eqemu_debug", "logs/eqemu_quest", "logs/eqemu_commands", "logs/crash" };
-static const char* LogNames[EQEMuLog::MaxLogID] = { "Status", "Normal", "Error", "Debug", "Quest", "Command", "Crash" };
-
-EQEMuLog::EQEMuLog() {
-	for (int i=0; i<MaxLogID; i++) {
-		fp[i] = 0;
-		logCallbackFmt[i] = nullptr;
-		logCallbackBuf[i] = nullptr;
-		logCallbackPva[i] = nullptr;
-	}
-	
-	pLogStatus[Status] = LOG_LEVEL_STATUS;
-	pLogStatus[Normal] = LOG_LEVEL_NORMAL;
-	pLogStatus[Error] = LOG_LEVEL_ERROR;
-	pLogStatus[Debug] = LOG_LEVEL_DEBUG;
-	pLogStatus[Quest] = LOG_LEVEL_QUEST;
-	pLogStatus[Commands] = LOG_LEVEL_COMMANDS;
-	pLogStatus[Crash] = LOG_LEVEL_CRASH;
-	logFileValid = true;
-}
-
-EQEMuLog::~EQEMuLog() {
-	logFileValid = false;
-	for (int i=0; i<MaxLogID; i++) {
-		LockMutex lock(&MLog[i]);	//to prevent termination race
-		if (fp[i])
-			fclose(fp[i]);
-	}
-}
-
-bool EQEMuLog::open(LogIDs id) {
-	if (!logFileValid) {
-		return false;
-	}
-	if (id >= MaxLogID) {
-		return false;
-	}
-	LockMutex lock(&MOpen);
-	if (pLogStatus[id] & 4) {
-		return false;
-	}
-	if (fp[id]) {
-		//cerr<<"Warning: LogFile already open"<<endl;
-		return true;
-	}
-
-	char exename[200] = "";
-	const EQEmuExePlatform &platform = GetExecutablePlatform();
-	if(platform == ExePlatformWorld) {
-		snprintf(exename, sizeof(exename), "_world");
-	} else if(platform == ExePlatformZone) {
-		snprintf(exename, sizeof(exename), "_zone");
-	} else if(platform == ExePlatformLaunch) {
-		snprintf(exename, sizeof(exename), "_launch");
-	} else if(platform == ExePlatformUCS) {
-		snprintf(exename, sizeof(exename), "_ucs");
-	} else if(platform == ExePlatformQueryServ) {
-		snprintf(exename, sizeof(exename), "_queryserv");
-	} else if(platform == ExePlatformSharedMemory) {
-		snprintf(exename, sizeof(exename), "_shared_memory");
-	} else if(platform == ExePlatformClientImport) {
-		snprintf(exename, sizeof(exename), "_import");
-	} else if(platform == ExePlatformClientExport) {
-		snprintf(exename, sizeof(exename), "_export");
-	}
-
-	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]) {
-		std::cerr << "Failed to open log file: " << filename << std::endl;
-		pLogStatus[id] |= 4; // set file state to error
-		return false;
-	}
-	fputs("---------------------------------------------\n",fp[id]);
-	write(id, "Starting Log: %s", filename);
-	return true;
-}
-
-bool EQEMuLog::write(LogIDs id, const char *fmt, ...) {
-	if (!logFileValid) {
-		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]);
-	if (!logFileValid)
-		return false;	//check again for threading race reasons (to avoid two mutexes)
-
-	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
-
-	va_list argptr, tmpargptr;
-	va_start(argptr, fmt);
-	if (dofile) {
-		va_copy(tmpargptr, argptr);
-		vfprintf( fp[id], fmt, tmpargptr );
-	}
-	if(logCallbackFmt[id]) {
-		msgCallbackFmt p = logCallbackFmt[id];
-		va_copy(tmpargptr, argptr);
-		p(id, fmt, tmpargptr );
-	}
-	if (pLogStatus[id] & 2) {
-		if (pLogStatus[id] & 8) {
-			fprintf(stderr, "[%s] ", LogNames[id]);
-			vfprintf( stderr, fmt, argptr );
-		}
-		else {
-			fprintf(stdout, "[%s] ", LogNames[id]);
-			vfprintf( stdout, fmt, argptr );
-		}
-	}
-	va_end(argptr);
-	if (dofile)
-		fprintf(fp[id], "\n");
-	if (pLogStatus[id] & 2) {
-		if (pLogStatus[id] & 8) {
-			fprintf(stderr, "\n");
-			fflush(stderr);
-		} else {
-			fprintf(stdout, "\n");
-			fflush(stdout);
-		}
-	}
-	if(dofile)
-		fflush(fp[id]);
-	return true;
-}
-
-//write with Prefix and a VA_list
-bool EQEMuLog::writePVA(LogIDs id, const char *prefix, const char *fmt, va_list argptr) {
-	if (!logFileValid) {
-		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]);
-	if (!logFileValid)
-		return false;	//check again for threading race reasons (to avoid two mutexes)
-
-	time_t aclock;
-	struct tm *newtime;
-
-	time( &aclock ); /* Get time in seconds */
-	newtime = localtime( &aclock ); /* Convert time to struct */
-
-	va_list tmpargptr;
-
-	if (dofile) {
-#ifndef NO_PIDLOG
-		fprintf(fp[id], "[%02d.%02d. - %02d:%02d:%02d] %s", newtime->tm_mon+1, newtime->tm_mday, newtime->tm_hour, newtime->tm_min, newtime->tm_sec, prefix);
-#else
-		fprintf(fp[id], "%04i [%02d.%02d. - %02d:%02d:%02d] %s", getpid(), newtime->tm_mon+1, newtime->tm_mday, newtime->tm_hour, newtime->tm_min, newtime->tm_sec, prefix);
-#endif
-		va_copy(tmpargptr, argptr);
-		vfprintf( fp[id], fmt, tmpargptr );
-	}
-	if(logCallbackPva[id]) {
-		msgCallbackPva p = logCallbackPva[id];
-		va_copy(tmpargptr, argptr);
-		p(id, prefix, fmt, tmpargptr );
-	}
-	if (pLogStatus[id] & 2) {
-		if (pLogStatus[id] & 8) {
-			fprintf(stderr, "[%s] %s", LogNames[id], prefix);
-			vfprintf( stderr, fmt, argptr );
-		}
-		else {
-			fprintf(stdout, "[%s] %s", LogNames[id], prefix);
-			vfprintf( stdout, fmt, argptr );
-		}
-	}
-	va_end(argptr);
-	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, uint8 size, uint32 count) {
-	if (!logFileValid) {
-		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]);
-	if (!logFileValid)
-		return false;	//check again for threading race reasons (to avoid two mutexes)
-
-	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, ...) {
-	va_list argptr, tmpargptr;
-	va_start(argptr, fmt);
-	if (dofile) {
-		va_copy(tmpargptr, argptr);
-		vfprintf( fp[id], fmt, tmpargptr );
-	}
-	if (pLogStatus[id] & 2) {
-		if (pLogStatus[id] & 8)
-			vfprintf( stderr, fmt, argptr );
-		else
-			vfprintf( stdout, fmt, argptr );
-	}
-	va_end(argptr);
-	return true;
-};
-
-bool EQEMuLog::Dump(LogIDs id, uint8* data, uint32 size, uint32 cols, uint32 skip) {
-	if (!logFileValid) {
-#if EQDEBUG >= 10
-	std::cerr << "Error: Dump() from null pointer" << std::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]);
-	if (!logFileValid)
-		return false;	//check again for threading race reasons (to avoid two mutexes)
-
-	write(id, "Dumping Packet: %i", size);
-	// Output as HEX
-	
-	int beginningOfLineOffset = 0; 
-	uint32 indexInData;
-	std::string asciiOutput;
-
-	for(indexInData=skip; indexInData<size; indexInData++) {
-		if ((indexInData-skip)%cols==0) {
-			if (indexInData != skip)
-				writeNTS(id, dofile, " | %s\n", asciiOutput.c_str());
-			writeNTS(id, dofile, "%4i: ", indexInData-skip);
-			asciiOutput.clear();
-			beginningOfLineOffset = 0;
-		}
-		else if ((indexInData-skip)%(cols/2) == 0) {
-			writeNTS(id, dofile, "- ");
-		}
-		writeNTS(id, dofile, "%02X ", (unsigned char)data[indexInData]);
-
-		if (data[indexInData] >= 32 && data[indexInData] < 127)
-		{
-			// According to http://msdn.microsoft.com/en-us/library/vstudio/ee404875(v=vs.100).aspx
-			// Visual Studio 2010 doesn't have std::to_string(int) but it does have the long long 
-			// version.
-			asciiOutput.append(std::to_string((long long)data[indexInData]));
-		}
-		else
-		{
-			asciiOutput.append(".");
-		}
-	}
-	uint32 k = ((indexInData-skip)-1)%cols;
-	if (k < 8)
-		writeNTS(id, dofile, "  ");
-	for (uint32 h = k+1; h < cols; h++) {
-		writeNTS(id, dofile, "   ");
-	}
-	writeNTS(id, dofile, " | %s\n", asciiOutput.c_str());
-	if (dofile)
-		fflush(fp[id]);
-	return true;
-}
-
-void EQEMuLog::SetCallback(LogIDs id, msgCallbackFmt proc) {
-	if (!logFileValid)
-		return;
-	if (id >= MaxLogID) {
-		return;
-	}
-	logCallbackFmt[id] = proc;
-}
-
-void EQEMuLog::SetCallback(LogIDs id, msgCallbackBuf proc) {
-	if (!logFileValid)
-		return;
-	if (id >= MaxLogID) {
-		return;
-	}
-	logCallbackBuf[id] = proc;
-}
-
-void EQEMuLog::SetCallback(LogIDs id, msgCallbackPva proc) {
-	if (!logFileValid)
-		return;
-	if (id >= MaxLogID) {
-		return;
-	}
-	logCallbackPva[id] = proc;
-}
-
-void EQEMuLog::SetAllCallbacks(msgCallbackFmt proc) {
-	if (!logFileValid)
-		return;
-	int r;
-	for(r = Status; r < MaxLogID; r++) {
-		SetCallback((LogIDs)r, proc);
-	}
-}
-
-void EQEMuLog::SetAllCallbacks(msgCallbackBuf proc) {
-	if (!logFileValid)
-		return;
-	int r;
-	for(r = Status; r < MaxLogID; r++) {
-		SetCallback((LogIDs)r, proc);
-	}
-}
-
-void EQEMuLog::SetAllCallbacks(msgCallbackPva proc) {
-	if (!logFileValid)
-		return;
-	int r;
-	for(r = Status; r < MaxLogID; r++) {
-		SetCallback((LogIDs)r, proc);
-	}
-}
-

common/debug.h

@@ -1,147 +0,0 @@
-/*	EQEMu: Everquest Server Emulator
-	Copyright (C) 2001-2002 EQEMu Development Team (http://eqemu.org)
-
-	This program 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; version 2 of the License.
-
-	This program is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY except by those people which sell it, which
-	are required to give you total support for your newly bought product;
-	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 this program; if not, write to the Free Software
-	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-*/
-
-// Debug Levels
-#ifndef EQDEBUG
-#define EQDEBUG 1
-#else
-////// File/Console options
-// 0 <= Quiet mode Errors to file Status and Normal ignored
-// 1 >= Status and Normal to console, Errors to file
-// 2 >= Status, Normal, and Error to console and logfile
-// 3 >= Lite debug
-// 4 >= Medium debug
-// 5 >= Debug release (Anything higher is not recommended for regular use)
-// 6 == (Reserved for special builds) Login opcode debug All packets dumped
-// 7 == (Reserved for special builds) Chat Opcode debug All packets dumped
-// 8 == (Reserved for special builds) World opcode debug All packets dumped
-// 9 == (Reserved for special builds) Zone Opcode debug All packets dumped
-// 10 >= More than you ever wanted to know
-//
-/////
-// Add more below to reserve for file's functions ect.
-/////
-// Any setup code based on defines should go here
-//
-#endif
-
-
-#if defined(_DEBUG) && defined(WIN32)
-	#ifndef _CRTDBG_MAP_ALLOC
-		#include <stdlib.h>
-		#include <crtdbg.h>
-	#endif
-#endif
-
-#ifndef EQDEBUG_H
-#define EQDEBUG_H
-
-#ifndef _WINDOWS
-	#define DebugBreak()			if(0) {}
-#endif
-
-#define _WINSOCKAPI_	//stupid windows, trying to fix the winsock2 vs. winsock issues
-#if defined(WIN32) && ( defined(PACKETCOLLECTOR) || defined(COLLECTOR) )
-	// Packet Collector on win32 requires winsock.h due to latest pcap.h
-	// winsock.h must come before windows.h
-	#include <winsock.h>
-#endif
-
-#ifdef _WINDOWS
-	#include <windows.h>
-	#include <winsock2.h>
-#endif
-
-#include "logsys.h"
-
-#include "../common/Mutex.h"
-#include <stdio.h>
-#include <stdarg.h>
-
-
-class EQEMuLog {
-public:
-	EQEMuLog();
-	~EQEMuLog();
-
-	enum LogIDs {
-		Status = 0,	//this must stay the first entry in this list
-		Normal,
-		Error,
-		Debug,
-		Quest,
-		Commands,
-		Crash,
-		MaxLogID
-	};
-
-	//these are callbacks called for each
-	typedef void (* msgCallbackBuf)(LogIDs id, const char *buf, uint8 size, uint32 count);
-	typedef void (* msgCallbackFmt)(LogIDs id, const char *fmt, va_list ap);
-	typedef void (* msgCallbackPva)(LogIDs id, const char *prefix, const char *fmt, va_list ap);
-
-	void SetAllCallbacks(msgCallbackFmt proc);
-	void SetAllCallbacks(msgCallbackBuf proc);
-	void SetAllCallbacks(msgCallbackPva proc);
-	void SetCallback(LogIDs id, msgCallbackFmt proc);
-	void SetCallback(LogIDs id, msgCallbackBuf proc);
-	void SetCallback(LogIDs id, msgCallbackPva proc);
-
-	bool writebuf(LogIDs id, const char *buf, uint8 size, uint32 count);
-	bool write(LogIDs id, const char *fmt, ...);
-	bool writePVA(LogIDs id, const char *prefix, const char *fmt, va_list args);
-	bool Dump(LogIDs id, uint8* data, uint32 size, uint32 cols=16, uint32 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
-
-	Mutex	MOpen;
-	Mutex	MLog[MaxLogID];
-	FILE*	fp[MaxLogID];
-/* LogStatus: bitwise variable
-	1 = output to file
-	2 = output to stdout
-	4 = fopen error, dont retry
-	8 = use stderr instead (2 must be set)
-*/
-	uint8	pLogStatus[MaxLogID];
-
-	msgCallbackFmt logCallbackFmt[MaxLogID];
-	msgCallbackBuf logCallbackBuf[MaxLogID];
-	msgCallbackPva logCallbackPva[MaxLogID];
-};
-
-extern EQEMuLog* LogFile;
-
-#ifdef _EQDEBUG
-class PerformanceMonitor {
-public:
-	PerformanceMonitor(int64* ip) {
-		p = ip;
-		QueryPerformanceCounter(&tmp);
-	}
-	~PerformanceMonitor() {
-		LARGE_INTEGER tmp2;
-		QueryPerformanceCounter(&tmp2);
-		*p += tmp2.QuadPart - tmp.QuadPart;
-	}
-	LARGE_INTEGER tmp;
-	int64* p;
-};
-#endif
-#endif

common/emu_opcodes.cpp

@@ -16,7 +16,7 @@
 	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 04111-1307 USA
 */
 
-#include "debug.h"
+#include "global_define.h"
 #include "emu_opcodes.h"
 
 const char *OpcodeNames[_maxEmuOpcode+1] = {

common/emu_tcp_connection.cpp

@@ -23,17 +23,14 @@ crap into its own subclass of this object, it will clean things up
 tremendously.
 */
 
-#include "../common/debug.h"
+#include "../common/global_define.h"
 
 #include <iostream>
 #include <string.h>
-#include <stdio.h>
-#include <iomanip>
 
-#include "EmuTCPConnection.h"
-#include "EmuTCPServer.h"
+#include "emu_tcp_connection.h"
+#include "emu_tcp_server.h"
 #include "../common/servertalk.h"
-#include "../common/packet_dump.h"
 
 #ifdef FREEBSD //Timothy Whitman - January 7, 2003
 	#define MSG_NOSIGNAL 0
@@ -53,6 +50,7 @@ EmuTCPConnection::EmuTCPConnection(uint32 ID, EmuTCPServer* iServer, SOCKET in_s
 	keepalive_timer(SERVER_TIMEOUT),
 	timeout_timer(SERVER_TIMEOUT * 2)
 {
+	_eqp
 	id = 0;
 	Server = nullptr;
 	pOldFormat = iOldFormat;
@@ -79,6 +77,7 @@ EmuTCPConnection::EmuTCPConnection(bool iOldFormat, EmuTCPServer* iRelayServer,
 	keepalive_timer(SERVER_TIMEOUT),
 	timeout_timer(SERVER_TIMEOUT * 2)
 {
+	_eqp
 	Server = iRelayServer;
 	if (Server)
 		RelayServer = true;
@@ -101,13 +100,14 @@ EmuTCPConnection::EmuTCPConnection(uint32 ID, EmuTCPServer* iServer, EmuTCPConne
 	keepalive_timer(SERVER_TIMEOUT),
 	timeout_timer(SERVER_TIMEOUT * 2)
 {
+	_eqp
 	Server = iServer;
 	RelayLink = iRelayLink;
 	RelayServer = true;
 	RelayCount = 0;
 	RemoteID = iRemoteID;
 	pOldFormat = false;
-	ConnectionType = Incomming;
+	ConnectionType = Incoming;
 	TCPMode = modePacket;
 	PacketMode = packetModeZone;
 #if TCPN_DEBUG_Memory >= 7
@@ -120,6 +120,7 @@ EmuTCPConnection::~EmuTCPConnection() {
 }
 
 EmuTCPNetPacket_Struct* EmuTCPConnection::MakePacket(ServerPacket* pack, uint32 iDestination) {
+	_eqp
 	int32 size = sizeof(EmuTCPNetPacket_Struct) + pack->size;
 	if (pack->compressed) {
 		size += 4;
@@ -147,6 +148,7 @@ EmuTCPNetPacket_Struct* EmuTCPConnection::MakePacket(ServerPacket* pack, uint32
 }
 
 SPackSendQueue* EmuTCPConnection::MakeOldPacket(ServerPacket* pack) {
+	_eqp
 	SPackSendQueue* spsq = (SPackSendQueue*) new uchar[sizeof(SPackSendQueue) + pack->size + 4];
 	if (pack->pBuffer != 0 && pack->size != 0)
 		memcpy((char *) &spsq->buffer[4], (char *) pack->pBuffer, pack->size);
@@ -157,6 +159,7 @@ SPackSendQueue* EmuTCPConnection::MakeOldPacket(ServerPacket* pack) {
 }
 
 bool EmuTCPConnection::SendPacket(ServerPacket* pack, uint32 iDestination) {
+	_eqp
 	if (!Connected())
 		return false;
 	eTCPMode tmp = GetMode();
@@ -217,6 +220,7 @@ bool EmuTCPConnection::SendPacket(ServerPacket* pack, uint32 iDestination) {
 }
 
 bool EmuTCPConnection::SendPacket(EmuTCPNetPacket_Struct* tnps) {
+	_eqp
 	if (RemoteID)
 		return false;
 	if (!Connected())
@@ -257,6 +261,7 @@ bool EmuTCPConnection::SendPacket(EmuTCPNetPacket_Struct* tnps) {
 }
 
 ServerPacket* EmuTCPConnection::PopPacket() {
+	_eqp
 	ServerPacket* ret;
 	if (!MOutQueueLock.trylock())
 		return nullptr;
@@ -266,12 +271,14 @@ ServerPacket* EmuTCPConnection::PopPacket() {
 }
 
 void EmuTCPConnection::InModeQueuePush(EmuTCPNetPacket_Struct* tnps) {
+	_eqp
 	MSendQueue.lock();
 	InModeQueue.push(tnps);
 	MSendQueue.unlock();
 }
 
 void EmuTCPConnection::OutQueuePush(ServerPacket* pack) {
+	_eqp
 	MOutQueueLock.lock();
 	OutQueue.push(pack);
 	MOutQueueLock.unlock();
@@ -279,6 +286,7 @@ void EmuTCPConnection::OutQueuePush(ServerPacket* pack) {
 
 
 bool EmuTCPConnection::LineOutQueuePush(char* line) {
+	_eqp
 	#if defined(GOTFRAGS) && 0
 		if (strcmp(line, "**CRASHME**") == 0) {
 			int i = 0;
@@ -366,13 +374,13 @@ bool EmuTCPConnection::LineOutQueuePush(char* line) {
 			safe_delete_array(line);
 			return(true);
 		}
-
 	}
 
 	return(TCPConnection::LineOutQueuePush(line));
 }
 
 void EmuTCPConnection::Disconnect(bool iSendRelayDisconnect) {
+	_eqp
 	TCPConnection::Disconnect();
 
 	if (RelayLink) {
@@ -382,6 +390,7 @@ void EmuTCPConnection::Disconnect(bool iSendRelayDisconnect) {
 }
 
 bool EmuTCPConnection::ConnectIP(uint32 irIP, uint16 irPort, char* errbuf) {
+	_eqp
 	if(!TCPConnection::ConnectIP(irIP, irPort, errbuf))
 		return(false);
 
@@ -419,7 +428,8 @@ bool EmuTCPConnection::ConnectIP(uint32 irIP, uint16 irPort, char* errbuf) {
 				sendbuf_used = sendbuf_size;
 				sendbuf = new uchar[sendbuf_size];
 				memcpy(sendbuf, "\0**PACKETMODEQS**\r", sendbuf_size);
-			} else {
+			} 
+			else {
 				//default: packetModeZone
 				safe_delete_array(sendbuf);
 				sendbuf_size = 20;
@@ -435,6 +445,7 @@ bool EmuTCPConnection::ConnectIP(uint32 irIP, uint16 irPort, char* errbuf) {
 }
 
 void EmuTCPConnection::ClearBuffers() {
+	_eqp
 	TCPConnection::ClearBuffers();
 
 	LockMutex lock2(&MOutQueueLock);
@@ -451,6 +462,7 @@ void EmuTCPConnection::ClearBuffers() {
 }
 
 void EmuTCPConnection::SendNetErrorPacket(const char* reason) {
+	_eqp
 	#if TCPC_DEBUG >= 1
 		struct in_addr	in;
 		in.s_addr = GetrIP();
@@ -472,6 +484,7 @@ void EmuTCPConnection::SendNetErrorPacket(const char* reason) {
 }
 
 void EmuTCPConnection::RemoveRelay(EmuTCPConnection* relay, bool iSendRelayDisconnect) {
+	_eqp
 	if (iSendRelayDisconnect) {
 		ServerPacket* pack = new ServerPacket(0, 5);
 		pack->pBuffer[0] = 3;
@@ -485,6 +498,7 @@ void EmuTCPConnection::RemoveRelay(EmuTCPConnection* relay, bool iSendRelayDisco
 
 
 bool EmuTCPConnection::ProcessReceivedData(char* errbuf) {
+	_eqp
 	if (errbuf)
 		errbuf[0] = 0;
 	timeout_timer.Start();
@@ -508,6 +522,7 @@ bool EmuTCPConnection::ProcessReceivedData(char* errbuf) {
 
 
 bool EmuTCPConnection::ProcessReceivedDataAsPackets(char* errbuf) {
+	_eqp
 	if (errbuf)
 		errbuf[0] = 0;
 	int32 base = 0;
@@ -624,6 +639,7 @@ bool EmuTCPConnection::ProcessReceivedDataAsPackets(char* errbuf) {
 }
 
 bool EmuTCPConnection::ProcessReceivedDataAsOldPackets(char* errbuf) {
+	_eqp
 	int32 base = 0;
 	int32 size = 4;
 	uchar* buffer;
@@ -698,6 +714,7 @@ bool EmuTCPConnection::ProcessReceivedDataAsOldPackets(char* errbuf) {
 }
 
 void EmuTCPConnection::ProcessNetworkLayerPacket(ServerPacket* pack) {
+	_eqp
 	uint8 opcode = pack->pBuffer[0];
 	uint8* data = &pack->pBuffer[1];
 	switch (opcode) {
@@ -717,7 +734,7 @@ void EmuTCPConnection::ProcessNetworkLayerPacket(ServerPacket* pack) {
 				SendNetErrorPacket("Switch to RelayServer mode by a Relay Client");
 				break;
 			}
-			if (ConnectionType != Incomming) {
+			if (ConnectionType != Incoming) {
 				SendNetErrorPacket("Switch to RelayServer mode on outgoing connection");
 				break;
 			}
@@ -738,7 +755,7 @@ void EmuTCPConnection::ProcessNetworkLayerPacket(ServerPacket* pack) {
 				SendNetErrorPacket("New RelayClient: wrong size, expected 11");
 				break;
 			}
-			if (ConnectionType != Incomming) {
+			if (ConnectionType != Incoming) {
 				SendNetErrorPacket("New RelayClient: illegal on outgoing connection");
 				break;
 			}
@@ -758,7 +775,7 @@ void EmuTCPConnection::ProcessNetworkLayerPacket(ServerPacket* pack) {
 			}
 			EmuTCPConnection* con = Server->FindConnection(*((uint32*)data));
 			if (con) {
-				if (ConnectionType == Incomming) {
+				if (ConnectionType == Incoming) {
 					if (con->GetRelayLink() != this) {
 						SendNetErrorPacket("Delete RelayClient: RelayLink != this");
 						break;
@@ -783,6 +800,7 @@ void EmuTCPConnection::ProcessNetworkLayerPacket(ServerPacket* pack) {
 }
 
 bool EmuTCPConnection::SendData(bool &sent_something, char* errbuf) {
+	_eqp
 	sent_something = false;
 	if(!TCPConnection::SendData(sent_something, errbuf))
 		return(false);
@@ -802,6 +820,7 @@ bool EmuTCPConnection::SendData(bool &sent_something, char* errbuf) {
 }
 
 bool EmuTCPConnection::RecvData(char* errbuf) {
+	_eqp
 	if(!TCPConnection::RecvData(errbuf)) {
 		if (OutQueue.count())
 			return(true);

common/emu_tcp_connection.h

@@ -1,7 +1,7 @@
 #ifndef EmuTCPCONNECTION_H_
 #define EmuTCPCONNECTION_H_
 
-#include "TCPConnection.h"
+#include "tcp_connection.h"
 #include "timer.h"
 
 //moved out of TCPConnection:: to be more exportable
@@ -26,6 +26,7 @@
 
 struct SPackSendQueue;
 class EmuTCPServer;
+class ServerPacket;
 
 class EmuTCPConnection : public TCPConnection {
 public:

common/emu_tcp_server.cpp

@@ -1,6 +1,6 @@
-#include "debug.h"
-#include "EmuTCPServer.h"
-#include "EmuTCPConnection.h"
+#include "global_define.h"
+#include "emu_tcp_server.h"
+#include "emu_tcp_connection.h"
 
 EmuTCPServer::EmuTCPServer(uint16 iPort, bool iOldFormat)
 :	TCPServer<EmuTCPConnection>(iPort),
@@ -9,6 +9,7 @@ EmuTCPServer::EmuTCPServer(uint16 iPort, bool iOldFormat)
 }
 
 EmuTCPServer::~EmuTCPServer() {
+	_eqp
 	MInQueue.lock();
 	while(!m_InQueue.empty()) {
 		delete m_InQueue.front();
@@ -18,23 +19,27 @@ EmuTCPServer::~EmuTCPServer() {
 }
 
 void EmuTCPServer::Process() {
+	_eqp
 	CheckInQueue();
 	TCPServer<EmuTCPConnection>::Process();
 }
 
 void EmuTCPServer::CreateNewConnection(uint32 ID, SOCKET in_socket, uint32 irIP, uint16 irPort)
 {
+	_eqp
 	EmuTCPConnection *conn = new EmuTCPConnection(ID, this, in_socket, irIP, irPort, pOldFormat);
 	AddConnection(conn);
 }
 
 
 void EmuTCPServer::SendPacket(ServerPacket* pack) {
+	_eqp
 	EmuTCPNetPacket_Struct* tnps = EmuTCPConnection::MakePacket(pack);
 	SendPacket(&tnps);
 }
 
 void EmuTCPServer::SendPacket(EmuTCPNetPacket_Struct** tnps) {
+	_eqp
 	MInQueue.lock();
 	m_InQueue.push(*tnps);
 	MInQueue.unlock();
@@ -42,6 +47,7 @@ void EmuTCPServer::SendPacket(EmuTCPNetPacket_Struct** tnps) {
 }
 
 void EmuTCPServer::CheckInQueue() {
+	_eqp
 	EmuTCPNetPacket_Struct* tnps = 0;
 
 	while (( tnps = InQueuePop() )) {
@@ -57,6 +63,7 @@ void EmuTCPServer::CheckInQueue() {
 }
 
 EmuTCPNetPacket_Struct* EmuTCPServer::InQueuePop() {
+	_eqp
 	EmuTCPNetPacket_Struct* ret = nullptr;
 	MInQueue.lock();
 	if(!m_InQueue.empty()) {
@@ -69,6 +76,7 @@ EmuTCPNetPacket_Struct* EmuTCPServer::InQueuePop() {
 
 
 EmuTCPConnection *EmuTCPServer::FindConnection(uint32 iID) {
+	_eqp
 	vitr cur, end;
 	cur = m_list.begin();
 	end = m_list.end();

common/emu_tcp_server.h

@@ -1,7 +1,7 @@
 #ifndef EmuTCPSERVER_H_
 #define EmuTCPSERVER_H_
 
-#include "TCPServer.h"
+#include "tcp_server.h"
 
 class EmuTCPConnection;
 struct EmuTCPNetPacket_Struct;

common/eq_constants.h

@@ -19,6 +19,7 @@
 #define EQ_CONSTANTS_H
 
 #include "skills.h"
+#include "types.h"
 
 /*
 **	Item attributes
@@ -138,45 +139,86 @@ enum ItemUseTypes : uint8
 };
 
 /*
-**	Augmentation use types (in-work)
+**	Augmentation use type bitmasks (1-based)
 **
 **	(ref: dbstr_us.txt)
 **
 */
-enum AugmentationUseTypes : uint32 {
-	AugTypeNone = 0,				// not 100% sure on this...
-	AugTypeGeneralSingleStat,		/*1^16^1 (General: Single Stat)^0*/
-	AugTypeGeneralMultipleStat,		/*2^16^2 (General: Multiple Stat)^0*/
-	AugTypeGeneralSpellEffect,		/*3^16^3 (General: Spell Effect)^0*/
-	AugTypeWeaponGeneral,			/*4^16^4 (Weapon: General)^0*/
-	AugTypeWeaponElemDamage,		/*5^16^5 (Weapon: Elem Damage)^0*/
-	AugTypeWeaponBaseDamage,		/*6^16^6 (Weapon: Base Damage)^0*/
-	AugTypeGeneralGroup,			/*7^16^7 (General: Group)^0*/
-	AugTypeGeneralRaid,				/*8^16^8 (General: Raid)^0*/
-	AugTypeGeneralDragonsPoints,	/*9^16^9 (General: Dragons Points)^0*/
-	AugTypeCraftedCommon,			/*10^16^10 (Crafted: Common)^0*/
-	AugTypeCraftedGroup1,			/*11^16^11 (Crafted: Group)^0*/
-	AugTypeCraftedRaid1,			/*12^16^12 (Crafted: Raid)^0*/
-	AugTypeEnergeiacGroup,			/*13^16^13 (Energeiac: Group)^0*/
-	AugTypeEnergeiacRaid,			/*14^16^14 (Energeiac: Raid)^0*/
-	AugTypeEmblem,					/*15^16^15 (Emblem)^0*/
-	AugTypeCraftedGroup2,			/*16^16^16 (Crafted: Group)^0*/
-	AugTypeCraftedRaid2,			/*17^16^17 (Crafted: Raid)^0*/
-	AugTypeUnknown1,				/*18^16^18^0*/
-	AugTypeUnknown2,				/*19^16^19^0*/
-	AugTypeOrnamentation,			/*20^16^20 (Ornamentation)^0*/
-	AugTypeSpecialOrnamentation,	/*21^16^21 (Special Ornamentation)^0*/
-	AugTypeUnknown3,				/*22^16^22^0*/
-	AugTypeUnknown4,				/*23^16^23^0*/
-	AugTypeUnknown5,				/*24^16^24^0*/
-	AugTypeUnknown6,				/*25^16^25^0*/
-	AugTypeUnknown7,				/*26^16^26^0*/
-	AugTypeUnknown8,				/*27^16^27^0*/
-	AugTypeUnknown9,				/*28^16^28^0*/
-	AugTypeUnknown10,				/*29^16^29^0*/
-	AugTypeEpic25,					/*30^16^30^0*/
-	AugTypeTest,					/*31^16^Test^0*/ // listed as 31^16^31^0 in 5-10 client
-	_AugTypeCount
+enum AugmentationUseTypeBitmasks : uint32 {
+	AugUseNone					= 0x00000000,
+	AugUseGeneralSingleStat		= 0x00000001,	/*1^16^1 (General: Single Stat)^0*/
+	AugUseGeneralMultipleStat	= 0x00000002,	/*2^16^2 (General: Multiple Stat)^0*/
+	AugUseGeneralSpellEffect	= 0x00000004,	/*3^16^3 (General: Spell Effect)^0*/
+	AugUseWeaponGeneral			= 0x00000008,	/*4^16^4 (Weapon: General)^0*/
+	AugUseWeaponElemDamage		= 0x00000010,	/*5^16^5 (Weapon: Elem Damage)^0*/
+	AugUseWeaponBaseDamage		= 0x00000020,	/*6^16^6 (Weapon: Base Damage)^0*/
+	AugUseGeneralGroup			= 0x00000040,	/*7^16^7 (General: Group)^0*/
+	AugUseGeneralRaid			= 0x00000080,	/*8^16^8 (General: Raid)^0*/
+	AugUseGeneralDragonsPoints	= 0x00000100,	/*9^16^9 (General: Dragons Points)^0*/
+	AugUseCraftedCommon			= 0x00000200,	/*10^16^10 (Crafted: Common)^0*/
+	AugUseCraftedGroup1			= 0x00000400,	/*11^16^11 (Crafted: Group)^0*/
+	AugUseCraftedRaid1			= 0x00000800,	/*12^16^12 (Crafted: Raid)^0*/
+	AugUseEnergeiacGroup		= 0x00001000,	/*13^16^13 (Energeiac: Group)^0*/
+	AugUseEnergeiacRaid			= 0x00002000,	/*14^16^14 (Energeiac: Raid)^0*/
+	AugUseEmblem				= 0x00004000,	/*15^16^15 (Emblem)^0*/
+	AugUseCraftedGroup2			= 0x00008000,	/*16^16^16 (Crafted: Group)^0*/
+	AugUseCraftedRaid2			= 0x00010000,	/*17^16^17 (Crafted: Raid)^0*/
+	AugUseUnknown1				= 0x00020000,	/*18^16^18^0*/
+	AugUseUnknown2				= 0x00040000,	/*19^16^19^0*/
+	AugUseOrnamentation			= 0x00080000,	/*20^16^20 (Ornamentation)^0*/
+	AugUseSpecialOrnamentation	= 0x00100000,	/*21^16^21 (Special Ornamentation)^0*/
+	AugUseUnknown3				= 0x00200000,	/*22^16^22^0*/
+	AugUseUnknown4				= 0x00400000,	/*23^16^23^0*/
+	AugUseUnknown5				= 0x00800000,	/*24^16^24^0*/
+	AugUseUnknown6				= 0x01000000,	/*25^16^25^0*/
+	AugUseUnknown7				= 0x02000000,	/*26^16^26^0*/
+	AugUseUnknown8				= 0x04000000,	/*27^16^27^0*/
+	AugUseUnknown9				= 0x08000000,	/*28^16^28^0*/
+	AugUseUnknown10				= 0x10000000,	/*29^16^29^0*/
+	AugUseEpic25				= 0x20000000,	/*30^16^30^0*/
+	AugUseTest					= 0x40000000,	/*31^16^Test^0*/ // listed as 31^16^31^0 in 5-10 client
+	AugUseAll					= 0xFFFFFFFF
+};
+
+/*
+**	Augmentation use types (enumerated)
+**
+*/
+enum AugmentationUseTypes : uint8 {
+	AugTypeNone = 0,
+	AugTypeGeneralSingleStat,
+	AugTypeGeneralMultipleStat,
+	AugTypeGeneralSpellEffect,
+	AugTypeWeaponGeneral,
+	AugTypeWeaponElemDamage,
+	AugTypeWeaponBaseDamage,
+	AugTypeGeneralGroup,
+	AugTypeGeneralRaid,
+	AugTypeGeneralDragonsPoints,
+	AugTypeCraftedCommon,
+	AugTypeCraftedGroup1,
+	AugTypeCraftedRaid1,
+	AugTypeEnergeiacGroup,
+	AugTypeEnergeiacRaid,
+	AugTypeEmblem,
+	AugTypeCraftedGroup2,
+	AugTypeCraftedRaid2,
+	AugTypeUnknown1,
+	AugTypeUnknown2,
+	AugTypeOrnamentation,
+	AugTypeSpecialOrnamentation,
+	AugTypeUnknown3,
+	AugTypeUnknown4,
+	AugTypeUnknown5,
+	AugTypeUnknown6,
+	AugTypeUnknown7,
+	AugTypeUnknown8,
+	AugTypeUnknown9,
+	AugTypeUnknown10,
+	AugTypeEpic25,
+	AugTypeTest,
+	_AugTypeCount,
+	AugTypeAll = 255
 };
 
 /*
@@ -326,7 +368,7 @@ enum {
 #define AT_DamageState	44	// The damage state of a destructible object (0 through 4)
 //#define AT_Trader		300	// Bazzar Trader Mode
 
-// solar: animations for AT_Anim
+// animations for AT_Anim
 #define ANIM_FREEZE	102
 #define	ANIM_STAND		0x64
 #define	ANIM_SIT		0x6e
@@ -735,10 +777,11 @@ enum MaterialUseSlots : uint8
 	_MaterialInvalid = 255
 };
 
+/*
 // Used for worn NPC inventory tracking. NPCs don't use
 // augments, so only the basic slots need to be kept track of.
 #define MAX_WORN_INVENTORY	22
-
+*/
 
 /*
 **	Inventory Slot Equipment Enum
@@ -768,73 +811,164 @@ enum MaterialUseSlots : uint8
 **
 */
 
-enum InventorySlot
-{
-	////////////////////////
-	// Equip slots
-	////////////////////////
-
-	SLOT_CHARM		= 0,
-	SLOT_EAR01		= 1,
-	SLOT_HEAD		= 2,
-	SLOT_FACE		= 3,
-	SLOT_EAR02		= 4,
-	SLOT_NECK		= 5,
-	SLOT_SHOULDER	= 6,
-	SLOT_ARMS		= 7,
-	SLOT_BACK		= 8,
-	SLOT_BRACER01	= 9,
-	SLOT_BRACER02	= 10,
-	SLOT_RANGE		= 11,
-	SLOT_HANDS		= 12,
-	SLOT_PRIMARY	= 13,
-	SLOT_SECONDARY	= 14,
-	SLOT_RING01		= 15,
-	SLOT_RING02		= 16,
-	SLOT_CHEST		= 17,
-	SLOT_LEGS		= 18,
-	SLOT_FEET		= 19,
-	SLOT_WAIST		= 20,
-	SLOT_AMMO		= 21,
-
-	////////////////////////
-	// All other slots
-	////////////////////////
-	SLOT_PERSONAL_BEGIN = 22,
-	SLOT_PERSONAL_END = 29,
-
-	SLOT_CURSOR		= 30,
-
-	SLOT_CURSOR_END	= (int16)0xFFFE,	// Last item on cursor queue
-	// Cursor bag slots are 331->340 (10 slots)
-
-	// Personal Inventory Slots
-	// Slots 1 through 8 are slots 22->29
-	// Inventory bag slots are 251->330 (10 slots per bag)
-
-	// Tribute slots are 400-404? (upper bound unknown)
-	// storing these in worn item's map
-
-	// Bank slots
-	// Bank slots 1 through 16 are slots 2000->2015
-	// Bank bag slots are 2031->2190
-
-	// Shared bank slots
-	// Shared bank slots 1 through 2 are slots 2500->2501
-	// Shared bank bag slots are 2531->2550
-
-	// Trade session slots
-	// Trade slots 1 through 8 are slots 3000->3007
-	// Trade bag slots are technically 0->79 when passed to client,
-	// but in our code, we treat them as slots 3100->3179
-
-	// Slot used in OP_TradeSkillCombine for world tradeskill containers
-	SLOT_TRADESKILL = 1000,
-	SLOT_AUGMENT = 1001,
-	SLOT_POWER_SOURCE = 9999,
-	// Value recognized by client for destroying an item
-	SLOT_INVALID = (int16)0xFFFF
+enum InventoryMapTypes : int16 {
+	MapPossessions = 0,
+	MapBank,
+	MapSharedBank,
+	MapTrade,
+	MapWorld,
+	MapLimbo,
+	MapTribute,
+	MapTrophyTribute,
+	MapGuildTribute,
+	MapMerchant,
+	MapDeleted,
+	MapCorpse,
+	MapBazaar,
+	MapInspect,
+	MapRealEstate,
+	MapViewMODPC,
+	MapViewMODBank,
+	MapViewMODSharedBank,
+	MapViewMODLimbo,
+	MapAltStorage,
+	MapArchived,
+	MapMail,
+	MapGuildTrophyTribute,
+	MapKrono,
+	MapOther,
+	_MapCount
 };
 
+enum InventoryMainTypes : int16 {
+	MainCharm = 0,
+	MainEar1,
+	MainHead,
+	MainFace,
+	MainEar2,
+	MainNeck,
+	MainShoulders,
+	MainArms,
+	MainBack,
+	MainWrist1,
+	MainWrist2,
+	MainRange,
+	MainHands,
+	MainPrimary,
+	MainSecondary,
+	MainFinger1,
+	MainFinger2,
+	MainChest,
+	MainLegs,
+	MainFeet,
+	MainWaist,
+	MainPowerSource = 9999, // temp
+	MainAmmo = 21, // temp
+	MainGeneral1,
+	MainGeneral2,
+	MainGeneral3,
+	MainGeneral4,
+	MainGeneral5,
+	MainGeneral6,
+	MainGeneral7,
+	MainGeneral8,
+	//MainGeneral9,
+	//MainGeneral10,
+	MainCursor,
+	_MainCount
+};
+
+#define INVALID_INDEX	-1
+#define NOT_USED		0
+#define NO_ITEM			0
+
+// yes..these are redundant... but, they help to identify and define what is actually being performed
+// plus, since they're pre-op's, they don't affect the actual binary size
+#define MAP_BEGIN	0
+#define MAIN_BEGIN	0
+#define SUB_BEGIN	0
+#define AUG_BEGIN	0
+
+namespace legacy {
+	// this is for perl and other legacy systems
+
+	typedef enum {
+		SLOT_CHARM			= 0,
+		SLOT_EAR01			= 1,
+		SLOT_HEAD			= 2,
+		SLOT_FACE			= 3,
+		SLOT_EAR02			= 4,
+		SLOT_NECK			= 5,
+		SLOT_SHOULDER		= 6,
+		SLOT_ARMS			= 7,
+		SLOT_BACK			= 8,
+		SLOT_BRACER01		= 9,
+		SLOT_BRACER02		= 10,
+		SLOT_RANGE			= 11,
+		SLOT_HANDS			= 12,
+		SLOT_PRIMARY		= 13,
+		SLOT_SECONDARY		= 14,
+		SLOT_RING01			= 15,
+		SLOT_RING02			= 16,
+		SLOT_CHEST			= 17,
+		SLOT_LEGS			= 18,
+		SLOT_FEET			= 19,
+		SLOT_WAIST			= 20,
+		SLOT_POWER_SOURCE	= 9999,
+		SLOT_AMMO			= 21,
+		SLOT_GENERAL_1		= 22,
+		SLOT_GENERAL_2		= 23,
+		SLOT_GENERAL_3		= 24,
+		SLOT_GENERAL_4		= 25,
+		SLOT_GENERAL_5		= 26,
+		SLOT_GENERAL_6		= 27,
+		SLOT_GENERAL_7		= 28,
+		SLOT_GENERAL_8		= 29,
+		//SLOT_GENERAL_9	= not supported
+		//SLOT_GENERAL_10	= not supported
+		SLOT_CURSOR			= 30,
+		SLOT_CURSOR_END		= (int16)0xFFFE, // I hope no one is using this...
+		SLOT_TRADESKILL		= 1000,
+		SLOT_AUGMENT		= 1001,
+		SLOT_INVALID		= (int16)0xFFFF,
+
+		SLOT_POSSESSIONS_BEGIN	= 0,
+		SLOT_POSSESSIONS_END	= 30,
+
+		SLOT_EQUIPMENT_BEGIN	= 0,
+		SLOT_EQUIPMENT_END		= 21,
+
+		SLOT_PERSONAL_BEGIN		= 22,
+		SLOT_PERSONAL_END		= 29,
+		SLOT_PERSONAL_BAGS_BEGIN	= 251,
+		SLOT_PERSONAL_BAGS_END		= 330,
+
+		SLOT_CURSOR_BAG_BEGIN		= 331,
+		SLOT_CURSOR_BAG_END			= 340,
+
+		SLOT_TRIBUTE_BEGIN	= 400,
+		SLOT_TRIBUTE_END	= 404,
+
+		SLOT_BANK_BEGIN			= 2000,
+		SLOT_BANK_END			= 2023,
+		SLOT_BANK_BAGS_BEGIN	= 2031,
+		SLOT_BANK_BAGS_END		= 2270,
+
+		SLOT_SHARED_BANK_BEGIN		= 2500,
+		SLOT_SHARED_BANK_END		= 2501,
+		SLOT_SHARED_BANK_BAGS_BEGIN	= 2531,
+		SLOT_SHARED_BANK_BAGS_END	= 2550,
+
+		SLOT_TRADE_BEGIN		= 3000,
+		SLOT_TRADE_END			= 3007,
+		SLOT_TRADE_BAGS_BEGIN	= 3031,
+		SLOT_TRADE_BAGS_END		= 3110,
+
+		SLOT_WORLD_BEGIN	= 4000,
+		SLOT_WORLD_END		= 4009
+	} InventorySlot;
+}
+
+static const uint32 MAX_SPELL_DB_ID_VAL = 65535;
 
 #endif

common/eq_dictionary.cpp

@@ -0,0 +1,956 @@
+/*
+EQEMu:  Everquest Server Emulator
+
+Copyright (C) 2001-2014 EQEMu Development Team (http://eqemulator.net)
+
+This program 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; version 2 of the License.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY except by those people which sell it, which
+are required to give you total support for your newly bought product;
+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 this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+*/
+
+#include "eq_dictionary.h"
+#include "string_util.h"
+
+//
+// class EmuConstants
+//
+uint16 EmuConstants::InventoryMapSize(int16 indexMap) {
+	switch (indexMap) {
+	case MapPossessions:
+		return MAP_POSSESSIONS_SIZE;
+	case MapBank:
+		return MAP_BANK_SIZE;
+	case MapSharedBank:
+		return MAP_SHARED_BANK_SIZE;
+	case MapTrade:
+		return MAP_TRADE_SIZE;
+	case MapWorld:
+		return MAP_WORLD_SIZE;
+	case MapLimbo:
+		return MAP_LIMBO_SIZE;
+	case MapTribute:
+		return MAP_TRIBUTE_SIZE;
+	case MapTrophyTribute:
+		return MAP_TROPHY_TRIBUTE_SIZE;
+	case MapGuildTribute:
+		return MAP_GUILD_TRIBUTE_SIZE;
+	case MapMerchant:
+		return MAP_MERCHANT_SIZE;
+	case MapDeleted:
+		return MAP_DELETED_SIZE;
+	case MapCorpse:
+		return MAP_CORPSE_SIZE;
+	case MapBazaar:
+		return MAP_BAZAAR_SIZE;
+	case MapInspect:
+		return MAP_INSPECT_SIZE;
+	case MapRealEstate:
+		return MAP_REAL_ESTATE_SIZE;
+	case MapViewMODPC:
+		return MAP_VIEW_MOD_PC_SIZE;
+	case MapViewMODBank:
+		return MAP_VIEW_MOD_BANK_SIZE;
+	case MapViewMODSharedBank:
+		return MAP_VIEW_MOD_SHARED_BANK_SIZE;
+	case MapViewMODLimbo:
+		return MAP_VIEW_MOD_LIMBO_SIZE;
+	case MapAltStorage:
+		return MAP_ALT_STORAGE_SIZE;
+	case MapArchived:
+		return MAP_ARCHIVED_SIZE;
+	case MapMail:
+		return MAP_MAIL_SIZE;
+	case MapGuildTrophyTribute:
+		return MAP_GUILD_TROPHY_TRIBUTE_SIZE;
+	case MapKrono:
+		return MAP_KRONO_SIZE;
+	case MapOther:
+		return MAP_OTHER_SIZE;
+	default:
+		return NOT_USED;
+	}
+}
+
+/*
+std::string EmuConstants::InventoryLocationName(Location_Struct location) {
+	// not ready for implementation...
+	std::string ret_str;
+	StringFormat(ret_str, "%s, %s, %s, %s", InventoryMapName(location.map), InventoryMainName(location.main), InventorySubName(location.sub), InventoryAugName(location.aug));
+	return  ret_str;
+}
+*/
+
+std::string EmuConstants::InventoryMapName(int16 indexMap) {
+	switch (indexMap) {
+	case INVALID_INDEX:
+		return "Invalid Map";
+	case MapPossessions:
+		return "Possessions";
+	case MapBank:
+		return "Bank";
+	case MapSharedBank:
+		return "Shared Bank";
+	case MapTrade:
+		return "Trade";
+	case MapWorld:
+		return "World";
+	case MapLimbo:
+		return "Limbo";
+	case MapTribute:
+		return "Tribute";
+	case MapTrophyTribute:
+		return "Trophy Tribute";
+	case MapGuildTribute:
+		return "Guild Tribute";
+	case MapMerchant:
+		return "Merchant";
+	case MapDeleted:
+		return "Deleted";
+	case MapCorpse:
+		return "Corpse";
+	case MapBazaar:
+		return "Bazaar";
+	case MapInspect:
+		return "Inspect";
+	case MapRealEstate:
+		return "Real Estate";
+	case MapViewMODPC:
+		return "View MOD PC";
+	case MapViewMODBank:
+		return "View MOD Bank";
+	case MapViewMODSharedBank:
+		return "View MOD Shared Bank";
+	case MapViewMODLimbo:
+		return "View MOD Limbo";
+	case MapAltStorage:
+		return "Alt Storage";
+	case MapArchived:
+		return "Archived";
+	case MapMail:
+		return "Mail";
+	case MapGuildTrophyTribute:
+		return "Guild Trophy Tribute";
+	case MapKrono:
+		return "Krono";
+	case MapOther:
+		return "Other";
+	default:
+		return "Unknown Map";
+	}
+}
+
+std::string EmuConstants::InventoryMainName(int16 indexMain) {
+	switch (indexMain) {
+	case INVALID_INDEX:
+		return "Invalid Main";
+	case MainCharm:
+		return "Charm";
+	case MainEar1:
+		return "Ear 1";
+	case MainHead:
+		return "Head";
+	case MainFace:
+		return "Face";
+	case MainEar2:
+		return "Ear 2";
+	case MainNeck:
+		return "Neck";
+	case MainShoulders:
+		return "Shoulders";
+	case MainArms:
+		return "Arms";
+	case MainBack:
+		return "Back";
+	case MainWrist1:
+		return "Wrist 1";
+	case MainWrist2:
+		return "Wrist 2";
+	case MainRange:
+		return "Range";
+	case MainHands:
+		return "Hands";
+	case MainPrimary:
+		return "Primary";
+	case MainSecondary:
+		return "Secondary";
+	case MainFinger1:
+		return "Finger 1";
+	case MainFinger2:
+		return "Finger 2";
+	case MainChest:
+		return "Chest";
+	case MainLegs:
+		return "Legs";
+	case MainFeet:
+		return "Feet";
+	case MainWaist:
+		return "Waist";
+	case MainPowerSource:
+		return "Power Source";
+	case MainAmmo:
+		return "Ammo";
+	case MainGeneral1:
+		return "General 1";
+	case MainGeneral2:
+		return "General 2";
+	case MainGeneral3:
+		return "General 3";
+	case MainGeneral4:
+		return "General 4";
+	case MainGeneral5:
+		return "General 5";
+	case MainGeneral6:
+		return "General 6";
+	case MainGeneral7:
+		return "General 7";
+	case MainGeneral8:
+		return "General 8";
+	/*
+	case MainGeneral9:
+		return "General 9";
+	case MainGeneral10:
+		return "General 10";
+	*/
+	case MainCursor:
+		return "Cursor";
+	default:
+		return "Unknown Main";
+	}
+}
+
+std::string EmuConstants::InventorySubName(int16 indexSub) {
+	if (indexSub == INVALID_INDEX)
+		return "Invalid Sub";
+
+	if ((uint16)indexSub >= ITEM_CONTAINER_SIZE)
+		return "Unknown Sub";
+
+	std::string ret_str;
+	ret_str = StringFormat("Container %i", (indexSub + 1)); // zero-based index..but, count starts at one
+
+	return ret_str;
+}
+
+std::string EmuConstants::InventoryAugName(int16 indexAug) {
+	if (indexAug == INVALID_INDEX)
+		return "Invalid Aug";
+
+	if ((uint16)indexAug >= ITEM_COMMON_SIZE)
+		return "Unknown Aug";
+
+	std::string ret_str;
+	ret_str = StringFormat("Augment %i", (indexAug + 1)); // zero-based index..but, count starts at one
+
+	return ret_str;
+}
+
+
+// 
+// class EQLimits
+//
+// client validation
+bool EQLimits::IsValidPCClientVersion(ClientVersion clientVersion) {
+	if (clientVersion > ClientVersion::Unknown && clientVersion <= LAST_PC_CLIENT)
+		return true;
+
+	return false;
+}
+
+ClientVersion EQLimits::ValidatePCClientVersion(ClientVersion clientVersion) {
+	if (clientVersion > ClientVersion::Unknown && clientVersion <= LAST_PC_CLIENT)
+		return clientVersion;
+
+	return ClientVersion::Unknown;
+}
+
+// npc validation
+bool EQLimits::IsValidNPCClientVersion(ClientVersion clientVersion) {
+	if (clientVersion > LAST_PC_CLIENT && clientVersion <= LAST_NPC_CLIENT)
+		return true;
+
+	return false;
+}
+
+ClientVersion EQLimits::ValidateNPCClientVersion(ClientVersion clientVersion) {
+	if (clientVersion > LAST_PC_CLIENT && clientVersion <= LAST_NPC_CLIENT)
+		return clientVersion;
+
+	return ClientVersion::Unknown;
+}
+
+// mob validation
+bool EQLimits::IsValidMobClientVersion(ClientVersion clientVersion) {
+	if (clientVersion > ClientVersion::Unknown && clientVersion <= LAST_NPC_CLIENT)
+		return true;
+
+	return false;
+}
+
+ClientVersion EQLimits::ValidateMobClientVersion(ClientVersion clientVersion) {
+	if (clientVersion > ClientVersion::Unknown && clientVersion <= LAST_NPC_CLIENT)
+		return clientVersion;
+
+	return ClientVersion::Unknown;
+}
+
+// inventory
+uint16 EQLimits::InventoryMapSize(int16 indexMap, ClientVersion clientVersion) {
+	// not all maps will have an instantiated container..some are references for queue generators (i.e., bazaar, mail, etc...)
+	// a zero '0' indicates a needed value..otherwise, change to '_NOTUSED' for a null value so indices requiring research can be identified
+	// ALL of these values need to be verified before pushing to live
+	//
+	// make sure that you transcribe the actual value from 'defaults' to here before updating or client crashes will ensue..and/or...
+	// insert older clients inside of the progression of client order
+	//
+	// MAP_POSSESSIONS_SIZE does not reflect all actual <client>_constants size due to bitmask-use compatibility
+	//
+	// when setting NPC-based values, try to adhere to an EmuConstants::<property> or NOT_USED value to avoid unnecessary issues
+
+	static const uint16 local[_MapCount][CLIENT_VERSION_COUNT] = {
+		// server and database are sync'd to current MapPossessions's client as set in 'using namespace RoF::slots;' and
+		// 'EmuConstants::MAP_POSSESSIONS_SIZE' - use/update EquipmentBitmask(), GeneralBitmask() and CursorBitmask()
+		// for partial range validation checks and 'EmuConstants::MAP_POSSESSIONS_SIZE' for full range iterations
+		{ // local[MainPossessions]
+/*Unknown*/		NOT_USED,
+/*62*/			EmuConstants::MAP_POSSESSIONS_SIZE,
+/*Titanium*/	EmuConstants::MAP_POSSESSIONS_SIZE,
+/*SoF*/			EmuConstants::MAP_POSSESSIONS_SIZE,
+/*SoD*/			EmuConstants::MAP_POSSESSIONS_SIZE,
+/*Underfoot*/	EmuConstants::MAP_POSSESSIONS_SIZE,
+/*RoF*/			EmuConstants::MAP_POSSESSIONS_SIZE,
+/*RoF2*/		EmuConstants::MAP_POSSESSIONS_SIZE,
+
+/*NPC*/			EmuConstants::MAP_POSSESSIONS_SIZE,
+/*Merc*/		EmuConstants::MAP_POSSESSIONS_SIZE,
+/*Bot*/			EmuConstants::MAP_POSSESSIONS_SIZE,
+/*Pet*/			EmuConstants::MAP_POSSESSIONS_SIZE
+		},
+		{ // local[MapBank]
+/*Unknown*/		NOT_USED,
+/*62*/			NOT_USED,
+/*Titanium*/	Titanium::consts::MAP_BANK_SIZE,
+/*SoF*/			EmuConstants::MAP_BANK_SIZE,
+/*SoD*/			EmuConstants::MAP_BANK_SIZE,
+/*Underfoot*/	EmuConstants::MAP_BANK_SIZE,
+/*RoF*/			EmuConstants::MAP_BANK_SIZE,
+/*RoF2*/		EmuConstants::MAP_BANK_SIZE,
+
+/*NPC*/			NOT_USED,
+/*Merc*/		NOT_USED,
+/*Bot*/			NOT_USED,
+/*Pet*/			NOT_USED
+		},
+		{ // local[MapSharedBank]
+/*Unknown*/		NOT_USED,
+/*62*/			EmuConstants::MAP_SHARED_BANK_SIZE,
+/*Titanium*/	EmuConstants::MAP_SHARED_BANK_SIZE,
+/*SoF*/			EmuConstants::MAP_SHARED_BANK_SIZE,
+/*SoD*/			EmuConstants::MAP_SHARED_BANK_SIZE,
+/*Underfoot*/	EmuConstants::MAP_SHARED_BANK_SIZE,
+/*RoF*/			EmuConstants::MAP_SHARED_BANK_SIZE,
+/*RoF2*/		EmuConstants::MAP_SHARED_BANK_SIZE,
+
+/*NPC*/			NOT_USED,
+/*Merc*/		NOT_USED,
+/*Bot*/			NOT_USED,
+/*Pet*/			NOT_USED
+		},
+		{ // local[MapTrade]
+/*Unknown*/		NOT_USED,
+/*62*/			EmuConstants::MAP_TRADE_SIZE,
+/*Titanium*/	EmuConstants::MAP_TRADE_SIZE,
+/*SoF*/			EmuConstants::MAP_TRADE_SIZE,
+/*SoD*/			EmuConstants::MAP_TRADE_SIZE,
+/*Underfoot*/	EmuConstants::MAP_TRADE_SIZE,
+/*RoF*/			EmuConstants::MAP_TRADE_SIZE,
+/*RoF2*/		EmuConstants::MAP_TRADE_SIZE,
+
+/*NPC*/			4,
+/*Merc*/		4,
+/*Bot*/			EmuConstants::MAP_TRADE_SIZE, // client thinks this is another client
+/*Pet*/			4
+		},
+		{ // local[MapWorld]
+/*Unknown*/		NOT_USED,
+/*62*/			EmuConstants::MAP_WORLD_SIZE,
+/*Titanium*/	EmuConstants::MAP_WORLD_SIZE,
+/*SoF*/			EmuConstants::MAP_WORLD_SIZE,
+/*SoD*/			EmuConstants::MAP_WORLD_SIZE,
+/*Underfoot*/	EmuConstants::MAP_WORLD_SIZE,
+/*RoF*/			EmuConstants::MAP_WORLD_SIZE,
+/*RoF2*/		EmuConstants::MAP_WORLD_SIZE,
+
+/*NPC*/			NOT_USED,
+/*Merc*/		NOT_USED,
+/*Bot*/			NOT_USED,
+/*Pet*/			NOT_USED
+		},
+		{ // local[MapLimbo]
+/*Unknown*/		NOT_USED,
+/*62*/			EmuConstants::MAP_LIMBO_SIZE,
+/*Titanium*/	EmuConstants::MAP_LIMBO_SIZE,
+/*SoF*/			EmuConstants::MAP_LIMBO_SIZE,
+/*SoD*/			EmuConstants::MAP_LIMBO_SIZE,
+/*Underfoot*/	EmuConstants::MAP_LIMBO_SIZE,
+/*RoF*/			EmuConstants::MAP_LIMBO_SIZE,
+/*RoF2*/		EmuConstants::MAP_LIMBO_SIZE,
+
+/*NPC*/			NOT_USED,
+/*Merc*/		NOT_USED,
+/*Bot*/			NOT_USED,
+/*Pet*/			NOT_USED
+		},
+		{ // local[MapTribute]
+/*Unknown*/		NOT_USED,
+/*62*/			EmuConstants::MAP_TRIBUTE_SIZE,
+/*Titanium*/	EmuConstants::MAP_TRIBUTE_SIZE,
+/*SoF*/			EmuConstants::MAP_TRIBUTE_SIZE,
+/*SoD*/			EmuConstants::MAP_TRIBUTE_SIZE,
+/*Underfoot*/	EmuConstants::MAP_TRIBUTE_SIZE,
+/*RoF*/			EmuConstants::MAP_TRIBUTE_SIZE,
+/*RoF2*/		EmuConstants::MAP_TRIBUTE_SIZE,
+
+/*NPC*/			0,
+/*Merc*/		0,
+/*Bot*/			0,
+/*Pet*/			0
+		},
+		{ // local[MapTrophyTribute]
+/*Unknown*/		NOT_USED,
+/*62*/			0,
+/*Titanium*/	0,
+/*SoF*/			0,
+/*SoD*/			0,
+/*Underfoot*/	0,
+/*RoF*/			EmuConstants::MAP_TROPHY_TRIBUTE_SIZE,
+/*RoF2*/		EmuConstants::MAP_TROPHY_TRIBUTE_SIZE,
+
+/*NPC*/			0,
+/*Merc*/		0,
+/*Bot*/			0,
+/*Pet*/			0
+		},
+		{ // local[MapGuildTribute]
+/*Unknown*/		NOT_USED,
+/*62*/			0,
+/*Titanium*/	0,
+/*SoF*/			0,
+/*SoD*/			0,
+/*Underfoot*/	0,
+/*RoF*/			EmuConstants::MAP_GUILD_TRIBUTE_SIZE,
+/*RoF2*/		EmuConstants::MAP_GUILD_TRIBUTE_SIZE,
+
+/*NPC*/			0,
+/*Merc*/		0,
+/*Bot*/			0,
+/*Pet*/			0
+		},
+		{ // local[MapMerchant]
+/*Unknown*/		NOT_USED,
+/*62*/			0,
+/*Titanium*/	0,
+/*SoF*/			0,
+/*SoD*/			0,
+/*Underfoot*/	0,
+/*RoF*/			EmuConstants::MAP_MERCHANT_SIZE,
+/*RoF2*/		EmuConstants::MAP_MERCHANT_SIZE,
+
+/*NPC*/			0,
+/*Merc*/		0,
+/*Bot*/			0,
+/*Pet*/			0
+		},
+		{ // local[MapDeleted]
+/*Unknown*/		NOT_USED,
+/*62*/			0,
+/*Titanium*/	0,
+/*SoF*/			0,
+/*SoD*/			0,
+/*Underfoot*/	0,
+/*RoF*/			EmuConstants::MAP_DELETED_SIZE,
+/*RoF2*/		EmuConstants::MAP_DELETED_SIZE,
+
+/*NPC*/			0,
+/*Merc*/		0,
+/*Bot*/			0,
+/*Pet*/			0
+		},
+		{ // local[MapCorpse]
+/*Unknown*/		NOT_USED,
+/*62*/			NOT_USED,
+/*Titanium*/	Titanium::consts::MAP_CORPSE_SIZE,
+/*SoF*/			SoF::consts::MAP_CORPSE_SIZE,
+/*SoD*/			SoD::consts::MAP_CORPSE_SIZE,
+/*Underfoot*/	UF::consts::MAP_CORPSE_SIZE,
+/*RoF*/			RoF::consts::MAP_CORPSE_SIZE,
+/*RoF2*/		RoF2::consts::MAP_CORPSE_SIZE,
+
+/*NPC*/			0,
+/*Merc*/		0,
+/*Bot*/			0,
+/*Pet*/			0
+		},
+		{ // local[MapBazaar]
+/*Unknown*/		NOT_USED,
+/*62*/			EmuConstants::MAP_BAZAAR_SIZE,
+/*Titanium*/	EmuConstants::MAP_BAZAAR_SIZE,
+/*SoF*/			EmuConstants::MAP_BAZAAR_SIZE,
+/*SoD*/			EmuConstants::MAP_BAZAAR_SIZE,
+/*Underfoot*/	EmuConstants::MAP_BAZAAR_SIZE,
+/*RoF*/			EmuConstants::MAP_BAZAAR_SIZE,
+/*RoF2*/		EmuConstants::MAP_BAZAAR_SIZE,
+
+/*NPC*/			0, // this may need to be 'EmuConstants::MAP_BAZAAR_SIZE' if offline client traders respawn as an npc
+/*Merc*/		0,
+/*Bot*/			0,
+/*Pet*/			0
+		},
+		{ // local[MapInspect]
+/*Unknown*/		NOT_USED,
+/*62*/			NOT_USED,
+/*Titanium*/	Titanium::consts::MAP_INSPECT_SIZE,
+/*SoF*/			SoF::consts::MAP_INSPECT_SIZE,
+/*SoD*/			SoD::consts::MAP_INSPECT_SIZE,
+/*Underfoot*/	UF::consts::MAP_INSPECT_SIZE,
+/*RoF*/			RoF::consts::MAP_INSPECT_SIZE,
+/*RoF2*/		RoF2::consts::MAP_INSPECT_SIZE,
+
+/*NPC*/			NOT_USED,
+/*Merc*/		NOT_USED,
+/*Bot*/			NOT_USED,
+/*Pet*/			NOT_USED
+		},
+		{ // local[MapRealEstate]
+/*Unknown*/		NOT_USED,
+/*62*/			0,
+/*Titanium*/	0,
+/*SoF*/			0,
+/*SoD*/			0,
+/*Underfoot*/	0,
+/*RoF*/			EmuConstants::MAP_REAL_ESTATE_SIZE,
+/*RoF2*/		EmuConstants::MAP_REAL_ESTATE_SIZE,
+
+/*NPC*/			0,
+/*Merc*/		0,
+/*Bot*/			0,
+/*Pet*/			0
+		},
+		{ // local[MapViewMODPC]
+/*Unknown*/		NOT_USED,
+/*62*/			0,
+/*Titanium*/	0,
+/*SoF*/			0,
+/*SoD*/			0,
+/*Underfoot*/	0,
+/*RoF*/			EmuConstants::MAP_VIEW_MOD_PC_SIZE,
+/*RoF2*/		EmuConstants::MAP_VIEW_MOD_PC_SIZE,
+
+/*NPC*/			0,
+/*Merc*/		0,
+/*Bot*/			0,
+/*Pet*/			0
+		},
+		{ // local[MapViewMODBank]
+/*Unknown*/		NOT_USED,
+/*62*/			0,
+/*Titanium*/	0,
+/*SoF*/			0,
+/*SoD*/			0,
+/*Underfoot*/	0,
+/*RoF*/			EmuConstants::MAP_VIEW_MOD_BANK_SIZE,
+/*RoF2*/		EmuConstants::MAP_VIEW_MOD_BANK_SIZE,
+
+/*NPC*/			0,
+/*Merc*/		0,
+/*Bot*/			0,
+/*Pet*/			0
+		},
+		{ // local[MapViewMODSharedBank]
+/*Unknown*/		NOT_USED,
+/*62*/			0,
+/*Titanium*/	0,
+/*SoF*/			0,
+/*SoD*/			0,
+/*Underfoot*/	0,
+/*RoF*/			EmuConstants::MAP_VIEW_MOD_SHARED_BANK_SIZE,
+/*RoF2*/		EmuConstants::MAP_VIEW_MOD_SHARED_BANK_SIZE,
+
+/*NPC*/			0,
+/*Merc*/		0,
+/*Bot*/			0,
+/*Pet*/			0
+		},
+		{ // local[MapViewMODLimbo]
+/*Unknown*/		NOT_USED,
+/*62*/			0,
+/*Titanium*/	0,
+/*SoF*/			0,
+/*SoD*/			0,
+/*Underfoot*/	0,
+/*RoF*/			EmuConstants::MAP_VIEW_MOD_LIMBO_SIZE,
+/*RoF2*/		EmuConstants::MAP_VIEW_MOD_LIMBO_SIZE,
+
+/*NPC*/			0,
+/*Merc*/		0,
+/*Bot*/			0,
+/*Pet*/			0
+		},
+		{ // local[MapAltStorage]
+/*Unknown*/		NOT_USED,
+/*62*/			0,
+/*Titanium*/	0,
+/*SoF*/			0,
+/*SoD*/			0,
+/*Underfoot*/	0,
+/*RoF*/			EmuConstants::MAP_ALT_STORAGE_SIZE,
+/*RoF2*/		EmuConstants::MAP_ALT_STORAGE_SIZE,
+
+/*NPC*/			0,
+/*Merc*/		0,
+/*Bot*/			0,
+/*Pet*/			0
+		},
+		{ // local[MapArchived]
+/*Unknown*/		NOT_USED,
+/*62*/			0,
+/*Titanium*/	0,
+/*SoF*/			0,
+/*SoD*/			0,
+/*Underfoot*/	0,
+/*RoF*/			EmuConstants::MAP_ARCHIVED_SIZE,
+/*RoF2*/		EmuConstants::MAP_ARCHIVED_SIZE,
+
+/*NPC*/			0,
+/*Merc*/		0,
+/*Bot*/			0,
+/*Pet*/			0
+		},
+		{ // local[MapMail]
+/*Unknown*/		NOT_USED,
+/*62*/			0,
+/*Titanium*/	0,
+/*SoF*/			0,
+/*SoD*/			0,
+/*Underfoot*/	0,
+/*RoF*/			EmuConstants::MAP_MAIL_SIZE,
+/*RoF2*/		EmuConstants::MAP_MAIL_SIZE,
+
+/*NPC*/			0,
+/*Merc*/		0,
+/*Bot*/			0,
+/*Pet*/			0
+		},
+		{ // local[MapGuildTrophyTribute]
+/*Unknown*/		NOT_USED,
+/*62*/			0,
+/*Titanium*/	0,
+/*SoF*/			0,
+/*SoD*/			0,
+/*Underfoot*/	0,
+/*RoF*/			EmuConstants::MAP_GUILD_TROPHY_TRIBUTE_SIZE,
+/*RoF2*/		EmuConstants::MAP_GUILD_TROPHY_TRIBUTE_SIZE,
+
+/*NPC*/			0,
+/*Merc*/		0,
+/*Bot*/			0,
+/*Pet*/			0
+		},
+		{ // local[MapKrono]
+/*Unknown*/		NOT_USED,
+/*62*/			NOT_USED,
+/*Titanium*/	NOT_USED,
+/*SoF*/			NOT_USED,
+/*SoD*/			NOT_USED,
+/*Underfoot*/	NOT_USED,
+/*RoF*/			EmuConstants::MAP_KRONO_SIZE,
+/*RoF2*/		EmuConstants::MAP_KRONO_SIZE,
+
+/*NPC*/			0,
+/*Merc*/		0,
+/*Bot*/			0,
+/*Pet*/			0
+		},
+		{ // local[MapOther]
+/*Unknown*/		NOT_USED,
+/*62*/			0,
+/*Titanium*/	0,
+/*SoF*/			0,
+/*SoD*/			0,
+/*Underfoot*/	0,
+/*RoF*/			EmuConstants::MAP_OTHER_SIZE,
+/*RoF2*/		EmuConstants::MAP_OTHER_SIZE,
+
+/*NPC*/			0,
+/*Merc*/		0,
+/*Bot*/			0,
+/*Pet*/			0
+		}
+	};
+
+	if ((uint16)indexMap < _MapCount)
+		return local[indexMap][static_cast<unsigned int>(ValidateMobClientVersion(clientVersion))];
+
+	return NOT_USED;
+}
+
+uint64 EQLimits::PossessionsBitmask(ClientVersion clientVersion) {
+	// these are for the new inventory system (RoF)..not the current (Ti) one...
+	// 0x0000000000200000 is SlotPowerSource (SoF+)
+	// 0x0000000080000000 is SlotGeneral9 (RoF+)
+	// 0x0000000100000000 is SlotGeneral10 (RoF+)
+
+	static const uint64 local[CLIENT_VERSION_COUNT] = {
+/*Unknown*/		NOT_USED,
+/*62*/			0x000000027FDFFFFF,
+/*Titanium*/	0x000000027FDFFFFF,
+/*SoF*/			0x000000027FFFFFFF,
+/*SoD*/			0x000000027FFFFFFF,
+/*Underfoot*/	0x000000027FFFFFFF,
+/*RoF*/			0x00000003FFFFFFFF,
+/*RoF2*/		0,
+
+/*NPC*/			0,
+/*Merc*/		0,
+/*Bot*/			0,
+/*Pet*/			0
+	};
+
+	return NOT_USED;
+	//return local[static_cast<unsigned int>(ValidateMobClientVersion(clientVersion))];
+}
+
+uint64 EQLimits::EquipmentBitmask(ClientVersion clientVersion) {
+	static const uint64 local[CLIENT_VERSION_COUNT] = {
+/*Unknown*/		NOT_USED,
+/*62*/			0x00000000005FFFFF,
+/*Titanium*/	0x00000000005FFFFF,
+/*SoF*/			0x00000000007FFFFF,
+/*SoD*/			0x00000000007FFFFF,
+/*Underfoot*/	0x00000000007FFFFF,
+/*RoF*/			0x00000000007FFFFF,
+/*RoF2*/		0,
+
+/*NPC*/			0,
+/*Merc*/		0,
+/*Bot*/			0,
+/*Pet*/			0
+	};
+
+	return NOT_USED;
+	//return local[static_cast<unsigned int>(ValidateMobClientVersion(clientVersion))];
+}
+
+uint64 EQLimits::GeneralBitmask(ClientVersion clientVersion) {
+	static const uint64 local[CLIENT_VERSION_COUNT] = {
+/*Unknown*/		NOT_USED,
+/*62*/			0x000000007F800000,
+/*Titanium*/	0x000000007F800000,
+/*SoF*/			0x000000007F800000,
+/*SoD*/			0x000000007F800000,
+/*Underfoot*/	0x000000007F800000,
+/*RoF*/			0x00000001FF800000,
+/*RoF2*/		0,
+
+/*NPC*/			0,
+/*Merc*/		0,
+/*Bot*/			0,
+/*Pet*/			0
+	};
+
+	return NOT_USED;
+	//return local[static_cast<unsigned int>(ValidateMobClientVersion(clientVersion))];
+}
+
+uint64 EQLimits::CursorBitmask(ClientVersion clientVersion) {
+	static const uint64 local[CLIENT_VERSION_COUNT] = {
+/*Unknown*/		NOT_USED,
+/*62*/			0x0000000200000000,
+/*Titanium*/	0x0000000200000000,
+/*SoF*/			0x0000000200000000,
+/*SoD*/			0x0000000200000000,
+/*Underfoot*/	0x0000000200000000,
+/*RoF*/			0x0000000200000000,
+/*RoF2*/		0,
+
+/*NPC*/			0,
+/*Merc*/		0,
+/*Bot*/			0,
+/*Pet*/			0
+	};
+
+	return NOT_USED;
+	//return local[static_cast<unsigned int>(ValidateMobClientVersion(clientVersion))];
+}
+
+bool EQLimits::AllowsEmptyBagInBag(ClientVersion clientVersion) {
+	static const bool local[CLIENT_VERSION_COUNT] = {
+/*Unknown*/		false,
+/*62*/			false,
+/*Titanium*/	Titanium::limits::ALLOWS_EMPTY_BAG_IN_BAG,
+/*SoF*/			SoF::limits::ALLOWS_EMPTY_BAG_IN_BAG,
+/*SoD*/			SoD::limits::ALLOWS_EMPTY_BAG_IN_BAG,
+/*Underfoot*/	UF::limits::ALLOWS_EMPTY_BAG_IN_BAG,
+/*RoF*/			RoF::limits::ALLOWS_EMPTY_BAG_IN_BAG,
+/*RoF2*/		RoF2::limits::ALLOWS_EMPTY_BAG_IN_BAG,
+
+/*NPC*/			false,
+/*Merc*/		false,
+/*Bot*/			false,
+/*Pet*/			false
+	};
+
+	return false; // not implemented
+	//return local[static_cast<unsigned int>(ValidateMobClientVersion(clientVersion))];
+}
+
+bool EQLimits::AllowsClickCastFromBag(ClientVersion clientVersion) {
+	static const bool local[CLIENT_VERSION_COUNT] = {
+/*Unknown*/		false,
+/*62*/			false,
+/*Titanium*/	Titanium::limits::ALLOWS_CLICK_CAST_FROM_BAG,
+/*SoF*/			SoF::limits::ALLOWS_CLICK_CAST_FROM_BAG,
+/*SoD*/			SoD::limits::ALLOWS_CLICK_CAST_FROM_BAG,
+/*Underfoot*/	UF::limits::ALLOWS_CLICK_CAST_FROM_BAG,
+/*RoF*/			RoF::limits::ALLOWS_CLICK_CAST_FROM_BAG,
+/*RoF2*/		RoF2::limits::ALLOWS_CLICK_CAST_FROM_BAG,
+
+/*NPC*/			false,
+/*Merc*/		false,
+/*Bot*/			false,
+/*Pet*/			false
+	};
+
+	return local[static_cast<unsigned int>(ValidateMobClientVersion(clientVersion))];
+}
+
+// items
+uint16 EQLimits::ItemCommonSize(ClientVersion clientVersion) {
+	static const uint16 local[CLIENT_VERSION_COUNT] = {
+/*Unknown*/		NOT_USED,
+/*62*/			EmuConstants::ITEM_COMMON_SIZE,
+/*Titanium*/	EmuConstants::ITEM_COMMON_SIZE,
+/*SoF*/			EmuConstants::ITEM_COMMON_SIZE,
+/*SoD*/			EmuConstants::ITEM_COMMON_SIZE,
+/*Underfoot*/	EmuConstants::ITEM_COMMON_SIZE,
+/*RoF*/			EmuConstants::ITEM_COMMON_SIZE,
+/*RoF2*/		EmuConstants::ITEM_COMMON_SIZE,
+
+/*NPC*/			EmuConstants::ITEM_COMMON_SIZE,
+/*Merc*/		EmuConstants::ITEM_COMMON_SIZE,
+/*Bot*/			EmuConstants::ITEM_COMMON_SIZE,
+/*Pet*/			EmuConstants::ITEM_COMMON_SIZE
+	};
+
+	return local[static_cast<unsigned int>(ValidateMobClientVersion(clientVersion))];
+}
+
+uint16 EQLimits::ItemContainerSize(ClientVersion clientVersion) {
+	static const uint16 local[CLIENT_VERSION_COUNT] = {
+/*Unknown*/		NOT_USED,
+/*62*/			EmuConstants::ITEM_CONTAINER_SIZE,
+/*Titanium*/	EmuConstants::ITEM_CONTAINER_SIZE,
+/*SoF*/			EmuConstants::ITEM_CONTAINER_SIZE,
+/*SoD*/			EmuConstants::ITEM_CONTAINER_SIZE,
+/*Underfoot*/	EmuConstants::ITEM_CONTAINER_SIZE,
+/*RoF*/			EmuConstants::ITEM_CONTAINER_SIZE,
+/*RoF2*/		EmuConstants::ITEM_CONTAINER_SIZE,
+
+/*NPC*/			EmuConstants::ITEM_CONTAINER_SIZE,
+/*Merc*/		EmuConstants::ITEM_CONTAINER_SIZE,
+/*Bot*/			EmuConstants::ITEM_CONTAINER_SIZE,
+/*Pet*/			EmuConstants::ITEM_CONTAINER_SIZE
+	};
+
+	return local[static_cast<unsigned int>(ValidateMobClientVersion(clientVersion))];
+}
+
+bool EQLimits::CoinHasWeight(ClientVersion clientVersion) {
+	static const bool local[CLIENT_VERSION_COUNT] = {
+/*Unknown*/		true,
+/*62*/			true,
+/*Titanium*/	Titanium::limits::COIN_HAS_WEIGHT,
+/*SoF*/			SoF::limits::COIN_HAS_WEIGHT,
+/*SoD*/			SoD::limits::COIN_HAS_WEIGHT,
+/*Underfoot*/	UF::limits::COIN_HAS_WEIGHT,
+/*RoF*/			RoF::limits::COIN_HAS_WEIGHT,
+/*RoF2*/		RoF::limits::COIN_HAS_WEIGHT,
+
+/*NPC*/			true,
+/*Merc*/		true,
+/*Bot*/			true,
+/*Pet*/			true
+	};
+
+	return local[static_cast<unsigned int>(ValidateMobClientVersion(clientVersion))];
+}
+
+uint32 EQLimits::BandoliersCount(ClientVersion clientVersion) {
+	static const uint32 local[CLIENT_VERSION_COUNT] = {
+/*Unknown*/		NOT_USED,
+/*62*/			EmuConstants::BANDOLIERS_COUNT,
+/*Titanium*/	EmuConstants::BANDOLIERS_COUNT,
+/*SoF*/			EmuConstants::BANDOLIERS_COUNT,
+/*SoD*/			EmuConstants::BANDOLIERS_COUNT,
+/*Underfoot*/	EmuConstants::BANDOLIERS_COUNT,
+/*RoF*/			EmuConstants::BANDOLIERS_COUNT,
+/*RoF2*/		EmuConstants::BANDOLIERS_COUNT,
+
+/*NPC*/			NOT_USED,
+/*Merc*/		NOT_USED,
+/*Bot*/			NOT_USED,
+/*Pet*/			NOT_USED
+	};
+
+	return local[static_cast<unsigned int>(ValidateMobClientVersion(clientVersion))];
+}
+
+uint32 EQLimits::BandolierSize(ClientVersion clientVersion) {
+	static const uint32 local[CLIENT_VERSION_COUNT] = {
+/*Unknown*/		NOT_USED,
+/*62*/			EmuConstants::BANDOLIER_SIZE,
+/*Titanium*/	EmuConstants::BANDOLIER_SIZE,
+/*SoF*/			EmuConstants::BANDOLIER_SIZE,
+/*SoD*/			EmuConstants::BANDOLIER_SIZE,
+/*Underfoot*/	EmuConstants::BANDOLIER_SIZE,
+/*RoF*/			EmuConstants::BANDOLIER_SIZE,
+/*RoF2*/		EmuConstants::BANDOLIER_SIZE,
+
+/*NPC*/			NOT_USED,
+/*Merc*/		NOT_USED,
+/*Bot*/			NOT_USED,
+/*Pet*/			NOT_USED
+	};
+
+	return local[static_cast<unsigned int>(ValidateMobClientVersion(clientVersion))];
+}
+
+uint32 EQLimits::PotionBeltSize(ClientVersion clientVersion) {
+	static const uint32 local[CLIENT_VERSION_COUNT] = {
+/*Unknown*/		NOT_USED,
+/*62*/			EmuConstants::POTION_BELT_SIZE,
+/*Titanium*/	EmuConstants::POTION_BELT_SIZE,
+/*SoF*/			EmuConstants::POTION_BELT_SIZE,
+/*SoD*/			EmuConstants::POTION_BELT_SIZE,
+/*Underfoot*/	EmuConstants::POTION_BELT_SIZE,
+/*RoF*/			EmuConstants::POTION_BELT_SIZE,
+/*RoF2*/		EmuConstants::POTION_BELT_SIZE,
+
+/*NPC*/			NOT_USED,
+/*Merc*/		NOT_USED,
+/*Bot*/			NOT_USED,
+/*Pet*/			NOT_USED
+	};
+
+	return local[static_cast<unsigned int>(ValidateMobClientVersion(clientVersion))];
+}

common/eq_dictionary.h

@@ -0,0 +1,209 @@
+/*
+EQEMu:  Everquest Server Emulator
+
+Copyright (C) 2001-2014 EQEMu Development Team (http://eqemulator.net)
+
+This program 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; version 2 of the License.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY except by those people which sell it, which
+are required to give you total support for your newly bought product;
+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 this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+*/
+
+#ifndef EQ_DICTIONARY_H
+#define EQ_DICTIONARY_H
+
+#include "types.h"
+#include "eq_constants.h"
+#include "clientversions.h"
+#include <string>
+#include "../common/patches/titanium_constants.h"
+#include "../common/patches/sof_constants.h"
+#include "../common/patches/sod_constants.h"
+#include "../common/patches/uf_constants.h"
+#include "../common/patches/rof_constants.h"
+#include "../common/patches/rof2_constants.h"
+
+// *** DO NOT CHANGE without a full understanding of the consequences..the server is set up to use these settings explicitly!! ***
+// *** You will cause compilation failures and corrupt your database if partial or incorrect attempts to change them are made!! ***
+
+// Hard-coded values usually indicate that further research is needed and the values given are from the old (known) system
+
+// (future use)
+//using namespace RoF2::maps;	// server inventory maps enumeration (code and database sync'd to reference)
+//using namespace RoF::slots;	// server possessions slots enumeration (code and database sync'd to reference)
+
+class EmuConstants {
+	// an immutable value is required to initialize arrays, etc... use this class as a repository for those
+public:
+	// database
+	static const ClientVersion CHARACTER_CREATION_CLIENT = ClientVersion::RoF2; // adjust according to starting item placement and target client
+
+	// inventory
+	static uint16 InventoryMapSize(int16 indexMap);
+	//static std::string InventoryLocationName(Location_Struct location);
+	static std::string InventoryMapName(int16 indexMap);
+	static std::string InventoryMainName(int16 indexMain);
+	static std::string InventorySubName(int16 indexSub);
+	static std::string InventoryAugName(int16 indexAug);
+
+	// these are currently hard-coded for existing inventory system..do not use in place of special client version handlers until ready
+	static const uint16	MAP_POSSESSIONS_SIZE = _MainCount;
+	static const uint16 MAP_BANK_SIZE = 24;
+	static const uint16 MAP_SHARED_BANK_SIZE = 2;
+	static const uint16 MAP_TRADE_SIZE = 8;
+	static const uint16 MAP_WORLD_SIZE = 10;
+	static const uint16 MAP_LIMBO_SIZE = 36;
+	static const uint16 MAP_TRIBUTE_SIZE = 5; // (need client values)
+	static const uint16 MAP_TROPHY_TRIBUTE_SIZE = 0;
+	static const uint16 MAP_GUILD_TRIBUTE_SIZE = 0;
+	static const uint16 MAP_MERCHANT_SIZE = 0;
+	static const uint16 MAP_DELETED_SIZE = 0;
+	static const uint16 MAP_CORPSE_SIZE = _MainCount; // no bitmask use..limits to size of client corpse window (see EQLimits::InventoryMapSize(MapCorpse, <EQClientVersion))
+	static const uint16 MAP_BAZAAR_SIZE = 80;
+	static const uint16 MAP_INSPECT_SIZE = 22;
+	static const uint16 MAP_REAL_ESTATE_SIZE = 0;
+	static const uint16 MAP_VIEW_MOD_PC_SIZE = NOT_USED;
+	static const uint16 MAP_VIEW_MOD_BANK_SIZE = NOT_USED;
+	static const uint16 MAP_VIEW_MOD_SHARED_BANK_SIZE = NOT_USED;
+	static const uint16 MAP_VIEW_MOD_LIMBO_SIZE = NOT_USED;
+	static const uint16 MAP_ALT_STORAGE_SIZE = 0;
+	static const uint16 MAP_ARCHIVED_SIZE = 0;
+	static const uint16 MAP_MAIL_SIZE = 0;
+	static const uint16 MAP_GUILD_TROPHY_TRIBUTE_SIZE = 0;
+	static const uint16 MAP_KRONO_SIZE = 0;
+	static const uint16 MAP_OTHER_SIZE = 0;
+
+	// most of these definitions will go away with the structure-based system..this maintains compatibility for now
+	// (these are mainly to assign specific values to constants used in conversions and to identify per-client ranges/offsets)
+	static const int16 EQUIPMENT_BEGIN = MainCharm;
+	static const int16 EQUIPMENT_END = MainAmmo;
+	static const uint16 EQUIPMENT_SIZE = 22; // does not account for 'Power Source' - used mainly for npc equipment arrays
+
+	static const int16 GENERAL_BEGIN = MainGeneral1;
+	static const int16 GENERAL_END = MainGeneral8;
+	static const uint16 GENERAL_SIZE = 8;
+	static const int16 GENERAL_BAGS_BEGIN = 251;
+	static const int16 GENERAL_BAGS_END_OFFSET = 79;
+	static const int16 GENERAL_BAGS_END = GENERAL_BAGS_BEGIN + GENERAL_BAGS_END_OFFSET;
+
+	static const int16 CURSOR_BAG_BEGIN = 331;
+	static const int16 CURSOR_BAG_END_OFFSET = 9;
+	static const int16 CURSOR_BAG_END = CURSOR_BAG_BEGIN + CURSOR_BAG_END_OFFSET;
+
+	static const int16 BANK_BEGIN = 2000;
+	static const int16 BANK_END = 2023;
+	static const int16 BANK_BAGS_BEGIN = 2031;
+	static const int16 BANK_BAGS_END_OFFSET = 239;
+	static const int16 BANK_BAGS_END = BANK_BAGS_BEGIN + BANK_BAGS_END_OFFSET;
+
+	static const int16 SHARED_BANK_BEGIN = 2500;
+	static const int16 SHARED_BANK_END = 2501;
+	static const int16 SHARED_BANK_BAGS_BEGIN = 2531;
+	static const int16 SHARED_BANK_BAGS_END_OFFSET = 19;
+	static const int16 SHARED_BANK_BAGS_END = SHARED_BANK_BAGS_BEGIN + SHARED_BANK_BAGS_END_OFFSET;
+
+	static const int16 TRADE_BEGIN = 3000;
+	static const int16 TRADE_END = 3007;
+	static const int16 TRADE_NPC_END = 3003;
+	static const int16 TRADE_BAGS_BEGIN = 3031;
+	static const int16 TRADE_BAGS_END_OFFSET = 79;
+	static const int16 TRADE_BAGS_END = TRADE_BAGS_BEGIN + TRADE_BAGS_END_OFFSET;
+
+	static const int16 WORLD_BEGIN = 4000;
+	static const int16 WORLD_END = 4009;
+	static const int16 WORLD_SIZE = MAP_WORLD_SIZE;
+
+	static const int16 TRIBUTE_BEGIN = 400;
+	static const int16 TRIBUTE_END = 404;
+	static const int16 TRIBUTE_SIZE = MAP_TRIBUTE_SIZE;
+
+	static const int16 CORPSE_BEGIN = 22;
+	//static const int16 CORPSE_END = RoF::consts::CORPSE_END; // not ready for use
+
+	static const int16 MATERIAL_BEGIN = MaterialHead;
+	static const int16 MATERIAL_END = MaterialSecondary;
+	static const int16 MATERIAL_TINT_END = MaterialFeet;
+	static const int16 MATERIAL_SIZE = _MaterialCount;
+
+	// items
+	// common and container sizes will not increase until the new 'location' struct is implemented
+	static const uint16 ITEM_COMMON_SIZE = RoF::consts::ITEM_COMMON_SIZE;
+	static const uint16 ITEM_CONTAINER_SIZE = Titanium::consts::ITEM_CONTAINER_SIZE;
+
+	// player profile
+	//static const uint32 CLASS_BITMASK = 0;	// needs value
+	//static const uint32 RACE_BITMASK = 0;	// needs value
+
+	// BANDOLIERS_COUNT sets maximum limit..active limit will need to be handled by the appropriate AA
+	static const uint32 BANDOLIERS_COUNT = Titanium::consts::BANDOLIERS_COUNT;	// count = number of bandolier instances
+	static const uint32 BANDOLIER_SIZE = Titanium::consts::BANDOLIER_SIZE;		// size = number of equipment slots in bandolier instance
+	static const uint32 POTION_BELT_SIZE = Titanium::consts::POTION_BELT_SIZE;
+
+	static const size_t TEXT_LINK_BODY_LENGTH = 56;
+
+	// legacy-related functions
+	//static int ServerToPerlSlot(int slot);	// encode
+	//static int PerlToServerSlot(int slot);	// decode
+};
+
+class EQLimits {
+	// values should default to a non-beneficial value..unless value conflicts with intended operation
+	//
+	// EmuConstants may be used as references..but, not every reference needs to be in EmuConstants (i.e., AllowsEmptyBagInBag(), CoinHasWeight(), etc...)
+public:
+	// client version validation (checks to avoid crashing zone server when accessing reference arrays)
+	// use this inside of class Client (limits to actual clients)
+	static bool IsValidPCClientVersion(ClientVersion clientVersion);
+	static ClientVersion ValidatePCClientVersion(ClientVersion clientVersion);
+
+	// basically..any non-client classes - do not when setting a valid client
+	static bool IsValidNPCClientVersion(ClientVersion clientVersion);
+	static ClientVersion ValidateNPCClientVersion(ClientVersion clientVersion);
+
+	// these are 'universal' - do not when setting a valid client
+	static bool IsValidMobClientVersion(ClientVersion clientVersion);
+	static ClientVersion ValidateMobClientVersion(ClientVersion clientVersion);
+
+	// inventory
+	static uint16 InventoryMapSize(int16 indexMap, ClientVersion clientVersion);
+	static uint64 PossessionsBitmask(ClientVersion clientVersion);
+	static uint64 EquipmentBitmask(ClientVersion clientVersion);
+	static uint64 GeneralBitmask(ClientVersion clientVersion);
+	static uint64 CursorBitmask(ClientVersion clientVersion);
+
+	static bool AllowsEmptyBagInBag(ClientVersion clientVersion);
+	static bool AllowsClickCastFromBag(ClientVersion clientVersion);
+
+	// items
+	static uint16 ItemCommonSize(ClientVersion clientVersion);
+	static uint16 ItemContainerSize(ClientVersion clientVersion);
+
+	// player profile
+	static bool CoinHasWeight(ClientVersion clientVersion);
+
+	static uint32 BandoliersCount(ClientVersion clientVersion);
+	static uint32 BandolierSize(ClientVersion clientVersion);
+
+	static uint32 PotionBeltSize(ClientVersion clientVersion);
+};
+
+#endif /* EQ_DICTIONARY_H */
+
+/*
+Working Notes:
+--------------
+
+- full review of client_packet.cpp and client translators needed
+
+
+*/

common/eq_packet.cpp

@@ -15,18 +15,22 @@
 	along with this program; if not, write to the Free Software
 	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
-#include "debug.h"
-#include <stdio.h>
-#include <iostream>
-#include <iomanip>
-#include "EQPacket.h"
+
+#include "crc16.h"
+#include "global_define.h"
+#include "eq_packet.h"
 #include "misc.h"
 #include "op_codes.h"
-#include "CRC16.h"
 #include "platform.h"
+#include <iomanip>
+#include <iostream>
+#include <sstream>
+#include <stdio.h>
+
 #ifndef STATIC_OPCODE
 #include "opcodemgr.h"
 #endif
+
 #include "packet_dump.h"
 #include "packet_functions.h"
 #include <cstdlib>
@@ -36,9 +40,11 @@ EQPacket::EQPacket(EmuOpcode op, const unsigned char *buf, uint32 len)
 :	BasePacket(buf, len),
 	emu_opcode(op)
 {
+	_eqp
 }
 
 void EQPacket::build_raw_header_dump(char *buffer, uint16 seq) const {
+	_eqp
 	BasePacket::build_raw_header_dump(buffer, seq);
 	buffer += strlen(buffer);
 
@@ -47,17 +53,20 @@ void EQPacket::build_raw_header_dump(char *buffer, uint16 seq) const {
 
 void EQPacket::DumpRawHeader(uint16 seq, FILE *to) const
 {
+	_eqp
 	char buff[196];
 	build_raw_header_dump(buff, seq);
 	fprintf(to, "%s", buff);
 }
 
 void EQPacket::build_header_dump(char *buffer) const {
+	_eqp
 	sprintf(buffer, "[EmuOpCode 0x%04x Size=%u]", emu_opcode, size);
 }
 
 void EQPacket::DumpRawHeaderNoTime(uint16 seq, FILE *to) const
 {
+	_eqp
 	if (src_ip) {
 		std::string sIP,dIP;;
 		sIP=long2ip(src_ip);
@@ -72,6 +81,7 @@ void EQPacket::DumpRawHeaderNoTime(uint16 seq, FILE *to) const
 
 void EQProtocolPacket::build_raw_header_dump(char *buffer, uint16 seq) const
 {
+	_eqp
 	BasePacket::build_raw_header_dump(buffer, seq);
 	buffer += strlen(buffer);
 
@@ -80,6 +90,7 @@ void EQProtocolPacket::build_raw_header_dump(char *buffer, uint16 seq) const
 
 void EQProtocolPacket::DumpRawHeader(uint16 seq, FILE *to) const
 {
+	_eqp
 	char buff[196];
 	build_raw_header_dump(buff, seq);
 	fprintf(to, "%s", buff);
@@ -87,11 +98,13 @@ void EQProtocolPacket::DumpRawHeader(uint16 seq, FILE *to) const
 
 void EQProtocolPacket::build_header_dump(char *buffer) const
 {
+	_eqp
 	sprintf(buffer, "[ProtoOpCode 0x%04x Size=%u]",opcode,size);
 }
 
 void EQProtocolPacket::DumpRawHeaderNoTime(uint16 seq, FILE *to) const
 {
+	_eqp
 	if (src_ip) {
 		std::string sIP,dIP;;
 		sIP=long2ip(src_ip);
@@ -106,6 +119,7 @@ void EQProtocolPacket::DumpRawHeaderNoTime(uint16 seq, FILE *to) const
 
 void EQApplicationPacket::build_raw_header_dump(char *buffer, uint16 seq) const
 {
+	_eqp
 	BasePacket::build_raw_header_dump(buffer, seq);
 	buffer += strlen(buffer);
 
@@ -118,6 +132,7 @@ void EQApplicationPacket::build_raw_header_dump(char *buffer, uint16 seq) const
 
 void EQApplicationPacket::DumpRawHeader(uint16 seq, FILE *to) const
 {
+	_eqp
 	char buff[196];
 	build_raw_header_dump(buff, seq);
 	fprintf(to, "%s", buff);
@@ -125,6 +140,7 @@ void EQApplicationPacket::DumpRawHeader(uint16 seq, FILE *to) const
 
 void EQApplicationPacket::build_header_dump(char *buffer) const
 {
+	_eqp
 #ifdef STATIC_OPCODE
 	sprintf(buffer, "[OpCode 0x%04x Size=%u]\n", emu_opcode,size);
 #else
@@ -134,6 +150,7 @@ void EQApplicationPacket::build_header_dump(char *buffer) const
 
 void EQApplicationPacket::DumpRawHeaderNoTime(uint16 seq, FILE *to) const
 {
+	_eqp
 	if (src_ip) {
 		std::string sIP,dIP;;
 		sIP=long2ip(src_ip);
@@ -152,6 +169,7 @@ void EQApplicationPacket::DumpRawHeaderNoTime(uint16 seq, FILE *to) const
 
 void EQRawApplicationPacket::build_raw_header_dump(char *buffer, uint16 seq) const
 {
+	_eqp
 	BasePacket::build_raw_header_dump(buffer, seq);
 	buffer += strlen(buffer);
 
@@ -164,6 +182,7 @@ void EQRawApplicationPacket::build_raw_header_dump(char *buffer, uint16 seq) con
 
 void EQRawApplicationPacket::DumpRawHeader(uint16 seq, FILE *to) const
 {
+	_eqp
 	char buff[196];
 	build_raw_header_dump(buff, seq);
 	fprintf(to, "%s", buff);
@@ -171,6 +190,7 @@ void EQRawApplicationPacket::DumpRawHeader(uint16 seq, FILE *to) const
 
 void EQRawApplicationPacket::build_header_dump(char *buffer) const
 {
+	_eqp
 #ifdef STATIC_OPCODE
 	sprintf(buffer, "[OpCode 0x%04x (0x%04x) Size=%u]\n", emu_opcode, opcode,size);
 #else
@@ -180,6 +200,7 @@ void EQRawApplicationPacket::build_header_dump(char *buffer) const
 
 void EQRawApplicationPacket::DumpRawHeaderNoTime(uint16 seq, FILE *to) const
 {
+	_eqp
 	if (src_ip) {
 		std::string sIP,dIP;;
 		sIP=long2ip(src_ip);
@@ -198,6 +219,7 @@ void EQRawApplicationPacket::DumpRawHeaderNoTime(uint16 seq, FILE *to) const
 
 uint32 EQProtocolPacket::serialize(unsigned char *dest) const
 {
+	_eqp
 	if (opcode>0xff) {
 		*(uint16 *)dest=opcode;
 	} else {
@@ -211,6 +233,7 @@ uint32 EQProtocolPacket::serialize(unsigned char *dest) const
 
 uint32 EQApplicationPacket::serialize(uint16 opcode, unsigned char *dest) const
 {
+	_eqp
 	uint8 OpCodeBytes = app_opcode_size;
 
 	if (app_opcode_size==1)
@@ -232,29 +255,10 @@ uint32 EQApplicationPacket::serialize(uint16 opcode, unsigned char *dest) const
 	return size+OpCodeBytes;
 }
 
-/*EQProtocolPacket::EQProtocolPacket(uint16 op, const unsigned char *buf, uint32 len)
-:	BasePacket(buf, len),
-	opcode(op)
-{
-
-uint32 offset;
-	opcode=ntohs(*(const uint16 *)buf);
-	offset=2;
-
-	if (len-offset) {
-		pBuffer= new unsigned char[len-offset];
-		memcpy(pBuffer,buf+offset,len-offset);
-		size=len-offset;
-	} else {
-		pBuffer=nullptr;
-		size=0;
-	}
-	OpMgr=&RawOpcodeManager;
-}*/
-
 bool EQProtocolPacket::combine(const EQProtocolPacket *rhs)
 {
-bool result=false;
+	_eqp
+	bool result=false;
 	if (opcode==OP_Combined && size+rhs->size+5<256) {
 		unsigned char *tmpbuffer=new unsigned char [size+rhs->size+3];
 		memcpy(tmpbuffer,pBuffer,size);
@@ -280,61 +284,12 @@ bool result=false;
 	}
 
 	return result;
-
 }
 
-/*
-this is the code to do app-layer combining, instead of protocol layer.
-this was taken out due to complex interactions with the opcode manager,
-and will require a bit more thinking (likely moving into EQStream) to
-get running again... but might be a good thing some day.
-
-bool EQApplicationPacket::combine(const EQApplicationPacket *rhs)
-{
-uint32 newsize=0, offset=0;
-unsigned char *tmpbuffer=nullptr;
-
-	if (opcode!=OP_AppCombined) {
-		newsize=app_opcode_size+size+(size>254?3:1)+app_opcode_size+rhs->size+(rhs->size>254?3:1);
-		tmpbuffer=new unsigned char [newsize];
-		offset=0;
-		if (size>254) {
-			tmpbuffer[offset++]=0xff;
-			*(uint16 *)(tmpbuffer+offset)=htons(size);
-			offset+=1;
-		} else {
-			tmpbuffer[offset++]=size;
-		}
-		offset+=serialize(tmpbuffer+offset);
-	} else {
-		newsize=size+app_opcode_size+rhs->size+(rhs->size>254?3:1);
-		tmpbuffer=new unsigned char [newsize];
-		memcpy(tmpbuffer,pBuffer,size);
-		offset=size;
-	}
-
-	if (rhs->size>254) {
-		tmpbuffer[offset++]=0xff;
-		*(uint16 *)(tmpbuffer+offset)=htons(rhs->size);
-		offset+=1;
-	} else {
-		tmpbuffer[offset++]=rhs->size;
-	}
-	offset+=rhs->serialize(tmpbuffer+offset);
-
-	size=offset;
-	opcode=OP_AppCombined;
-
-	delete[] pBuffer;
-	pBuffer=tmpbuffer;
-
-	return true;
-}
-*/
-
 bool EQProtocolPacket::ValidateCRC(const unsigned char *buffer, int length, uint32 Key)
 {
-bool valid=false;
+	_eqp
+	bool valid=false;
 	// OP_SessionRequest, OP_SessionResponse, OP_OutOfSession are not CRC'd
 	if (buffer[0]==0x00 && (buffer[1]==OP_SessionRequest || buffer[1]==OP_SessionResponse || buffer[1]==OP_OutOfSession)) {
 		valid=true;
@@ -353,8 +308,9 @@ bool valid=false;
 
 uint32 EQProtocolPacket::Decompress(const unsigned char *buffer, const uint32 length, unsigned char *newbuf, uint32 newbufsize)
 {
-uint32 newlen=0;
-uint32 flag_offset=0;
+	_eqp
+	uint32 newlen=0;
+	uint32 flag_offset=0;
 	newbuf[0]=buffer[0];
 	if (buffer[0]==0x00) {
 		flag_offset=2;
@@ -378,7 +334,8 @@ uint32 flag_offset=0;
 }
 
 uint32 EQProtocolPacket::Compress(const unsigned char *buffer, const uint32 length, unsigned char *newbuf, uint32 newbufsize) {
-uint32 flag_offset=1,newlength;
+	_eqp
+	uint32 flag_offset=1,newlength;
 	//dump_message_column(buffer,length,"Before: ");
 	newbuf[0]=buffer[0];
 	if (buffer[0]==0) {
@@ -401,6 +358,7 @@ uint32 flag_offset=1,newlength;
 
 void EQProtocolPacket::ChatDecode(unsigned char *buffer, int size, int DecodeKey)
 {
+	_eqp
 	if ((size >= 2) && buffer[1]!=0x01 && buffer[0]!=0x02 && buffer[0]!=0x1d) {
 		int Key=DecodeKey;
 		unsigned char *test=(unsigned char *)malloc(size);
@@ -426,6 +384,7 @@ void EQProtocolPacket::ChatDecode(unsigned char *buffer, int size, int DecodeKey
 
 void EQProtocolPacket::ChatEncode(unsigned char *buffer, int size, int EncodeKey)
 {
+	_eqp
 	if (buffer[1]!=0x01 && buffer[0]!=0x02 && buffer[0]!=0x1d) {
 		int Key=EncodeKey;
 		char *test=(char*)malloc(size);
@@ -449,10 +408,12 @@ void EQProtocolPacket::ChatEncode(unsigned char *buffer, int size, int EncodeKey
 }
 
 EQApplicationPacket *EQApplicationPacket::Copy() const {
+	_eqp
 	return(new EQApplicationPacket(*this));
 }
 
 EQRawApplicationPacket *EQProtocolPacket::MakeAppPacket() const {
+	_eqp
 	EQRawApplicationPacket *res = new EQRawApplicationPacket(opcode, pBuffer, size);
 	res->copyInfo(this);
 	return(res);
@@ -462,10 +423,13 @@ EQRawApplicationPacket::EQRawApplicationPacket(uint16 opcode, const unsigned cha
 :	EQApplicationPacket(OP_Unknown, buf, len),
 	opcode(opcode)
 {
+	_eqp
 }
+
 EQRawApplicationPacket::EQRawApplicationPacket(const unsigned char *buf, const uint32 len)
 : EQApplicationPacket(OP_Unknown, buf+sizeof(uint16), len-sizeof(uint16))
 {
+	_eqp
 	if(GetExecutablePlatform() != ExePlatformUCS) {
 		opcode = *((const uint16 *) buf);
 		if(opcode == 0x0000)
@@ -476,7 +440,7 @@ EQRawApplicationPacket::EQRawApplicationPacket(const unsigned char *buf, const u
 				const unsigned char *packet_start = (buf + 3);
 				const int32 packet_length = len - 3;
 				safe_delete_array(pBuffer);
-				if(len >= 0)
+				if(packet_length >= 0)
 				{
 					size = packet_length;
 					pBuffer = new unsigned char[size];
@@ -499,11 +463,17 @@ EQRawApplicationPacket::EQRawApplicationPacket(const unsigned char *buf, const u
 }
 
 void DumpPacket(const EQApplicationPacket* app, bool iShowInfo) {
+	_eqp
 	if (iShowInfo) {
 		std::cout << "Dumping Applayer: 0x" << std::hex << std::setfill('0') << std::setw(4) << app->GetOpcode() << std::dec;
 		std::cout << " size:" << app->size << std::endl;
 	}
 	DumpPacketHex(app->pBuffer, app->size);
-//	DumpPacketAscii(app->pBuffer, app->size);
 }
 
+std::string DumpPacketToString(const EQApplicationPacket* app){
+	_eqp
+	std::ostringstream out;
+	out << DumpPacketHexToString(app->pBuffer, app->size);
+	return out.str();
+}

common/eq_packet.h

@@ -18,10 +18,9 @@
 #ifndef _EQPACKET_H
 #define _EQPACKET_H
 
-#include "BasePacket.h"
-#include "EQStreamType.h"
-#include "op_codes.h"
+#include "base_packet.h"
 #include "platform.h"
+#include <iostream>
 
 #ifdef STATIC_OPCODE
 	typedef unsigned short EmuOpcode;
@@ -30,9 +29,6 @@
 #include "emu_opcodes.h"
 #endif
 
-class EQStream;
-class EQStreamPair;
-
 class EQPacket : public BasePacket {
 	friend class EQStream;
 public:
@@ -97,16 +93,15 @@ protected:
 };
 
 class EQApplicationPacket : public EQPacket {
-//	friend class EQProtocolPacket;
 	friend class EQStream;
 public:
-	EQApplicationPacket() : EQPacket(OP_Unknown,nullptr,0)
+	EQApplicationPacket() : EQPacket(OP_Unknown, nullptr, 0), opcode_bypass(0)
 		{ app_opcode_size = GetExecutablePlatform() == ExePlatformUCS ? 1 : 2; }
-	EQApplicationPacket(const EmuOpcode op) : EQPacket(op,nullptr,0)
+	EQApplicationPacket(const EmuOpcode op) : EQPacket(op, nullptr, 0), opcode_bypass(0)
 		{ app_opcode_size = GetExecutablePlatform() == ExePlatformUCS ? 1 : 2; }
-	EQApplicationPacket(const EmuOpcode op, const uint32 len) : EQPacket(op,nullptr,len)
+	EQApplicationPacket(const EmuOpcode op, const uint32 len) : EQPacket(op, nullptr, len), opcode_bypass(0)
 		{ app_opcode_size = GetExecutablePlatform() == ExePlatformUCS ? 1 : 2; }
-	EQApplicationPacket(const EmuOpcode op, const unsigned char *buf, const uint32 len) : EQPacket(op,buf,len)
+	EQApplicationPacket(const EmuOpcode op, const unsigned char *buf, const uint32 len) : EQPacket(op, buf, len), opcode_bypass(0)
 		{ app_opcode_size = GetExecutablePlatform() == ExePlatformUCS ? 1 : 2; }
 	bool combine(const EQApplicationPacket *rhs);
 	uint32 serialize (uint16 opcode, unsigned char *dest) const;
@@ -119,12 +114,16 @@ public:
 	virtual void DumpRawHeader(uint16 seq=0xffff, FILE *to = stdout) const;
 	virtual void DumpRawHeaderNoTime(uint16 seq=0xffff, FILE *to = stdout) const;
 
+	uint16 GetOpcodeBypass() { return opcode_bypass; }
+	void SetOpcodeBypass(uint16 v) { opcode_bypass = v; }
+
 protected:
 
 	uint8 app_opcode_size;
+	uint16 opcode_bypass;
 private:
 
-	EQApplicationPacket(const EQApplicationPacket &p) : EQPacket(p.emu_opcode, p.pBuffer, p.size) { app_opcode_size = p.app_opcode_size; }
+	EQApplicationPacket(const EQApplicationPacket &p) : EQPacket(p.emu_opcode, p.pBuffer, p.size), opcode_bypass(p.opcode_bypass) { app_opcode_size = p.app_opcode_size; }
 
 };
 
@@ -148,6 +147,6 @@ protected:
 };
 
 extern void DumpPacket(const EQApplicationPacket* app, bool iShowInfo = false);
-
+extern std::string DumpPacketToString(const EQApplicationPacket* app);
 
 #endif

common/eq_packet_structs.h

@@ -32,7 +32,8 @@ static const uint32 MAX_MERC_GRADES = 10;
 static const uint32 MAX_MERC_STANCES = 10;
 static const uint32 BLOCKED_BUFF_COUNT = 20;
 
-#include "eq_constants.h"
+//#include "eq_constants.h"
+#include "eq_dictionary.h"
 
 /*
 ** Compiler override to ensure
@@ -144,6 +145,28 @@ struct Color_Struct
 	};
 };
 
+/*
+* Visible equiptment.
+* Size: 20 Octets
+*/
+struct EquipStruct {
+	/*00*/ uint32 material;
+	/*04*/ uint32 unknown1;
+	/*08*/ uint32 elitematerial;
+	/*12*/ uint32 heroforgemodel;
+	/*16*/ uint32 material2;	// Same as material?
+	/*20*/
+};
+
+struct CharSelectEquip {
+	uint32 material;
+	uint32 unknown1;
+	uint32 elitematerial;
+	uint32 heroforgemodel;
+	uint32 material2;
+	Color_Struct color;
+};
+
 /*
 ** Character Selection Struct
 ** Length: 1704 Bytes
@@ -151,10 +174,11 @@ struct Color_Struct
 */
 struct CharacterSelect_Struct {
 /*0000*/	uint32	race[10];				// Characters Race
-/*0040*/	Color_Struct	cs_colors[10][9];	// Characters Equipment Colors
+/*0040*/	//Color_Struct	cs_colors[10][9];	// Characters Equipment Colors
 /*0400*/	uint8	beardcolor[10];			// Characters beard Color
 /*0410*/	uint8	hairstyle[10];			// Characters hair style
-/*0420*/	uint32	equip[10][9];			// 0=helm, 1=chest, 2=arm, 3=bracer, 4=hand, 5=leg, 6=boot, 7=melee1, 8=melee2 (Might not be)
+/*0420*/	//uint32	equip[10][9];			// 0=helm, 1=chest, 2=arm, 3=bracer, 4=hand, 5=leg, 6=boot, 7=melee1, 8=melee2 (Might not be)
+/*0000*/	CharSelectEquip	equip[10][9];
 /*0780*/	uint32	secondary[10];			// Characters secondary IDFile number
 /*0820*/	uint32	drakkin_heritage[10];		// added for SoF
 /*0860*/	uint32	drakkin_tattoo[10];			// added for SoF
@@ -257,26 +281,26 @@ struct Spawn_Struct {
 /*0193*/ uint8	guildrank;			// 0=normal, 1=officer, 2=leader
 /*0194*/ uint8	unknown0194[3];
 /*0197*/ union
-		 {
-			struct
-			{
-				/*0197*/ uint32 equip_helmet;		// Equipment: Helmet Visual
-				/*0201*/ uint32 equip_chest;		// Equipment: Chest Visual
-				/*0205*/ uint32 equip_arms;			// Equipment: Arms Visual
-				/*0209*/ uint32 equip_bracers;		// Equipment: Bracers Visual
-				/*0213*/ uint32 equip_hands;		// Equipment: Hands Visual
-				/*0217*/ uint32 equip_legs;			// Equipment: Legs Visual
-				/*0221*/ uint32 equip_feet;			// Equipment: Feet Visual
-				/*0225*/ uint32 equip_primary;		// Equipment: Primary Visual
-				/*0229*/ uint32 equip_secondary;	// Equipment: Secondary Visual
-			} equip;
-			/*0197*/ uint32 equipment[_MaterialCount]; // Array elements correspond to struct equipment above
-		 };
+{
+	struct
+	{
+		/*0000*/ EquipStruct equip_helmet;     // Equipment: Helmet visual
+		/*0000*/ EquipStruct equip_chest;      // Equipment: Chest visual
+		/*0000*/ EquipStruct equip_arms;       // Equipment: Arms visual
+		/*0000*/ EquipStruct equip_bracers;    // Equipment: Wrist visual
+		/*0000*/ EquipStruct equip_hands;      // Equipment: Hands visual
+		/*0000*/ EquipStruct equip_legs;       // Equipment: Legs visual
+		/*0000*/ EquipStruct equip_feet;       // Equipment: Boots visual
+		/*0000*/ EquipStruct equip_primary;    // Equipment: Main visual
+		/*0000*/ EquipStruct equip_secondary;  // Equipment: Off visual
+	} equip;
+	/*0000*/ EquipStruct equipment[_MaterialCount];
+};
 /*0233*/ float	runspeed;		// Speed when running
 /*0036*/ uint8	afk;			// 0=no, 1=afk
 /*0238*/ uint32	guildID;		// Current guild
 /*0242*/ char	title[32];		// Title
-/*0274*/ uint8	unknown0274;
+/*0274*/ uint8	unknown0274;	// non-zero prefixes name with '!'
 /*0275*/ uint8	set_to_0xFF[8];	// ***Placeholder (all ff)
 /*0283*/ uint8	helm;			// Helm texture
 /*0284*/ uint32	race;			// Spawn race
@@ -339,6 +363,7 @@ union
 	uint32 DestructibleUnk7;
 	uint8 DestructibleUnk8;
 	uint32 DestructibleUnk9;
+	bool targetable_with_hotkey;
 
 };
 
@@ -477,7 +502,11 @@ struct CastSpell_Struct
 	uint32	spell_id;
 	uint32	inventoryslot; // slot for clicky item, 0xFFFF = normal cast
 	uint32	target_id;
-	uint8	cs_unknown[4];
+	uint32  cs_unknown1;
+	uint32  cs_unknown2;
+ 	float   y_pos;
+ 	float   x_pos;
+	float   z_pos;
 };
 
 struct SpellEffect_Struct
@@ -511,7 +540,7 @@ struct SpawnAppearance_Struct
 };
 
 
-// solar: this is used inside profile
+// this is used inside profile
 struct SpellBuff_Struct
 {
 /*000*/	uint8	slotid;		//badly named... seems to be 2 for a real buff, 0 otherwise
@@ -533,7 +562,7 @@ struct SpellBuffFade_Struct {
 /*007*/	uint8 unknown7;
 /*008*/	uint32 spellid;
 /*012*/	uint32 duration;
-/*016*/	uint32 unknown016;
+/*016*/	uint32 num_hits;
 /*020*/	uint32 unknown020;	//prolly global player ID
 /*024*/	uint32 slotid;
 /*028*/	uint32 bufffade;
@@ -596,8 +625,8 @@ struct GMTrainee_Struct
 {
 	/*000*/ uint32 npcid;
 	/*004*/ uint32 playerid;
-	/*008*/ uint32 skills[73];
-	/*300*/ uint8 unknown300[148];
+	/*008*/ uint32 skills[PACKET_SKILL_ARRAY_SIZE];
+	/*408*/ uint8 unknown408[40];
 	/*448*/
 };
 
@@ -688,7 +717,7 @@ struct CharCreate_Struct
 /*0076*/	uint32	drakkin_heritage;	// added for SoF
 /*0080*/	uint32	drakkin_tattoo;		// added for SoF
 /*0084*/	uint32	drakkin_details;	// added for SoF
-/*0088*/
+/*0088*/	uint32	tutorial;
 };
 
 /*
@@ -720,12 +749,8 @@ struct Disciplines_Struct {
 	uint32 values[MAX_PP_DISCIPLINES];
 };
 
-static const uint32 TRIBUTE_SLOT_START = 400;
-static const uint32 MAX_PLAYER_TRIBUTES = 5;
-static const uint32 MAX_PLAYER_BANDOLIER = 4;
-static const uint32 MAX_PLAYER_BANDOLIER_ITEMS = 4;
-static const uint32 MAX_POTIONS_IN_BELT = 4;
 static const uint32 TRIBUTE_NONE = 0xFFFFFFFF;
+
 struct Tribute_Struct {
 	uint32 tribute;
 	uint32 tier;
@@ -747,10 +772,10 @@ enum { //bandolier item positions
 };
 struct Bandolier_Struct {
 	char name[32];
-	BandolierItem_Struct items[MAX_PLAYER_BANDOLIER_ITEMS];
+	BandolierItem_Struct items[EmuConstants::BANDOLIER_SIZE];
 };
 struct PotionBelt_Struct {
-	BandolierItem_Struct items[MAX_POTIONS_IN_BELT];
+	BandolierItem_Struct items[EmuConstants::POTION_BELT_SIZE];
 };
 
 struct MovePotionToBelt_Struct {
@@ -762,14 +787,62 @@ struct MovePotionToBelt_Struct {
 static const uint32 MAX_GROUP_LEADERSHIP_AA_ARRAY = 16;
 static const uint32 MAX_RAID_LEADERSHIP_AA_ARRAY = 16;
 static const uint32 MAX_LEADERSHIP_AA_ARRAY = (MAX_GROUP_LEADERSHIP_AA_ARRAY+MAX_RAID_LEADERSHIP_AA_ARRAY);
-struct LeadershipAA_Struct {
-	uint32 ranks[MAX_LEADERSHIP_AA_ARRAY];
-};
 struct GroupLeadershipAA_Struct {
-	uint32 ranks[MAX_GROUP_LEADERSHIP_AA_ARRAY];
+	union {
+		struct {
+			uint32 groupAAMarkNPC;
+			uint32 groupAANPCHealth;
+			uint32 groupAADelegateMainAssist;
+			uint32 groupAADelegateMarkNPC;
+			uint32 groupAA4;
+			uint32 groupAA5;
+			uint32 groupAAInspectBuffs;
+			uint32 groupAA7;
+			uint32 groupAASpellAwareness;
+			uint32 groupAAOffenseEnhancement;
+			uint32 groupAAManaEnhancement;
+			uint32 groupAAHealthEnhancement;
+			uint32 groupAAHealthRegeneration;
+			uint32 groupAAFindPathToPC;
+			uint32 groupAAHealthOfTargetsTarget;
+			uint32 groupAA15;
+		};
+		uint32 ranks[MAX_GROUP_LEADERSHIP_AA_ARRAY];
+	};
 };
+
 struct RaidLeadershipAA_Struct {
-	uint32 ranks[MAX_RAID_LEADERSHIP_AA_ARRAY];
+	union {
+		struct {
+			uint32 raidAAMarkNPC;
+			uint32 raidAANPCHealth;
+			uint32 raidAADelegateMainAssist;
+			uint32 raidAADelegateMarkNPC;
+			uint32 raidAA4;
+			uint32 raidAA5;
+			uint32 raidAA6;
+			uint32 raidAASpellAwareness;
+			uint32 raidAAOffenseEnhancement;
+			uint32 raidAAManaEnhancement;
+			uint32 raidAAHealthEnhancement;
+			uint32 raidAAHealthRegeneration;
+			uint32 raidAAFindPathToPC;
+			uint32 raidAAHealthOfTargetsTarget;
+			uint32 raidAA14;
+			uint32 raidAA15;
+		};
+		uint32 ranks[MAX_RAID_LEADERSHIP_AA_ARRAY];
+	};
+};
+
+struct LeadershipAA_Struct {
+	union {
+		struct {
+			GroupLeadershipAA_Struct group;
+			RaidLeadershipAA_Struct raid;
+		};
+		uint32 ranks[MAX_LEADERSHIP_AA_ARRAY];
+	};
 };
 
  /**
@@ -782,17 +855,18 @@ struct BindStruct {
 	/*008*/ float y;
 	/*012*/ float z;
 	/*016*/ float heading;
-	/*020*/
+	/*020*/ uint32 instance_id;
+	/*024*/
 };
 
 struct SuspendedMinion_Struct
 {
-	/*000*/	uint16	SpellID;
-	/*002*/	uint32	HP;
-	/*006*/	uint32	Mana;
-	/*010*/	SpellBuff_Struct	Buffs[BUFF_COUNT];
-	/*510*/	uint32	Items[_MaterialCount];
-	/*546*/	char	Name[64];
+	/*000*/	uint16 SpellID;
+	/*002*/	uint32 HP;
+	/*006*/	uint32 Mana;
+	/*010*/	SpellBuff_Struct Buffs[BUFF_COUNT];
+	/*510*/	uint32 Items[_MaterialCount];
+	/*546*/	char Name[64];
 	/*610*/
 };
 
@@ -803,10 +877,13 @@ struct SuspendedMinion_Struct
 ** Length: 4308 bytes
 ** OpCode: 0x006a
  */
-static const uint32 MAX_PP_LANGUAGE		= 28;
-static const uint32 MAX_PP_SPELLBOOK	= 480;	// Increased to 480 to support SoF
-static const uint32 MAX_PP_MEMSPELL		= 9;
-static const uint32 MAX_PP_SKILL		= _SkillPacketArraySize;	// 100 - actual skills buffer size
+static const uint32 MAX_PP_LANGUAGE = 28;
+static const uint32 MAX_PP_SPELLBOOK = 480;	// Set for all functions
+static const uint32 MAX_PP_MEMSPELL = 9; // Set to latest client so functions can work right
+static const uint32 MAX_PP_REF_SPELLBOOK = 480;	// Set for Player Profile size retain
+static const uint32 MAX_PP_REF_MEMSPELL = 9; // Set for Player Profile size retain
+
+static const uint32 MAX_PP_SKILL		= PACKET_SKILL_ARRAY_SIZE;	// 100 - actual skills buffer size
 static const uint32 MAX_PP_AA_ARRAY		= 240;
 static const uint32 MAX_GROUP_MEMBERS	= 6;
 static const uint32 MAX_RECAST_TYPES	= 20;
@@ -883,7 +960,7 @@ struct PlayerProfile_Struct
 /*0245*/	uint8				guildbanker;
 /*0246*/	uint8				unknown0246[6];		//
 /*0252*/	uint32				intoxication;
-/*0256*/	uint32				spellSlotRefresh[MAX_PP_MEMSPELL];	//in ms
+/*0256*/	uint32				spellSlotRefresh[MAX_PP_REF_MEMSPELL];	//in ms
 /*0292*/	uint32				abilitySlotRefresh;
 /*0296*/	uint8				haircolor;			// Player hair color
 /*0297*/	uint8				beardcolor;			// Player beard color
@@ -922,9 +999,9 @@ struct PlayerProfile_Struct
 /*2505*/	uint8				unknown2541[47];	// ?
 /*2552*/	uint8				languages[MAX_PP_LANGUAGE];
 /*2580*/	uint8				unknown2616[4];
-/*2584*/	uint32				spell_book[MAX_PP_SPELLBOOK];
+/*2584*/	uint32				spell_book[MAX_PP_REF_SPELLBOOK];
 /*4504*/	uint8				unknown4540[128];	// Was [428] all 0xff
-/*4632*/	uint32				mem_spells[MAX_PP_MEMSPELL];
+/*4632*/	uint32				mem_spells[MAX_PP_REF_MEMSPELL];
 /*4668*/	uint8				unknown4704[32];	//
 /*4700*/	float				y;					// Player y position
 /*4704*/	float				x;					// Player x position
@@ -999,7 +1076,7 @@ struct PlayerProfile_Struct
 /*7212*/	uint32				tribute_points;
 /*7216*/	uint32				unknown7252;
 /*7220*/	uint32				tribute_active;		//1=active
-/*7224*/	Tribute_Struct		tributes[MAX_PLAYER_TRIBUTES];
+/*7224*/	Tribute_Struct		tributes[EmuConstants::TRIBUTE_SIZE];
 /*7264*/	Disciplines_Struct	disciplines;
 /*7664*/	uint32				recastTimers[MAX_RECAST_TYPES];	// Timers (GMT of last use)
 /*7744*/	char				unknown7780[160];
@@ -1026,7 +1103,7 @@ struct PlayerProfile_Struct
 /*12800*/	uint32				expAA;
 /*12804*/	uint32				aapoints;			//avaliable, unspent
 /*12808*/	uint8				unknown12844[36];
-/*12844*/	Bandolier_Struct	bandoliers[MAX_PLAYER_BANDOLIER];
+/*12844*/	Bandolier_Struct	bandoliers[EmuConstants::BANDOLIERS_COUNT];
 /*14124*/	uint8				unknown14160[4506];
 /*18630*/	SuspendedMinion_Struct	SuspendedMinion; // No longer in use
 /*19240*/	uint32				timeentitledonaccount;
@@ -1191,7 +1268,7 @@ struct Animation_Struct {
 /*04*/
 };
 
-// solar: this is what causes the caster to animate and the target to
+// this is what causes the caster to animate and the target to
 // get the particle effects around them when a spell is cast
 // also causes a buff icon
 struct Action_Struct
@@ -1215,7 +1292,7 @@ struct Action_Struct
  /* 31 */
 };
 
-// solar: this is what prints the You have been struck. and the regular
+// this is what prints the You have been struck. and the regular
 // melee messages like You try to pierce, etc. It's basically the melee
 // and spell damage message
 struct CombatDamage_Struct
@@ -1303,19 +1380,19 @@ struct PlayerPositionUpdateServer_Struct
 struct PlayerPositionUpdateClient_Struct
 {
 /*0000*/ uint16	spawn_id;
-/*0022*/ uint16	sequence;	//increments one each packet
+/*0002*/ uint16	sequence;			//increments one each packet
 /*0004*/ float	y_pos;				// y coord
 /*0008*/ float	delta_z;			// Change in z
-/*0016*/ float	delta_x;			// Change in x
-/*0012*/ float	delta_y;			// Change in y
+/*0012*/ float	delta_x;			// Change in x
+/*0016*/ float	delta_y;			// Change in y
 /*0020*/ int32	animation:10,		// animation
 				delta_heading:10,	// change in heading
 				padding0020:12;		// ***Placeholder (mostly 1)
 /*0024*/ float	x_pos;				// x coord
 /*0028*/ float	z_pos;				// z coord
-/*0034*/ uint16	heading:12,			// Directional heading
+/*0032*/ uint16	heading:12,			// Directional heading
 				padding0004:4;		// ***Placeholder
-/*0032*/ uint8	unknown0006[2];		// ***Placeholder
+/*0034*/ uint8	unknown0006[2];		// ***Placeholder
 /*0036*/
 };
 
@@ -1432,7 +1509,8 @@ enum ItemPacketType
 	ItemPacketTributeItem		= 0x6C,
 	ItemPacketMerchant			= 0x64,
 	ItemPacketWorldContainer	= 0x6B,
-	ItemPacketCharmUpdate		= 0x6E
+	ItemPacketCharmUpdate		= 0x6E,
+	ItemPacketInvalid			= 0xFF
 };
 struct ItemPacket_Struct
 {
@@ -1449,17 +1527,18 @@ struct BulkItemPacket_Struct
 
 struct Consume_Struct
 {
-/*0000*/ uint32 slot;
-/*0004*/ uint32 auto_consumed; // 0xffffffff when auto eating e7030000 when right click
-/*0008*/ uint8 c_unknown1[4];
-/*0012*/ uint8 type; // 0x01=Food 0x02=Water
-/*0013*/ uint8 unknown13[3];
+/*0000*/ uint32	slot;
+/*0004*/ uint32	auto_consumed; // 0xffffffff when auto eating e7030000 when right click
+/*0008*/ uint8	c_unknown1[4];
+/*0012*/ uint8	type; // 0x01=Food 0x02=Water
+/*0013*/ uint8	unknown13[3];
 };
 
 struct DeleteItem_Struct {
-/*0000*/ uint32 from_slot;
-/*0004*/ uint32 to_slot;
-/*0008*/ uint32 number_in_stack;
+/*0000*/ uint32	from_slot;
+/*0004*/ uint32	to_slot;
+/*0008*/ uint32	number_in_stack;
+/*0012*/
 };
 
 struct MoveItem_Struct
@@ -1467,6 +1546,18 @@ struct MoveItem_Struct
 /*0000*/ uint32 from_slot;
 /*0004*/ uint32 to_slot;
 /*0008*/ uint32 number_in_stack;
+/*0012*/
+};
+
+// both MoveItem_Struct/DeleteItem_Struct server structures will be changing to a structure-based slot format..this will
+// be used for handling SoF/SoD/etc... time stamps sent using the MoveItem_Struct format. (nothing will be done with this
+// info at the moment..but, it is forwarded on to the server for handling/future use)
+struct ClientTimeStamp_Struct
+{
+/*0000*/ uint32	from_slot;
+/*0004*/ uint32	to_slot;
+/*0008*/ uint32	number_in_stack;
+/*0012*/
 };
 
 //
@@ -1720,7 +1811,7 @@ struct RandomReq_Struct {
 	uint32 high;
 };
 
-/* solar: 9/23/03 reply to /random command; struct from Zaphod */
+/* 9/23/03 reply to /random command */
 struct RandomReply_Struct {
 /* 00 */	uint32 low;
 /* 04 */	uint32 high;
@@ -2170,6 +2261,12 @@ struct GroupLeaderChange_Struct
 /*128*/		char	Unknown128[20];
 };
 
+struct GroupMentor_Struct {
+/*000*/	int percent;
+/*004*/	char name[64];
+/*068*/
+};
+
 struct FaceChange_Struct {
 /*000*/	uint8	haircolor;
 /*001*/	uint8	beardcolor;
@@ -2280,15 +2377,18 @@ struct Stun_Struct { // 4 bytes total
 };
 
 struct AugmentItem_Struct {
-/*00*/	int16	container_slot;
-/*02*/	char	unknown02[2];
-/*04*/	int32	augment_slot;
-/*08*/
+/*00*/	uint32	container_index;
+/*04*/	int32	container_slot;
+/*08*/	uint32  augment_index;
+/*12*/	int32	augment_slot;
+/*16*/	uint32	dest_inst_id;			// The unique serial number for the item instance that is being augmented
+/*20*/	int32	augment_action;			// Guessed - 0 = augment, 1 = remove with distiller, 3 = delete aug
+/*24*/
 };
 
 // OP_Emote
 struct Emote_Struct {
-/*0000*/	uint32 unknown01;
+/*0000*/	uint32 type;			// 0 - custom, 0xffffffff - command (/dance, /flip, etc...)
 /*0004*/	char message[1024];
 /*1028*/
 };
@@ -2589,6 +2689,17 @@ struct Translocate_Struct {
 /*088*/	uint32	Complete;
 };
 
+struct PendingTranslocate_Struct
+{
+	uint32 zone_id;
+	uint16 instance_id;
+	float heading;
+	float x;
+	float y;
+	float z;
+	uint32 spell_id;
+};
+
 struct Sacrifice_Struct {
 /*000*/	uint32	CasterID;
 /*004*/	uint32	TargetID;
@@ -2809,7 +2920,7 @@ uint8	npccastfilters;			// 0) No, 1) Ignore NPC Casts (all), 2) Ignore NPC Casts
 */
 struct	ItemViewRequest_Struct {
 /*000*/	uint32	item_id;
-/*004*/	uint32	augments[5];
+/*004*/	uint32	augments[6];
 /*024*/ uint32	link_hash;
 /*028*/	uint32	unknown028;
 /*032*/	char	unknown032[12];	//probably includes loregroup & evolving info. see Client::MakeItemLink() in zone/inventory.cpp:469
@@ -2905,14 +3016,14 @@ struct ClientError_Struct
 };
 
 struct Track_Struct {
-	uint16 entityid;
-	uint16 padding002;
+	uint32 entityid;
 	float distance;
 	// Fields for SoD and later
 	uint8 level;
-	uint8 NPC;
-	uint8 GroupMember;
+	uint8 is_npc;
 	char name[64];
+	uint8 is_pet;
+	uint8 is_merc;
 };
 
 struct Tracking_Struct {
@@ -3342,8 +3453,8 @@ struct SelectTributeReply_Struct {
 
 struct TributeInfo_Struct {
 	uint32	active;		//0 == inactive, 1 == active
-	uint32	tributes[MAX_PLAYER_TRIBUTES];	//-1 == NONE
-	uint32	tiers[MAX_PLAYER_TRIBUTES];		//all 00's
+	uint32	tributes[EmuConstants::TRIBUTE_SIZE];	//-1 == NONE
+	uint32	tiers[EmuConstants::TRIBUTE_SIZE];		//all 00's
 	uint32	tribute_master_id;
 };
 
@@ -3387,7 +3498,7 @@ struct Split_Struct
 */
 struct NewCombine_Struct {
 /*00*/	int16	container_slot;
-/*02*/	char	unknown02[2];
+/*02*/	int16	guildtribute_slot;
 /*04*/
 };
 
@@ -3461,6 +3572,7 @@ struct MerchantList {
 	int8	level_required;
 	uint16	alt_currency_cost;
 	uint32	classes_required;
+	uint8	probability;
 };
 
 struct TempMerchantList {
@@ -3897,6 +4009,11 @@ struct MarkNPC_Struct
 /*08**/	char	Name[64];
 };
 
+struct InspectBuffs_Struct {
+/*000*/ uint32 spell_id[BUFF_COUNT];
+/*100*/ uint32 tics_remaining[BUFF_COUNT];
+};
+
 struct RaidGeneral_Struct {
 /*00*/	uint32		action;	//=10
 /*04*/	char		player_name[64];	//should both be the player's name
@@ -3912,6 +4029,19 @@ struct RaidAddMember_Struct {
 /*139*/	uint8 flags[5]; //no idea if these are needed...
 };
 
+struct RaidMOTD_Struct {
+/*000*/ RaidGeneral_Struct general; // leader_name and action only used
+/*136*/ char motd[0]; // max size is 1024, but reply is variable
+};
+
+struct RaidLeadershipUpdate_Struct {
+/*000*/	uint32 action;
+/*004*/	char player_name[64];
+/*068*/	char leader_name[64];
+/*132*/	GroupLeadershipAA_Struct group; //unneeded
+/*196*/	RaidLeadershipAA_Struct raid;
+/*260*/	char Unknown260[128]; //unverified
+};
 
 struct RaidAdd_Struct {
 /*000*/	uint32		action;	//=0
@@ -4053,7 +4183,7 @@ struct GroupInvite_Struct {
 //	uint8	unknown128[65];
 };
 
-struct BuffFadeMsg_Struct {
+struct ColoredText_Struct {
 	uint32 color;
 	char msg[1];
 };
@@ -4250,6 +4380,13 @@ struct ItemVerifyReply_Struct {
 /*012*/
 };
 
+struct ItemRecastDelay_Struct {
+/*000*/	uint32	recast_delay;	// in seconds
+/*004*/	uint32	recast_type;
+/*008*/	uint32	unknown008;
+/*012*/
+};
+
 /**
  * Shroud yourself. For yourself shrouding, this has your spawnId, spawnStruct,
  * bits of your charProfileStruct (no checksum, then charProfile up till
@@ -4283,14 +4420,14 @@ typedef struct {
 struct ControlBoat_Struct {
 /*000*/	uint32	boatId;			// entitylist id of the boat
 /*004*/	bool	TakeControl;	// 01 if taking control, 00 if releasing it
-/*007*/							// no idea what these last three bytes represent
+/*007*/	char	unknown[3];		// no idea what these last three bytes represent
 };
 
 struct AugmentInfo_Struct
 {
-/*000*/ uint32	itemid;		// id of the solvent needed
-/*004*/ uint8	window;		// window to display the information in
-/*005*/	uint8	unknown005[67];	// total packet length 72, all the rest were always 00
+/*000*/ uint32	itemid;			// id of the solvent needed
+/*004*/ uint32	window;			// window to display the information in
+/*008*/ char	augment_info[64];	// the reply has the text here
 /*072*/
 };
 
@@ -4453,6 +4590,14 @@ struct GuildBankPromote_Struct
 /*12*/	uint32	Slot2;	// Always appears to be the same as Slot for Action code 3
 };
 
+struct GuildPromoteStruct {
+/*000*/	char	target[64];
+/*064*/	char	name[64];
+/*128*/	uint32	rank;
+/*132*/	uint32	myrank;
+/*136*/
+};
+
 struct GuildBankPermissions_Struct
 {
 /*00*/	uint32	Action;	// 6
@@ -4570,11 +4715,13 @@ struct BuffIconEntry_Struct
 	uint32 buff_slot;
 	uint32 spell_id;
 	uint32 tics_remaining;
+	uint32 num_hits;
 };
 
 struct BuffIcon_Struct
 {
 	uint32 entity_id;
+	uint8  all_buffs;
 	uint16 count;
 	BuffIconEntry_Struct entries[0];
 };
@@ -5087,17 +5234,19 @@ struct MercenaryMerchantResponse_Struct {
 };
 
 struct ServerLootItem_Struct {
-	uint32	item_id;
-	int16	equipSlot;
-	uint8	charges;
-	uint16	lootslot;
-	uint32 aug1;
-	uint32 aug2;
-	uint32 aug3;
-	uint32 aug4;
-	uint32 aug5;
-	uint8 minlevel;
-	uint8 maxlevel;
+	uint32	item_id;	  // uint32	item_id;
+	int16	equip_slot;	  // int16	equip_slot;
+	uint16	charges;	  // uint8	charges; 
+	uint16	lootslot;	  // uint16	lootslot;
+	uint32	aug_1;		  // uint32	aug_1;
+	uint32	aug_2;		  // uint32	aug_2;
+	uint32	aug_3;		  // uint32	aug_3;
+	uint32	aug_4;		  // uint32	aug_4;
+	uint32	aug_5;		  // uint32	aug_5;
+	uint32	aug_6;		  // uint32	aug_5;
+	uint8	attuned;
+	uint8	min_level;
+	uint8	max_level;
 };
 
 //Found in client near a ref to the string:
@@ -5120,6 +5269,23 @@ struct ClientMarqueeMessage_Struct {
 
 typedef std::list<ServerLootItem_Struct*> ItemList;
 
+struct TextLinkBody_Struct {
+	// Current server mask: EQClientRoF2
+	uint8 unknown_1;		/* %1X */
+	uint32 item_id;			/* %05X */
+	uint32 augment_1;		/* %05X */
+	uint32 augment_2;		/* %05X */
+	uint32 augment_3;		/* %05X */
+	uint32 augment_4;		/* %05X */
+	uint32 augment_5;		/* %05X */
+	uint32 augment_6;		/* %05X */
+	uint8 is_evolving;		/* %1X */
+	uint32 evolve_group;	/* %05X */
+	uint8 evolve_level;		/* %02X */
+	uint32 ornament_icon;	/* %05X */
+	int hash;				/* %08X */
+};
+
 // Restore structure packing to default
 #pragma pack()
 

common/eq_stream.h

@@ -1,23 +1,27 @@
 #ifndef _EQSTREAM_H
 #define _EQSTREAM_H
 
-#include <string>
 #include <vector>
 #include <map>
 #include <queue>
 #include <deque>
+
 #ifndef WIN32
 #include <netinet/in.h>
 #endif
-#include "EQStreamType.h"
-#include "EQPacket.h"
-#include "EQStreamIntf.h"
-#include "Mutex.h"
-#include "../common/opcodemgr.h"
+
 #include "../common/misc.h"
-#include "../common/Condition.h"
+#include "../common/opcodemgr.h"
 #include "../common/timer.h"
 
+#include "eq_packet.h"
+#include "eq_stream_intf.h"
+#include "eq_stream_type.h"
+#include "mutex.h"
+
+class EQApplicationPacket;
+class EQProtocolPacket;
+
 #define FLAG_COMPRESSED	0x01
 #define FLAG_ENCODED	0x04
 
@@ -45,6 +49,10 @@
 #define RETRANSMIT_ACKED_PACKETS true
 #endif
 
+#ifndef MAX_SESSION_RETRIES
+#define MAX_SESSION_RETRIES 30
+#endif
+
 #pragma pack(1)
 struct SessionRequest {
 	uint32 UnknownA;
@@ -78,7 +86,6 @@ struct SessionStats {
 #pragma pack()
 
 class OpcodeManager;
-class EQStreamPair;
 class EQRawApplicationPacket;
 
 class EQStream : public EQStreamInterface {
@@ -101,6 +108,9 @@ class EQStream : public EQStreamInterface {
 		uint32 retransmittimer;
 		uint32 retransmittimeout;
 
+		uint16 sessionAttempts;
+		bool streamactive;
+
 		//uint32 buffer_len;
 
 		uint32 Session, Key;
@@ -194,10 +204,16 @@ class EQStream : public EQStreamInterface {
 
 		void _SendDisconnect();
 
-		void init();
+		void init(bool resetSession=true);
 	public:
-		EQStream() { init(); remote_ip = 0; remote_port = 0; State=UNESTABLISHED; StreamType=UnknownStream; compressed=true; encoded=false; app_opcode_size=2; bytes_sent=0; bytes_recv=0; create_time=Timer::GetTimeSeconds(); }
-		EQStream(sockaddr_in addr) { init(); remote_ip=addr.sin_addr.s_addr; remote_port=addr.sin_port; State=UNESTABLISHED; StreamType=UnknownStream; compressed=true; encoded=false; app_opcode_size=2; bytes_sent=0; bytes_recv=0; create_time=Timer::GetTimeSeconds(); }
+		EQStream() { init(); remote_ip = 0; remote_port = 0; State = UNESTABLISHED; 
+			StreamType = UnknownStream; compressed = true; encoded = false; app_opcode_size = 2; 
+			bytes_sent = 0; bytes_recv = 0; create_time = Timer::GetTimeSeconds(); sessionAttempts = 0; 
+			streamactive = false; }
+		EQStream(sockaddr_in addr) { init(); remote_ip = addr.sin_addr.s_addr; 
+			remote_port = addr.sin_port; State = UNESTABLISHED; StreamType = UnknownStream; 
+			compressed = true; encoded = false; app_opcode_size = 2; bytes_sent = 0; bytes_recv = 0; 
+			create_time = Timer::GetTimeSeconds(); }
 		virtual ~EQStream() { RemoveData(); SetState(CLOSED); }
 		void SetMaxLen(uint32 length) { MaxLen=length; }
 
@@ -221,6 +237,9 @@ class EQStream : public EQStreamInterface {
 		void SetLastPacketTime(uint32 t) {LastPacket=t;}
 		void Write(int eq_fd);
 
+		// whether or not the stream has been assigned (we passed our stream match)
+		void SetActive(bool val) { streamactive = val; }
+
 		//
 		inline bool IsInUse() { bool flag; MInUse.lock(); flag=(active_users>0); MInUse.unlock(); return flag; }
 		inline void PutInUse() { MInUse.lock(); active_users++; MInUse.unlock(); }

common/eq_stream_factory.cpp

@@ -1,5 +1,7 @@
-#include "debug.h"
-#include "EQStreamFactory.h"
+#include "global_define.h"
+#include "eqemu_logsys.h"
+#include "eq_stream_factory.h"
+
 #ifdef _WINDOWS
 	#include <winsock.h>
 	#include <process.h>
@@ -13,24 +15,25 @@
 	#include <netdb.h>
 	#include <pthread.h>
 #endif
-#include <fcntl.h>
+
 #include <iostream>
+#include <fcntl.h>
+
 #include "op_codes.h"
-#include "EQStream.h"
-#include "logsys.h"
 
 ThreadReturnType EQStreamFactoryReaderLoop(void *eqfs)
 {
-EQStreamFactory *fs=(EQStreamFactory *)eqfs;
+	_eqp
+	EQStreamFactory *fs = (EQStreamFactory*)eqfs;
 
 #ifndef WIN32
-	_log(COMMON__THREADS, "Starting EQStreamFactoryReaderLoop with thread ID %d", pthread_self());
+	Log.Out(Logs::Detail, Logs::None,  "Starting EQStreamFactoryReaderLoop with thread ID %d", pthread_self());
 #endif
 
 	fs->ReaderLoop();
 
 #ifndef WIN32
-	_log(COMMON__THREADS, "Ending EQStreamFactoryReaderLoop with thread ID %d", pthread_self());
+	Log.Out(Logs::Detail, Logs::None,  "Ending EQStreamFactoryReaderLoop with thread ID %d", pthread_self());
 #endif
 
 	THREAD_RETURN(nullptr);
@@ -38,16 +41,17 @@ EQStreamFactory *fs=(EQStreamFactory *)eqfs;
 
 ThreadReturnType EQStreamFactoryWriterLoop(void *eqfs)
 {
-	EQStreamFactory *fs=(EQStreamFactory *)eqfs;
+	_eqp
+	EQStreamFactory *fs = (EQStreamFactory*)eqfs;
 
 #ifndef WIN32
-	_log(COMMON__THREADS, "Starting EQStreamFactoryWriterLoop with thread ID %d", pthread_self());
+	Log.Out(Logs::Detail, Logs::None,  "Starting EQStreamFactoryWriterLoop with thread ID %d", pthread_self());
 #endif
 
 	fs->WriterLoop();
 
 #ifndef WIN32
-	_log(COMMON__THREADS, "Ending EQStreamFactoryWriterLoop with thread ID %d", pthread_self());
+	Log.Out(Logs::Detail, Logs::None,  "Ending EQStreamFactoryWriterLoop with thread ID %d", pthread_self());
 #endif
 
 	THREAD_RETURN(nullptr);
@@ -56,6 +60,7 @@ ThreadReturnType EQStreamFactoryWriterLoop(void *eqfs)
 EQStreamFactory::EQStreamFactory(EQStreamType type, int port, uint32 timeout)
 	: Timeoutable(5000), stream_timeout(timeout)
 {
+	_eqp
 	StreamType=type;
 	Port=port;
 	sock=-1;
@@ -63,6 +68,7 @@ EQStreamFactory::EQStreamFactory(EQStreamType type, int port, uint32 timeout)
 
 void EQStreamFactory::Close()
 {
+	_eqp
 	Stop();
 
 #ifdef _WINDOWS
@@ -75,7 +81,8 @@ void EQStreamFactory::Close()
 
 bool EQStreamFactory::Open()
 {
-struct sockaddr_in address;
+	_eqp
+	struct sockaddr_in address;
 #ifndef WIN32
 	pthread_t t1,t2;
 #endif
@@ -104,8 +111,6 @@ struct sockaddr_in address;
 		fcntl(sock, F_SETFL, O_NONBLOCK);
 	#endif
 	//moved these because on windows the output was delayed and causing the console window to look bad
-	//std::cout << "Starting factory Reader" << std::endl;
-	//std::cout << "Starting factory Writer" << std::endl;
 	#ifdef _WINDOWS
 		_beginthread(EQStreamFactoryReaderLoop,0, this);
 		_beginthread(EQStreamFactoryWriterLoop,0, this);
@@ -116,44 +121,42 @@ struct sockaddr_in address;
 	return true;
 }
 
-EQStream *EQStreamFactory::Pop()
+std::shared_ptr<EQStream> EQStreamFactory::Pop()
 {
-EQStream *s=nullptr;
-	//std::cout << "Pop():Locking MNewStreams" << std::endl;
+	_eqp
+	std::shared_ptr<EQStream> s = nullptr;
 	MNewStreams.lock();
 	if (NewStreams.size()) {
-		s=NewStreams.front();
+		s = NewStreams.front();
 		NewStreams.pop();
 		s->PutInUse();
 	}
 	MNewStreams.unlock();
-	//std::cout << "Pop(): Unlocking MNewStreams" << std::endl;
 
 	return s;
 }
 
-void EQStreamFactory::Push(EQStream *s)
+void EQStreamFactory::Push(std::shared_ptr<EQStream> s)
 {
-	//std::cout << "Push():Locking MNewStreams" << std::endl;
+	_eqp
 	MNewStreams.lock();
 	NewStreams.push(s);
 	MNewStreams.unlock();
-	//std::cout << "Push(): Unlocking MNewStreams" << std::endl;
 }
 
 void EQStreamFactory::ReaderLoop()
 {
-fd_set readset;
-std::map<std::pair<uint32, uint16>,EQStream *>::iterator stream_itr;
-int num;
-int length;
-unsigned char buffer[2048];
-sockaddr_in from;
-int socklen=sizeof(sockaddr_in);
-timeval sleep_time;
-//time_t now;
+	_eqp
+	fd_set readset;
+	std::map<std::pair<uint32, uint16>, std::shared_ptr<EQStream>>::iterator stream_itr;
+	int num;
+	int length;
+	unsigned char buffer[2048];
+	sockaddr_in from;
+	int socklen = sizeof(sockaddr_in);
+	timeval sleep_time;
+	ReaderRunning = true;
 
-	ReaderRunning=true;
 	while(sock!=-1) {
 		MReaderRunning.lock();
 		if (!ReaderRunning)
@@ -184,10 +187,10 @@ timeval sleep_time;
 				// What do we wanna do?
 			} else {
 				MStreams.lock();
-				stream_itr=Streams.find(std::make_pair(from.sin_addr.s_addr, from.sin_port));
+				stream_itr = Streams.find(std::make_pair(from.sin_addr.s_addr, from.sin_port));
 				if (stream_itr == Streams.end()) {
 					if (buffer[1]==OP_SessionRequest) {
-						EQStream *s = new EQStream(from);
+						std::shared_ptr<EQStream> s = std::make_shared<EQStream>(from);
 						s->SetStreamType(StreamType);
 						Streams[std::make_pair(from.sin_addr.s_addr, from.sin_port)]=s;
 						WriterWork.Signal();
@@ -198,13 +201,13 @@ timeval sleep_time;
 					}
 					MStreams.unlock();
 				} else {
-					EQStream *curstream = stream_itr->second;
+					std::shared_ptr<EQStream> curstream = stream_itr->second;
 					//dont bother processing incoming packets for closed connections
 					if(curstream->CheckClosed())
 						curstream = nullptr;
 					else
 						curstream->PutInUse();
-					MStreams.unlock();	//the in use flag prevents the stream from being deleted while we are using it.
+						//the in use flag prevents the stream from being deleted while we are using it.
 
 					if(curstream) {
 						curstream->AddBytesRecv(length);
@@ -212,6 +215,7 @@ timeval sleep_time;
 						curstream->SetLastPacketTime(Timer::GetCurrentTime());
 						curstream->ReleaseFromUse();
 					}
+					MStreams.unlock();
 				}
 			}
 		}
@@ -220,14 +224,15 @@ timeval sleep_time;
 
 void EQStreamFactory::CheckTimeout()
 {
+	_eqp
 	//lock streams the entire time were checking timeouts, it should be fast.
 	MStreams.lock();
 
 	unsigned long now=Timer::GetCurrentTime();
-	std::map<std::pair<uint32, uint16>,EQStream *>::iterator stream_itr;
+	std::map<std::pair<uint32, uint16>, std::shared_ptr<EQStream>>::iterator stream_itr;
 
-	for(stream_itr=Streams.begin();stream_itr!=Streams.end();) {
-		EQStream *s = stream_itr->second;
+	for(stream_itr = Streams.begin(); stream_itr != Streams.end();) {
+		std::shared_ptr<EQStream> s = stream_itr->second;
 
 		s->CheckTimeout(now, stream_timeout);
 
@@ -239,11 +244,9 @@ void EQStreamFactory::CheckTimeout()
 				//give it a little time for everybody to finish with it
 			} else {
 				//everybody is done, we can delete it now
-				//std::cout << "Removing connection" << std::endl;
-				std::map<std::pair<uint32, uint16>,EQStream *>::iterator temp=stream_itr;
+				std::map<std::pair<uint32, uint16>, std::shared_ptr<EQStream>>::iterator temp = stream_itr;
 				++stream_itr;
-				//let whoever has the stream outside delete it
-				delete temp->second;
+				temp->second = nullptr;
 				Streams.erase(temp);
 				continue;
 			}
@@ -256,21 +259,18 @@ void EQStreamFactory::CheckTimeout()
 
 void EQStreamFactory::WriterLoop()
 {
-std::map<std::pair<uint32, uint16>,EQStream *>::iterator stream_itr;
-bool havework=true;
-std::vector<EQStream *> wants_write;
-std::vector<EQStream *>::iterator cur,end;
-bool decay=false;
-uint32 stream_count;
-
-Timer DecayTimer(20);
-
-	WriterRunning=true;
+	_eqp
+	std::map<std::pair<uint32, uint16>, std::shared_ptr<EQStream>>::iterator stream_itr;
+	bool havework=true;
+	std::vector<std::shared_ptr<EQStream>> wants_write;
+	std::vector<std::shared_ptr<EQStream>>::iterator cur, end;
+	bool decay = false;
+	uint32 stream_count;
+	Timer DecayTimer(20);
+	WriterRunning = true;
 	DecayTimer.Enable();
+
 	while(sock!=-1) {
-		//if (!havework) {
-			//WriterWork.Wait();
-		//}
 		MWriterRunning.lock();
 		if (!WriterRunning)
 			break;
@@ -291,7 +291,7 @@ Timer DecayTimer(20);
 
 			//bullshit checking, to see if this is really happening, GDB seems to think so...
 			if(stream_itr->second == nullptr) {
-				fprintf(stderr, "ERROR: nullptr Stream encountered in EQStreamFactory::WriterLoop for: %i", stream_itr->first.first, stream_itr->first.second);
+				fprintf(stderr, "ERROR: nullptr Stream encountered in EQStreamFactory::WriterLoop for: %i:%i", stream_itr->first.first, stream_itr->first.second);
 				continue;
 			}
 
@@ -314,12 +314,10 @@ Timer DecayTimer(20);
 		Sleep(10);
 
 		MStreams.lock();
-		stream_count=Streams.size();
+		stream_count = Streams.size();
 		MStreams.unlock();
 		if (!stream_count) {
-			//std::cout << "No streams, waiting on condition" << std::endl;
 			WriterWork.Wait();
-			//std::cout << "Awake from condition, must have a stream now" << std::endl;
 		}
 	}
 }

common/eq_stream_factory.h

@@ -2,13 +2,16 @@
 
 #define _EQSTREAMFACTORY_H
 
+#include <memory>
 #include <queue>
 #include <map>
-#include "../common/EQStream.h"
-#include "../common/Condition.h"
+
+#include "../common/eq_stream.h"
+#include "../common/condition.h"
 #include "../common/timeoutmgr.h"
-#include "../common/opcodemgr.h"
-#include "../common/timer.h"
+
+class EQStream;
+class Timer;
 
 class EQStreamFactory : private Timeoutable {
 	private:
@@ -24,10 +27,10 @@ class EQStreamFactory : private Timeoutable {
 
 		EQStreamType StreamType;
 
-		std::queue<EQStream *> NewStreams;
+		std::queue<std::shared_ptr<EQStream>> NewStreams;
 		Mutex MNewStreams;
 
-		std::map<std::pair<uint32, uint16>,EQStream *> Streams;
+		std::map<std::pair<uint32, uint16>, std::shared_ptr<EQStream>> Streams;
 		Mutex MStreams;
 
 		virtual void CheckTimeout();
@@ -40,8 +43,8 @@ class EQStreamFactory : private Timeoutable {
 		EQStreamFactory(EQStreamType type, uint32 timeout = 135000) : Timeoutable(5000), stream_timeout(timeout) { ReaderRunning=false; WriterRunning=false; StreamType=type; sock=-1; }
 		EQStreamFactory(EQStreamType type, int port, uint32 timeout = 135000);
 
-		EQStream *Pop();
-		void Push(EQStream *s);
+		std::shared_ptr<EQStream> Pop();
+		void Push(std::shared_ptr<EQStream> s);
 
 		bool Open();
 		bool Open(unsigned long port) { Port=port; return Open(); }

common/eq_stream_ident.cpp

@@ -1,20 +1,20 @@
-#include "debug.h"
-#include "EQStreamIdent.h"
-#include "EQStreamProxy.h"
-#include "logsys.h"
+#include "global_define.h"
+#include "eqemu_logsys.h"
+#include "eq_stream_ident.h"
+#include "eq_stream_proxy.h"
+
 
 EQStreamIdentifier::~EQStreamIdentifier() {
 	while(!m_identified.empty()) {
 		m_identified.front()->ReleaseFromUse();
 		m_identified.pop();
 	}
-	std::vector<Record *>::iterator cur, end;
+	std::vector<Record>::iterator cur, end;
 	cur = m_streams.begin();
 	end = m_streams.end();
 	for(; cur != end; ++cur) {
-		Record *r = *cur;
-		r->stream->ReleaseFromUse();
-		delete r;
+		Record &r = *cur;
+		r.stream->ReleaseFromUse();
 	}
 	std::vector<Patch *>::iterator curp, endp;
 	curp = m_patches.begin();
@@ -34,54 +34,52 @@ void EQStreamIdentifier::RegisterPatch(const EQStream::Signature &sig, const cha
 }
 
 void EQStreamIdentifier::Process() {
-	std::vector<Record *>::iterator cur;
+	std::vector<Record>::iterator cur;
 	std::vector<Patch *>::iterator curp, endp;
 
 	//foreach pending stream.
 	cur = m_streams.begin();
 	while(cur != m_streams.end()) {
-		Record *r = *cur;
+		Record &r = *cur;
 
 		//first see if this stream has expired
-		if(r->expire.Check(false)) {
+		if(r.expire.Check(false)) {
 			//this stream has failed to match any pattern in our timeframe.
-			_log(NET__IDENTIFY, "Unable to identify stream from %s:%d before timeout.", long2ip(r->stream->GetRemoteIP()).c_str(), ntohs(r->stream->GetRemotePort()));
-			r->stream->ReleaseFromUse();
-			delete r;
+			Log.Out(Logs::General, Logs::Netcode, "[IDENTIFY] Unable to identify stream from %s:%d before timeout.", long2ip(r.stream->GetRemoteIP()).c_str(), ntohs(r.stream->GetRemotePort()));
+			r.stream->ReleaseFromUse();
 			cur = m_streams.erase(cur);
 			continue;
 		}
 
 		//then make sure the stream is still active
 		//if stream hasn't finished initializing then continue;
-		if(r->stream->GetState() == UNESTABLISHED)
+		if(r.stream->GetState() == UNESTABLISHED)
 		{
 			++cur;
 			continue;
 		}
-		if(r->stream->GetState() != ESTABLISHED) {
+		if(r.stream->GetState() != ESTABLISHED) {
 			//the stream closed before it was identified.
-			_log(NET__IDENTIFY, "Unable to identify stream from %s:%d before it closed.", long2ip(r->stream->GetRemoteIP()).c_str(), ntohs(r->stream->GetRemotePort()));
-			switch(r->stream->GetState())
+			Log.Out(Logs::General, Logs::Netcode, "[IDENTIFY] Unable to identify stream from %s:%d before it closed.", long2ip(r.stream->GetRemoteIP()).c_str(), ntohs(r.stream->GetRemotePort()));
+			switch(r.stream->GetState())
 			{
 			case ESTABLISHED:
-				_log(NET__IDENTIFY, "Stream state was Established");
+				Log.Out(Logs::General, Logs::Netcode, "[IDENTIFY] Stream state was Established");
 				break;
 			case CLOSING:
-				_log(NET__IDENTIFY, "Stream state was Closing");
+				Log.Out(Logs::General, Logs::Netcode, "[IDENTIFY] Stream state was Closing");
 				break;
 			case DISCONNECTING:
-				_log(NET__IDENTIFY, "Stream state was Disconnecting");
+				Log.Out(Logs::General, Logs::Netcode, "[IDENTIFY] Stream state was Disconnecting");
 				break;
 			case CLOSED:
-				_log(NET__IDENTIFY, "Stream state was Closed");
+				Log.Out(Logs::General, Logs::Netcode, "[IDENTIFY] Stream state was Closed");
 				break;
 			default:
-				_log(NET__IDENTIFY, "Stream state was Unestablished or unknown");
+				Log.Out(Logs::General, Logs::Netcode, "[IDENTIFY] Stream state was Unestablished or unknown");
 				break;
 			}
-			r->stream->ReleaseFromUse();
-			delete r;
+			r.stream->ReleaseFromUse();
 			cur = m_streams.erase(cur);
 			continue;
 		}
@@ -98,20 +96,23 @@ void EQStreamIdentifier::Process() {
 			Patch *p = *curp;
 
 			//ask the stream to see if it matches the supplied signature
-			EQStream::MatchState res = r->stream->CheckSignature(&p->signature);
+			EQStream::MatchState res = r.stream->CheckSignature(&p->signature);
 			switch(res) {
 			case EQStream::MatchNotReady:
 				//the stream has not received enough packets to compare with this signature
-//				_log(NET__IDENT_TRACE, "%s:%d: Tried patch %s, but stream is not ready for it.", long2ip(r->stream->GetRemoteIP()).c_str(), ntohs(r->stream->GetRemotePort()), p->name.c_str());
+//				Log.LogDebugType(Logs::General, Logs::Netcode, "[IDENT_TRACE] %s:%d: Tried patch %s, but stream is not ready for it.", long2ip(r.stream->GetRemoteIP()).c_str(), ntohs(r.stream->GetRemotePort()), p->name.c_str());
 				all_ready = false;
 				break;
 			case EQStream::MatchSuccessful: {
 				//yay, a match.
 
-				_log(NET__IDENTIFY, "Identified stream %s:%d with signature %s", long2ip(r->stream->GetRemoteIP()).c_str(), ntohs(r->stream->GetRemotePort()), p->name.c_str());
+				Log.Out(Logs::General, Logs::Netcode, "[IDENTIFY] Identified stream %s:%d with signature %s", long2ip(r.stream->GetRemoteIP()).c_str(), ntohs(r.stream->GetRemotePort()), p->name.c_str());
+
+				// before we assign the eqstream to an interface, let the stream recognize it is in use and the session should not be reset any further
+				r.stream->SetActive(true);
 
 				//might want to do something less-specific here... some day..
-				EQStreamInterface *s = new EQStreamProxy(r->stream, p->structs, p->opcodes);
+				EQStreamInterface *s = new EQStreamProxy(r.stream, p->structs, p->opcodes);
 				m_identified.push(s);
 
 				found_one = true;
@@ -119,7 +120,7 @@ void EQStreamIdentifier::Process() {
 			}
 			case EQStream::MatchFailed:
 				//do nothing...
-				_log(NET__IDENT_TRACE, "%s:%d: Tried patch %s, and it did not match.", long2ip(r->stream->GetRemoteIP()).c_str(), ntohs(r->stream->GetRemotePort()), p->name.c_str());
+				Log.Out(Logs::General, Logs::Netcode, "[IDENT_TRACE] %s:%d: Tried patch %s, and it did not match.", long2ip(r.stream->GetRemoteIP()).c_str(), ntohs(r.stream->GetRemotePort()), p->name.c_str());
 				break;
 			}
 		}
@@ -127,14 +128,13 @@ void EQStreamIdentifier::Process() {
 		//if we checked all patches and did not find a match.
 		if(all_ready && !found_one) {
 			//the stream cannot be identified.
-			_log(NET__IDENTIFY, "Unable to identify stream from %s:%d, no match found.", long2ip(r->stream->GetRemoteIP()).c_str(), ntohs(r->stream->GetRemotePort()));
-			r->stream->ReleaseFromUse();
+			Log.Out(Logs::General, Logs::Netcode, "[IDENTIFY] Unable to identify stream from %s:%d, no match found.", long2ip(r.stream->GetRemoteIP()).c_str(), ntohs(r.stream->GetRemotePort()));
+			r.stream->ReleaseFromUse();
 		}
 
 		//if we found a match, or were not able to identify it
 		if(found_one || all_ready) {
-			//cannot print ip/port here. r->stream is invalid.
-			delete r;
+			//cannot print ip/port here. r.stream is invalid.
 			cur = m_streams.erase(cur);
 		} else {
 			++cur;
@@ -142,8 +142,8 @@ void EQStreamIdentifier::Process() {
 	}	//end foreach stream
 }
 
-void EQStreamIdentifier::AddStream(EQStream *&eqs) {
-	m_streams.push_back(new Record(eqs));
+void EQStreamIdentifier::AddStream(std::shared_ptr<EQStream> &eqs) {
+	m_streams.push_back(Record(eqs));
 	eqs = nullptr;
 }
 
@@ -155,7 +155,7 @@ EQStreamInterface *EQStreamIdentifier::PopIdentified() {
 	return(res);
 }
 
-EQStreamIdentifier::Record::Record(EQStream *s)
+EQStreamIdentifier::Record::Record(std::shared_ptr<EQStream> s)
 :	stream(s),
 	expire(STREAM_IDENT_WAIT_MS)
 {

common/eq_stream_ident.h

@@ -1,16 +1,17 @@
 #ifndef EQSTREAMIDENT_H_
 #define EQSTREAMIDENT_H_
 
-#include "EQStream.h"
+#include "eq_stream.h"
 #include "timer.h"
 #include <vector>
-#include <string>
 #include <queue>
+#include <memory>
 
 #define STREAM_IDENT_WAIT_MS 10000
 
 class OpcodeManager;
 class StructStrategy;
+class EQStreamInterface;
 
 class EQStreamIdentifier {
 public:
@@ -21,7 +22,7 @@ public:
 
 	//main processing interface
 	void Process();
-	void AddStream(EQStream *& eqs);
+	void AddStream(std::shared_ptr<EQStream> &eqs);
 	EQStreamInterface *PopIdentified();
 
 protected:
@@ -39,11 +40,11 @@ protected:
 	//pending streams..
 	class Record {
 	public:
-		Record(EQStream *s);
-		EQStream *stream;		//we own this
+		Record(std::shared_ptr<EQStream> s);
+		std::shared_ptr<EQStream> stream;		//we own this
 		Timer expire;
 	};
-	std::vector<Record *> m_streams;	//we own these objects, and the streams contained in them.
+	std::vector<Record> m_streams;	//we own these objects, and the streams contained in them.
 	std::queue<EQStreamInterface *> m_identified;	//we own these objects
 };
 

common/eq_stream_intf.h

@@ -35,7 +35,7 @@ public:
 	virtual const uint32 GetBytesRecieved() const { return 0; }
 	virtual const uint32 GetBytesSentPerSecond() const { return 0; }
 	virtual const uint32 GetBytesRecvPerSecond() const { return 0; }
-	virtual const EQClientVersion ClientVersion() const { return EQClientUnknown; }
+	virtual const ClientVersion GetClientVersion() const { return ClientVersion::Unknown; }
 };
 
 #endif /*EQSTREAMINTF_H_*/

common/eq_stream_proxy.cpp

@@ -1,11 +1,11 @@
 
-#include "debug.h"
-#include "EQStreamProxy.h"
-#include "EQStream.h"
-#include "StructStrategy.h"
+#include "global_define.h"
+#include "eq_stream_proxy.h"
+#include "eq_stream.h"
+#include "struct_strategy.h"
 
 
-EQStreamProxy::EQStreamProxy(EQStream *&stream, const StructStrategy *structs, OpcodeManager **opcodes)
+EQStreamProxy::EQStreamProxy(std::shared_ptr<EQStream> &stream, const StructStrategy *structs, OpcodeManager **opcodes)
 :	m_stream(stream),
 	m_structs(structs),
 	m_opcodes(opcodes)
@@ -15,16 +15,15 @@ EQStreamProxy::EQStreamProxy(EQStream *&stream, const StructStrategy *structs, O
 }
 
 EQStreamProxy::~EQStreamProxy() {
-	//delete m_stream;	//released by the stream factory.
 }
 
 std::string EQStreamProxy::Describe() const {
 	return(m_structs->Describe());
 }
 
-const EQClientVersion EQStreamProxy::ClientVersion() const
+const ClientVersion EQStreamProxy::GetClientVersion() const
 {
-	return m_structs->ClientVersion();
+	return m_structs->GetClientVersion();
 }
 
 void EQStreamProxy::QueuePacket(const EQApplicationPacket *p, bool ack_req) {
@@ -85,12 +84,6 @@ const uint32 EQStreamProxy::GetBytesRecvPerSecond() const
 
 void EQStreamProxy::ReleaseFromUse() {
 	m_stream->ReleaseFromUse();
-
-	//this is so ugly, but I cant think of a better way to deal with
-	//it right now...
-	if(!m_stream->IsInUse()) {
-		delete this;
-	}
 }
 
 void EQStreamProxy::RemoveData() {

common/eq_stream_proxy.h

@@ -3,9 +3,10 @@
 
 
 #include "types.h"
-#include "EQStreamIntf.h"
+#include "eq_stream_intf.h"
+#include "eq_stream.h"
+#include <memory>
 
-class EQStream;
 class StructStrategy;
 class OpcodeManager;
 class EQApplicationPacket;
@@ -13,7 +14,7 @@ class EQApplicationPacket;
 class EQStreamProxy : public EQStreamInterface {
 public:
 	//takes ownership of the stream.
-	EQStreamProxy(EQStream *&stream, const StructStrategy *structs, OpcodeManager **opcodes);
+	EQStreamProxy(std::shared_ptr<EQStream> &stream, const StructStrategy *structs, OpcodeManager **opcodes);
 	virtual ~EQStreamProxy();
 
 	//EQStreamInterface:
@@ -27,7 +28,7 @@ public:
 	virtual void RemoveData();
 	virtual bool CheckState(EQStreamState state);
 	virtual std::string Describe() const;
-	virtual const EQClientVersion ClientVersion() const;
+	virtual const ClientVersion GetClientVersion() const;
 
 	virtual const uint32 GetBytesSent() const;
 	virtual const uint32 GetBytesRecieved() const;
@@ -35,7 +36,7 @@ public:
 	virtual const uint32 GetBytesRecvPerSecond() const;
 
 protected:
-	EQStream *const					m_stream;	//we own this stream object.
+	std::shared_ptr<EQStream> const					m_stream;	//we own this stream object.
 	const StructStrategy *const		m_structs;	//we do not own this object.
 	//this is a pointer to a pointer to make it less likely that a packet will
 	//reference an invalid opcode manager when they are being reloaded.

common/eqdb.cpp

@@ -15,8 +15,8 @@
 	along with this program; if not, write to the Free Software
 	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
-#include "debug.h"
-#include "EQDB.h"
+#include "global_define.h"
+#include "eqdb.h"
 #include "database.h"
 #include <mysql.h>
 #include <cstring>

common/eqdb.h

@@ -22,7 +22,7 @@
 #include <vector>
 #include <map>
 #include "types.h"
-#include "EQDBRes.h"
+#include "eqdb_res.h"
 #include <mysql.h>
 
 //this is the main object exported to perl.

common/eqdb_res.cpp

@@ -15,8 +15,8 @@
 	along with this program; if not, write to the Free Software
 	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
-#include "debug.h"
-#include "EQDBRes.h"
+#include "global_define.h"
+#include "eqdb_res.h"
 #include <mysql.h>
 
 std::vector<std::string> EQDBRes::fetch_row_array() {

common/eqemu_config.cpp

@@ -0,0 +1,498 @@
+/*	 EQEMu: Everquest Server Emulator
+	Copyright (C) 2001-2006 EQEMu Development Team (http://eqemulator.net)
+
+	This program 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; version 2 of the License.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY except by those people which sell it, which
+	are required to give you total support for your newly bought product;
+	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 this program; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+*/
+
+#include "../common/global_define.h"
+#include "eqemu_config.h"
+#include "misc_functions.h"
+
+#include <iostream>
+#include <sstream>
+
+std::string EQEmuConfig::ConfigFile = "eqemu_config.xml";
+EQEmuConfig *EQEmuConfig::_config = nullptr;
+
+void EQEmuConfig::do_world(TiXmlElement *ele)
+{
+	_eqp
+	const char *text;
+	TiXmlElement * sub_ele;;
+	text = ParseTextBlock(ele, "shortname");
+	if (text) {
+		ShortName = text;
+	}
+	text = ParseTextBlock(ele, "longname");
+	if (text) {
+		LongName = text;
+	}
+	text = ParseTextBlock(ele, "address", true);
+	if (text) {
+		WorldAddress = text;
+	}
+	text = ParseTextBlock(ele, "localaddress", true);
+	if (text) {
+		LocalAddress = text;
+	}
+	text = ParseTextBlock(ele, "maxclients", true);
+	if (text) {
+		MaxClients = atoi(text);
+	}
+	// Get the <key> element
+	text = ParseTextBlock(ele, "key", true);
+	if (text) {
+		SharedKey = text;
+	}
+	// Get the <loginserver> element
+	sub_ele = ele->FirstChildElement("loginserver");
+	if (sub_ele) {
+		text = ParseTextBlock(sub_ele, "host", true);
+		if (text) {
+			LoginHost = text;
+		}
+		text = ParseTextBlock(sub_ele, "port", true);
+		if (text) {
+			LoginPort = atoi(text);
+		}
+		text = ParseTextBlock(sub_ele, "account", true);
+		if (text) {
+			LoginAccount = text;
+		}
+		text = ParseTextBlock(sub_ele, "password", true);
+		if (text) {
+			LoginPassword = text;
+		}
+	} else {
+		char	str[32];
+		do {
+			sprintf(str, "loginserver%i", ++LoginCount);
+			sub_ele = ele->FirstChildElement(str);
+			if (sub_ele) {
+				LoginConfig* loginconfig = new LoginConfig;
+				text = ParseTextBlock(sub_ele, "host", true);
+				if (text) {
+					loginconfig->LoginHost = text;
+				}
+				text = ParseTextBlock(sub_ele, "port", true);
+				if (text) {
+					loginconfig->LoginPort = atoi(text);
+				}
+				text = ParseTextBlock(sub_ele, "account", true);
+				if (text) {
+					loginconfig->LoginAccount = text;
+				}
+				text = ParseTextBlock(sub_ele, "password", true);
+				if (text) {
+					loginconfig->LoginPassword = text;
+				}
+				loginlist.Insert(loginconfig);
+			}
+		} while (sub_ele);
+	}
+	// Check for locked
+	sub_ele = ele->FirstChildElement("locked");
+	if (sub_ele != nullptr) {
+		Locked = true;
+	}
+	// Get the <tcp> element
+	sub_ele = ele->FirstChildElement("tcp");
+	if (sub_ele != nullptr) {
+		text = sub_ele->Attribute("ip");
+		if (text) {
+			WorldIP = text;
+		}
+		text = sub_ele->Attribute("port");
+		if (text) {
+			WorldTCPPort = atoi(text);
+		}
+		text = sub_ele->Attribute("telnet");
+		if (text && !strcasecmp(text, "enabled")) {
+			TelnetEnabled = true;
+		}
+	}
+	// Get the <http> element
+	sub_ele = ele->FirstChildElement("http");
+	if (sub_ele != nullptr) {
+//		text = sub_ele->Attribute("ip");
+//		if (text)
+//			WorldIP=text;
+		text = sub_ele->Attribute("mimefile");
+		if (text) {
+			WorldHTTPMimeFile = text;
+		}
+		text = sub_ele->Attribute("port");
+		if (text) {
+			WorldHTTPPort = atoi(text);
+		}
+		text = sub_ele->Attribute("enabled");
+		if (text && !strcasecmp(text, "true")) {
+			WorldHTTPEnabled = true;
+		}
+	}
+}
+
+void EQEmuConfig::do_chatserver(TiXmlElement *ele)
+{
+	_eqp
+	const char *text;
+	text = ParseTextBlock(ele, "host", true);
+	if (text) {
+		ChatHost = text;
+	}
+	text = ParseTextBlock(ele, "port", true);
+	if (text) {
+		ChatPort = atoi(text);
+	}
+}
+
+void EQEmuConfig::do_mailserver(TiXmlElement *ele)
+{
+	_eqp
+	const char *text;
+	text = ParseTextBlock(ele, "host", true);
+	if (text) {
+		MailHost = text;
+	}
+	text = ParseTextBlock(ele, "port", true);
+	if (text) {
+		MailPort = atoi(text);
+	}
+}
+
+void EQEmuConfig::do_database(TiXmlElement *ele)
+{
+	_eqp
+	const char *text;
+	text = ParseTextBlock(ele, "host", true);
+	if (text) {
+		DatabaseHost = text;
+	}
+	text = ParseTextBlock(ele, "port", true);
+	if (text) {
+		DatabasePort = atoi(text);
+	}
+	text = ParseTextBlock(ele, "username", true);
+	if (text) {
+		DatabaseUsername = text;
+	}
+	text = ParseTextBlock(ele, "password", true);
+	if (text) {
+		DatabasePassword = text;
+	}
+	text = ParseTextBlock(ele, "db", true);
+	if (text) {
+		DatabaseDB = text;
+	}
+}
+
+
+void EQEmuConfig::do_qsdatabase(TiXmlElement *ele)
+{
+	_eqp
+	const char *text;
+	text = ParseTextBlock(ele, "host", true);
+	if (text) {
+		QSDatabaseHost = text;
+	}
+	text = ParseTextBlock(ele, "port", true);
+	if (text) {
+		QSDatabasePort = atoi(text);
+	}
+	text = ParseTextBlock(ele, "username", true);
+	if (text) {
+		QSDatabaseUsername = text;
+	}
+	text = ParseTextBlock(ele, "password", true);
+	if (text) {
+		QSDatabasePassword = text;
+	}
+	text = ParseTextBlock(ele, "db", true);
+	if (text) {
+		QSDatabaseDB = text;
+	}
+}
+
+void EQEmuConfig::do_zones(TiXmlElement *ele)
+{
+	_eqp
+	const char *text;
+	TiXmlElement *sub_ele;
+//	TiXmlNode *node,*sub_node;
+	text = ParseTextBlock(ele, "defaultstatus", true);
+	if (text) {
+		DefaultStatus = atoi(text);
+	}
+	// Get the <ports> element
+	sub_ele = ele->FirstChildElement("ports");
+	if (sub_ele != nullptr) {
+		text = sub_ele->Attribute("low");
+		if (text) {
+			ZonePortLow = atoi(text);
+		};
+		text = sub_ele->Attribute("high");
+		if (text) {
+			ZonePortHigh = atoi(text);
+		}
+	}
+}
+
+void EQEmuConfig::do_files(TiXmlElement *ele)
+{
+	_eqp
+	const char *text;
+	text = ParseTextBlock(ele, "spells", true);
+	if (text) {
+		SpellsFile = text;
+	}
+	text = ParseTextBlock(ele, "opcodes", true);
+	if (text) {
+		OpCodesFile = text;
+	}
+	text = ParseTextBlock(ele, "eqtime", true);
+	if (text) {
+		EQTimeFile = text;
+	}
+}
+
+void EQEmuConfig::do_directories(TiXmlElement *ele)
+{
+	_eqp
+	const char *text;
+	text = ParseTextBlock(ele, "maps", true);
+	if (text) {
+		MapDir = text;
+	}
+	text = ParseTextBlock(ele, "quests", true);
+	if (text) {
+		QuestDir = text;
+	}
+	text = ParseTextBlock(ele, "plugins", true);
+	if (text) {
+		PluginDir = text;
+	}
+}
+
+void EQEmuConfig::do_launcher(TiXmlElement *ele)
+{
+	_eqp
+	const char *text;
+	TiXmlElement *sub_ele;
+	text = ParseTextBlock(ele, "logprefix", true);
+	if (text) {
+		LogPrefix = text;
+	}
+	text = ParseTextBlock(ele, "logsuffix", true);
+	if (text) {
+		LogSuffix = text;
+	}
+	// Get the <exe> element
+	text = ParseTextBlock(ele, "exe", true);
+	if (text) {
+		ZoneExe = text;
+	}
+	// Get the <timers> element
+	sub_ele = ele->FirstChildElement("timers");
+	if (sub_ele != nullptr) {
+		text = sub_ele->Attribute("restart");
+		if (text) {
+			RestartWait = atoi(text);
+		}
+		text = sub_ele->Attribute("reterminate");
+		if (text) {
+			TerminateWait = atoi(text);
+		}
+		text = sub_ele->Attribute("initial");
+		if (text) {
+			InitialBootWait = atoi(text);
+		}
+		text = sub_ele->Attribute("interval");
+		if (text) {
+			ZoneBootInterval = atoi(text);
+		}
+	}
+}
+
+std::string EQEmuConfig::GetByName(const std::string &var_name) const
+{
+	_eqp
+	if (var_name == "ShortName") {
+		return (ShortName);
+	}
+	if (var_name == "LongName") {
+		return (LongName);
+	}
+	if (var_name == "WorldAddress") {
+		return (WorldAddress);
+	}
+	if (var_name == "LoginHost") {
+		return (LoginHost);
+	}
+	if (var_name == "LoginAccount") {
+		return (LoginAccount);
+	}
+	if (var_name == "LoginPassword") {
+		return (LoginPassword);
+	}
+	if (var_name == "LoginPort") {
+		return (itoa(LoginPort));
+	}
+	if (var_name == "Locked") {
+		return (Locked ? "true" : "false");
+	}
+	if (var_name == "WorldTCPPort") {
+		return (itoa(WorldTCPPort));
+	}
+	if (var_name == "WorldIP") {
+		return (WorldIP);
+	}
+	if (var_name == "TelnetEnabled") {
+		return (TelnetEnabled ? "true" : "false");
+	}
+	if (var_name == "WorldHTTPPort") {
+		return (itoa(WorldHTTPPort));
+	}
+	if (var_name == "WorldHTTPMimeFile") {
+		return (WorldHTTPMimeFile);
+	}
+	if (var_name == "WorldHTTPEnabled") {
+		return (WorldHTTPEnabled ? "true" : "false");
+	}
+	if (var_name == "ChatHost") {
+		return (ChatHost);
+	}
+	if (var_name == "ChatPort") {
+		return (itoa(ChatPort));
+	}
+	if (var_name == "MailHost") {
+		return (MailHost);
+	}
+	if (var_name == "MailPort") {
+		return (itoa(MailPort));
+	}
+	if (var_name == "DatabaseHost") {
+		return (DatabaseHost);
+	}
+	if (var_name == "DatabaseUsername") {
+		return (DatabaseUsername);
+	}
+	if (var_name == "DatabasePassword") {
+		return (DatabasePassword);
+	}
+	if (var_name == "DatabaseDB") {
+		return (DatabaseDB);
+	}
+	if (var_name == "DatabasePort") {
+		return (itoa(DatabasePort));
+	}
+	if (var_name == "QSDatabaseHost") {
+		return (QSDatabaseHost);
+	}
+	if (var_name == "QSDatabaseUsername") {
+		return (QSDatabaseUsername);
+	}
+	if (var_name == "QSDatabasePassword") {
+		return (QSDatabasePassword);
+	}
+	if (var_name == "QSDatabaseDB") {
+		return (QSDatabaseDB);
+	}
+	if (var_name == "QSDatabasePort") {
+		return (itoa(QSDatabasePort));
+	}
+	if (var_name == "SpellsFile") {
+		return (SpellsFile);
+	}
+	if (var_name == "OpCodesFile") {
+		return (OpCodesFile);
+	}
+	if (var_name == "EQTimeFile") {
+		return (EQTimeFile);
+	}
+	if (var_name == "MapDir") {
+		return (MapDir);
+	}
+	if (var_name == "QuestDir") {
+		return (QuestDir);
+	}
+	if (var_name == "PluginDir") {
+		return (PluginDir);
+	}
+	if (var_name == "LogPrefix") {
+		return (LogPrefix);
+	}
+	if (var_name == "LogSuffix") {
+		return (LogSuffix);
+	}
+	if (var_name == "ZoneExe") {
+		return (ZoneExe);
+	}
+	if (var_name == "ZonePortLow") {
+		return (itoa(ZonePortLow));
+	}
+	if (var_name == "ZonePortHigh") {
+		return (itoa(ZonePortHigh));
+	}
+	if (var_name == "DefaultStatus") {
+		return (itoa(DefaultStatus));
+	}
+//	if(var_name == "DynamicCount")
+//		return(itoa(DynamicCount));
+	return ("");
+}
+
+void EQEmuConfig::Dump() const
+{
+	_eqp
+	std::cout << "ShortName = " << ShortName << std::endl;
+	std::cout << "LongName = " << LongName << std::endl;
+	std::cout << "WorldAddress = " << WorldAddress << std::endl;
+	std::cout << "LoginHost = " << LoginHost << std::endl;
+	std::cout << "LoginAccount = " << LoginAccount << std::endl;
+	std::cout << "LoginPassword = " << LoginPassword << std::endl;
+	std::cout << "LoginPort = " << LoginPort << std::endl;
+	std::cout << "Locked = " << Locked << std::endl;
+	std::cout << "WorldTCPPort = " << WorldTCPPort << std::endl;
+	std::cout << "WorldIP = " << WorldIP << std::endl;
+	std::cout << "TelnetEnabled = " << TelnetEnabled << std::endl;
+	std::cout << "WorldHTTPPort = " << WorldHTTPPort << std::endl;
+	std::cout << "WorldHTTPMimeFile = " << WorldHTTPMimeFile << std::endl;
+	std::cout << "WorldHTTPEnabled = " << WorldHTTPEnabled << std::endl;
+	std::cout << "ChatHost = " << ChatHost << std::endl;
+	std::cout << "ChatPort = " << ChatPort << std::endl;
+	std::cout << "MailHost = " << MailHost << std::endl;
+	std::cout << "MailPort = " << MailPort << std::endl;
+	std::cout << "DatabaseHost = " << DatabaseHost << std::endl;
+	std::cout << "DatabaseUsername = " << DatabaseUsername << std::endl;
+	std::cout << "DatabasePassword = " << DatabasePassword << std::endl;
+	std::cout << "DatabaseDB = " << DatabaseDB << std::endl;
+	std::cout << "DatabasePort = " << DatabasePort << std::endl;
+	std::cout << "QSDatabaseHost = " << QSDatabaseHost << std::endl;
+	std::cout << "QSDatabaseUsername = " << QSDatabaseUsername << std::endl;
+	std::cout << "QSDatabasePassword = " << QSDatabasePassword << std::endl;
+	std::cout << "QSDatabaseDB = " << QSDatabaseDB << std::endl;
+	std::cout << "QSDatabasePort = " << QSDatabasePort << std::endl;
+	std::cout << "SpellsFile = " << SpellsFile << std::endl;
+	std::cout << "OpCodesFile = " << OpCodesFile << std::endl;
+	std::cout << "EQTimeFile = " << EQTimeFile << std::endl;
+	std::cout << "MapDir = " << MapDir << std::endl;
+	std::cout << "QuestDir = " << QuestDir << std::endl;
+	std::cout << "PluginDir = " << PluginDir << std::endl;
+	std::cout << "ZonePortLow = " << ZonePortLow << std::endl;
+	std::cout << "ZonePortHigh = " << ZonePortHigh << std::endl;
+	std::cout << "DefaultStatus = " << (int)DefaultStatus << std::endl;
+//	std::cout << "DynamicCount = " << DynamicCount << std::endl;
+}
+

common/eqemu_config.h

@@ -0,0 +1,217 @@
+/*	 EQEMu: Everquest Server Emulator
+	Copyright (C) 2001-2006 EQEMu Development Team (http://eqemulator.net)
+
+	This program 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; version 2 of the License.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY except by those people which sell it, which
+	are required to give you total support for your newly bought product;
+	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 this program; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+*/
+#ifndef __EQEmuConfig_H
+#define __EQEmuConfig_H
+
+#include "xml_parser.h"
+#include "linked_list.h"
+
+struct LoginConfig {
+	std::string LoginHost;
+	std::string LoginAccount;
+	std::string LoginPassword;
+	uint16 LoginPort;
+};
+
+class EQEmuConfig : public XMLParser
+{
+	public:
+		virtual std::string GetByName(const std::string &var_name) const;
+
+		// From <world/>
+		std::string ShortName;
+		std::string LongName;
+		std::string WorldAddress;
+		std::string LocalAddress;
+		std::string LoginHost;
+		std::string LoginAccount;
+		std::string LoginPassword;
+		uint16 LoginPort;
+		uint32 LoginCount;
+		LinkedList<LoginConfig*> loginlist;
+		bool Locked;
+		uint16 WorldTCPPort;
+		std::string WorldIP;
+		bool TelnetEnabled;
+		int32 MaxClients;
+		bool WorldHTTPEnabled;
+		uint16 WorldHTTPPort;
+		std::string WorldHTTPMimeFile;
+		std::string SharedKey;
+
+		// From <chatserver/>
+		std::string ChatHost;
+		uint16 ChatPort;
+
+		// From <mailserver/>
+		std::string MailHost;
+		uint16 MailPort;
+
+		// From <database/>
+		std::string DatabaseHost;
+		std::string DatabaseUsername;
+		std::string DatabasePassword;
+		std::string DatabaseDB;
+		uint16 DatabasePort;
+
+		// From <qsdatabase> // QueryServ
+		std::string QSDatabaseHost;
+		std::string QSDatabaseUsername;
+		std::string QSDatabasePassword;
+		std::string QSDatabaseDB;
+		uint16 QSDatabasePort;
+
+		// From <files/>
+		std::string SpellsFile;
+		std::string OpCodesFile;
+		std::string EQTimeFile;
+
+		// From <directories/>
+		std::string MapDir;
+		std::string QuestDir;
+		std::string PluginDir;
+
+		// From <launcher/>
+		std::string LogPrefix;
+		std::string LogSuffix;
+		std::string ZoneExe;
+		uint32 RestartWait;
+		uint32 TerminateWait;
+		uint32 InitialBootWait;
+		uint32 ZoneBootInterval;
+
+		// From <zones/>
+		uint16 ZonePortLow;
+		uint16 ZonePortHigh;
+		uint8 DefaultStatus;
+
+//	uint16 DynamicCount;
+
+//	map<string,uint16> StaticZones;
+
+	protected:
+
+		static EQEmuConfig *_config;
+
+		static std::string ConfigFile;
+
+#define ELEMENT(name) \
+	void do_##name(TiXmlElement *ele);
+#include "eqemu_config_elements.h"
+
+
+		EQEmuConfig()
+		{
+			// import the needed handler prototypes
+#define ELEMENT(name) \
+	Handlers[#name]=(ElementHandler)&EQEmuConfig::do_##name;
+#include "eqemu_config_elements.h"
+			// Set sane defaults
+			// Login server
+			LoginHost = "eqemulator.net";
+			LoginPort = 5998;
+			// World
+			Locked = false;
+			WorldTCPPort = 9000;
+			TelnetEnabled = false;
+			WorldHTTPEnabled = false;
+			WorldHTTPPort = 9080;
+			WorldHTTPMimeFile = "mime.types";
+			SharedKey = "";	//blank disables authentication
+			// Mail
+			ChatHost = "eqchat.eqemulator.net";
+			ChatPort = 7778;
+			// Mail
+			MailHost = "eqmail.eqemulator.net";
+			MailPort = 7779;
+			// Mysql
+			DatabaseHost = "localhost";
+			DatabasePort = 3306;
+			DatabaseUsername = "eq";
+			DatabasePassword = "eq";
+			DatabaseDB = "eq";
+			// QueryServ Database
+			QSDatabaseHost = "localhost";
+			QSDatabasePort = 3306;
+			QSDatabaseUsername = "eq";
+			QSDatabasePassword = "eq";
+			QSDatabaseDB = "eq";
+			// Files
+			SpellsFile = "spells_us.txt";
+			OpCodesFile = "opcodes.conf";
+			EQTimeFile = "eqtime.cfg";
+			// Dirs
+			MapDir = "Maps";
+			QuestDir = "quests";
+			PluginDir = "plugins";
+			// Launcher
+			LogPrefix = "logs/zone-";
+			LogSuffix = ".log";
+			RestartWait = 10000;		//milliseconds
+			TerminateWait = 10000;		//milliseconds
+			InitialBootWait = 20000;	//milliseconds
+			ZoneBootInterval = 2000;	//milliseconds
+			#ifdef WIN32
+			ZoneExe = "zone.exe";
+			#else
+			ZoneExe = "./zone";
+			#endif
+			// Zones
+			ZonePortLow = 7000;
+			ZonePortHigh = 7999;
+			DefaultStatus = 0;
+			// For where zones need to connect to.
+			WorldIP = "127.0.0.1";
+			// Dynamics to start
+			//DynamicCount=5;
+			MaxClients = -1;
+			LoginCount = 0;
+		}
+		virtual ~EQEmuConfig() {}
+
+	public:
+
+		// Produce a const singleton
+		static const EQEmuConfig *get()
+		{
+			if (_config == nullptr) {
+				LoadConfig();
+			}
+			return (_config);
+		}
+
+		// Allow the use to set the conf file to be used.
+		static void SetConfigFile(std::string file)
+		{
+			EQEmuConfig::ConfigFile = file;
+		}
+
+		// Load the config
+		static bool LoadConfig()
+		{
+			if (_config != nullptr) {
+				delete _config;
+			}
+			_config = new EQEmuConfig;
+			return _config->ParseFile(EQEmuConfig::ConfigFile.c_str(), "server");
+		}
+
+		void Dump() const;
+};
+
+#endif

common/eqemu_logsys.cpp

@@ -0,0 +1,353 @@
+/*	EQEMu: Everquest Server Emulator
+	Copyright (C) 2001-2015 EQEMu Development Team (http://eqemulator.net)
+
+	This program 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; version 2 of the License.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY except by those people which sell it, which
+	are required to give you total support for your newly bought product;
+	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 this program; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+*/
+
+
+#include "eqemu_logsys.h"
+#include "platform.h"
+#include "string_util.h"
+#include "database.h"
+#include "misc.h"
+
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <iomanip>
+#include <time.h>
+#include <sys/stat.h>
+
+std::ofstream process_log;
+
+#ifdef _WINDOWS
+	#include <direct.h>
+	#include <conio.h>
+	#include <iostream>
+	#include <dos.h>
+	#include <windows.h>
+	#include <process.h>
+#else
+	#include <unistd.h>
+	#include <sys/stat.h>
+#endif
+
+/* Linux ANSI console color defines */
+#define LC_RESET   "\033[0m"
+#define LC_BLACK   "\033[30m"      /* Black */
+#define LC_RED     "\033[31m"      /* Red */
+#define LC_GREEN   "\033[32m"      /* Green */
+#define LC_YELLOW  "\033[33m"      /* Yellow */
+#define LC_BLUE    "\033[34m"      /* Blue */
+#define LC_MAGENTA "\033[35m"      /* Magenta */
+#define LC_CYAN    "\033[36m"      /* Cyan */
+#define LC_WHITE   "\033[37m"      /* White */
+
+namespace Console {
+	enum Color {
+		Black = 0,
+		Blue = 1,
+		Green = 2,
+		Cyan = 3,
+		Red = 4,
+		Magenta = 5,
+		Brown = 6,
+		LightGray = 7,
+		DarkGray = 8,
+		LightBlue = 9,
+		LightGreen = 10,
+		LightCyan = 11,
+		LightRed = 12,
+		LightMagenta = 13,
+		Yellow = 14,
+		White = 15
+	};
+}
+
+EQEmuLogSys::EQEmuLogSys()
+{
+	on_log_gmsay_hook = [](uint16 log_type, const std::string&) {};
+	bool file_logs_enabled = false;
+	int log_platform = 0;
+}
+
+EQEmuLogSys::~EQEmuLogSys()
+{
+}
+
+void EQEmuLogSys::LoadLogSettingsDefaults()
+{
+	/* Get Executable platform currently running this code (Zone/World/etc) */
+	log_platform = GetExecutablePlatformInt();
+
+	/* Zero out Array */
+	memset(log_settings, 0, sizeof(LogSettings) * Logs::LogCategory::MaxCategoryID);
+
+	/* Set Defaults */
+	log_settings[Logs::LoginServer].log_to_console = Logs::General;
+	log_settings[Logs::World_Server].log_to_console = Logs::General;
+	log_settings[Logs::Zone_Server].log_to_console = Logs::General;
+	log_settings[Logs::QS_Server].log_to_console = Logs::General;
+	log_settings[Logs::UCS_Server].log_to_console = Logs::General;
+	log_settings[Logs::Crash].log_to_console = Logs::General;
+	log_settings[Logs::MySQLError].log_to_console = Logs::General;
+
+	/*	Declare process file names for log writing
+		If there is no process_file_name declared, no log file will be written, simply
+	*/
+	if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformWorld)
+		platform_file_name = "world";
+	else if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformQueryServ)
+		platform_file_name = "query_server";
+	else if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformZone)
+		platform_file_name = "zone";
+	else if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformUCS)
+		platform_file_name = "ucs";
+	else if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformLogin)
+		platform_file_name = "login";
+	else if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformLaunch)
+		platform_file_name = "launcher";
+}
+
+std::string EQEmuLogSys::FormatOutMessageString(uint16 log_category, const std::string &in_message)
+{
+	std::string category_string;
+	if (log_category > 0 && Logs::LogCategoryName[log_category])
+		category_string = StringFormat("[%s] ", Logs::LogCategoryName[log_category]);
+	return StringFormat("%s%s", category_string.c_str(), in_message.c_str());
+}
+
+void EQEmuLogSys::ProcessGMSay(uint16 debug_level, uint16 log_category, const std::string &message)
+{
+	/* Check if category enabled for process */
+	if (log_settings[log_category].log_to_gmsay == 0)
+		return;
+
+	/* Enabling Netcode based GMSay output creates a feedback loop that ultimately ends in a crash */
+	if (log_category == Logs::LogCategory::Netcode)
+		return;
+
+	/* Make sure the message inbound is at a debug level we're set at */
+	if (log_settings[log_category].log_to_gmsay < debug_level)
+		return;
+
+	/* Check to see if the process that actually ran this is zone */
+	if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformZone)
+		on_log_gmsay_hook(log_category, message);
+}
+
+void EQEmuLogSys::ProcessLogWrite(uint16 debug_level, uint16 log_category, const std::string &message)
+{
+	if (log_category == Logs::Crash) {
+		char time_stamp[80];
+		EQEmuLogSys::SetCurrentTimeStamp(time_stamp);
+		std::ofstream crash_log;
+		EQEmuLogSys::MakeDirectory("logs/crashes");
+		crash_log.open(StringFormat("logs/crashes/crash_%s_%i.log", platform_file_name.c_str(), getpid()), std::ios_base::app | std::ios_base::out);
+		crash_log << time_stamp << " " << message << "\n";
+		crash_log.close();
+	}
+
+	/* Check if category enabled for process */
+	if (log_settings[log_category].log_to_file == 0)
+		return;
+
+	/* Make sure the message inbound is at a debug level we're set at */
+	if (log_settings[log_category].log_to_file < debug_level)
+		return;
+
+	char time_stamp[80];
+	EQEmuLogSys::SetCurrentTimeStamp(time_stamp);
+
+	if (process_log)
+		process_log << time_stamp << " " << message << std::endl;
+}
+
+uint16 EQEmuLogSys::GetWindowsConsoleColorFromCategory(uint16 log_category) {
+	switch (log_category) {
+		case Logs::Status:
+		case Logs::Normal:
+			return Console::Color::Yellow;
+		case Logs::MySQLError:
+		case Logs::Error:
+			return Console::Color::LightRed;
+		case Logs::MySQLQuery:
+		case Logs::Debug:
+			return Console::Color::LightGreen;
+		case Logs::Quests:
+			return Console::Color::LightCyan;
+		case Logs::Commands:
+		case Logs::Mercenaries:
+			return Console::Color::LightMagenta;
+		case Logs::Crash:
+			return Console::Color::LightRed;
+		default:
+			return Console::Color::Yellow;
+	}
+}
+
+std::string EQEmuLogSys::GetLinuxConsoleColorFromCategory(uint16 log_category) {
+	switch (log_category) {
+		case Logs::Status:
+		case Logs::Normal:
+			return LC_YELLOW;
+		case Logs::MySQLError:
+		case Logs::Error:
+			return LC_RED;
+		case Logs::MySQLQuery:
+		case Logs::Debug:
+			return LC_GREEN;
+		case Logs::Quests:
+			return LC_CYAN;
+		case Logs::Commands:
+		case Logs::Mercenaries:
+			return LC_MAGENTA;
+		case Logs::Crash:
+			return LC_RED;
+		default:
+			return LC_YELLOW;
+	}
+}
+
+uint16 EQEmuLogSys::GetGMSayColorFromCategory(uint16 log_category) {
+	switch (log_category) {
+		case Logs::Status:
+		case Logs::Normal:
+			return 15; /* Yellow */
+		case Logs::MySQLError:
+		case Logs::Error:
+			return 13; /* Red */
+		case Logs::MySQLQuery:
+		case Logs::Debug:
+			return 14; /* Light Green */
+		case Logs::Quests:
+			return 258; /* Light Cyan */
+		case Logs::Commands:
+		case Logs::Mercenaries:
+			return 5; /* Light Purple */
+		case Logs::Crash:
+			return 13; /* Red */
+		default:
+			return 15; /* Yellow */
+	}
+}
+
+void EQEmuLogSys::ProcessConsoleMessage(uint16 debug_level, uint16 log_category, const std::string &message)
+{
+	/* Check if category enabled for process */
+	if (log_settings[log_category].log_to_console == 0)
+		return;
+
+	/* Make sure the message inbound is at a debug level we're set at */
+	if (log_settings[log_category].log_to_console < debug_level)
+		return;
+
+	#ifdef _WINDOWS
+		HANDLE  console_handle;
+		console_handle = GetStdHandle(STD_OUTPUT_HANDLE);
+		CONSOLE_FONT_INFOEX info = { 0 };
+		info.cbSize = sizeof(info);
+		info.dwFontSize.Y = 12; // leave X as zero
+		info.FontWeight = FW_NORMAL;
+		wcscpy(info.FaceName, L"Lucida Console");
+		SetCurrentConsoleFontEx(console_handle, NULL, &info);
+		SetConsoleTextAttribute(console_handle, EQEmuLogSys::GetWindowsConsoleColorFromCategory(log_category));
+		std::cout << message << "\n";
+		SetConsoleTextAttribute(console_handle, Console::Color::White);
+	#else
+		std::cout << EQEmuLogSys::GetLinuxConsoleColorFromCategory(log_category) << message << LC_RESET << std::endl;
+	#endif
+}
+
+void EQEmuLogSys::Out(Logs::DebugLevel debug_level, uint16 log_category, std::string message, ...)
+{
+	_eqp
+	const bool log_to_console = log_settings[log_category].log_to_console > 0;
+	const bool log_to_file = log_settings[log_category].log_to_file > 0;
+	const bool log_to_gmsay = log_settings[log_category].log_to_gmsay > 0;
+	const bool nothing_to_log = !log_to_console && !log_to_file && !log_to_gmsay;
+
+	if (nothing_to_log) 
+		return;
+
+	va_list args;
+	va_start(args, message);
+	std::string output_message = vStringFormat(message.c_str(), args);
+	va_end(args);
+
+	std::string output_debug_message = EQEmuLogSys::FormatOutMessageString(log_category, output_message);
+
+	if (log_to_console) EQEmuLogSys::ProcessConsoleMessage(debug_level, log_category, output_debug_message);
+	if (log_to_gmsay) EQEmuLogSys::ProcessGMSay(debug_level, log_category, output_debug_message);
+	if (log_to_file) EQEmuLogSys::ProcessLogWrite(debug_level, log_category, output_debug_message);
+}
+
+void EQEmuLogSys::SetCurrentTimeStamp(char* time_stamp)
+{
+	time_t raw_time;
+	struct tm * time_info;
+	time(&raw_time);
+	time_info = localtime(&raw_time);
+	strftime(time_stamp, 80, "[%m-%d-%Y :: %H:%M:%S]", time_info);
+}
+
+void EQEmuLogSys::MakeDirectory(const std::string &directory_name)
+{
+#ifdef _WINDOWS
+	struct _stat st;
+	if (_stat(directory_name.c_str(), &st) == 0) // exists
+		return;
+	_mkdir(directory_name.c_str());
+#else
+	struct stat st;
+	if (stat(directory_name.c_str(), &st) == 0) // exists
+		return;
+	mkdir(directory_name.c_str(), 0755);
+#endif
+}
+
+void EQEmuLogSys::CloseFileLogs()
+{
+	if (process_log.is_open()) {
+		process_log.close();
+	}
+}
+
+void EQEmuLogSys::StartFileLogs(const std::string &log_name)
+{
+	EQEmuLogSys::CloseFileLogs();
+
+	/* When loading settings, we must have been given a reason in category based logging to output to a file in order to even create or open one... */
+	if (file_logs_enabled == false)
+		return;
+
+	if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformZone) {
+		if (!log_name.empty())
+			platform_file_name = log_name;
+
+		if (platform_file_name.empty())
+			return;
+
+		EQEmuLogSys::Out(Logs::General, Logs::Status, "Starting File Log 'logs/%s_%i.log'", platform_file_name.c_str(), getpid());
+		EQEmuLogSys::MakeDirectory("logs/zone");
+		process_log.open(StringFormat("logs/zone/%s_%i.log", platform_file_name.c_str(), getpid()), std::ios_base::app | std::ios_base::out);
+	} else {
+		if (platform_file_name.empty())
+			return;
+
+		EQEmuLogSys::Out(Logs::General, Logs::Status, "Starting File Log 'logs/%s_%i.log'", platform_file_name.c_str(), getpid());
+		process_log.open(StringFormat("logs/%s_%i.log", platform_file_name.c_str(), getpid()), std::ios_base::app | std::ios_base::out);
+	}
+}

common/eqemu_logsys.h

@@ -0,0 +1,208 @@
+/*	EQEMu: Everquest Server Emulator
+	Copyright (C) 2001-2015 EQEMu Development Team (http://eqemulator.net)
+
+	This program 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; version 2 of the License.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY except by those people which sell it, which
+	are required to give you total support for your newly bought product;
+	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 this program; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+*/
+
+#ifndef EQEMU_LOGSYS_H
+#define EQEMU_LOGSYS_H
+
+#include <iostream>
+#include <fstream>
+#include <stdio.h>
+#include <functional>
+
+#include "types.h"
+
+namespace Logs {
+	enum DebugLevel {
+		General = 1,	/* 1 - Low-Level general debugging, useful info on single line */
+		Moderate,		/* 2 - Informational based, used in functions, when particular things load */
+		Detail			/* 3 - Use this for extreme detail in logging, usually in extreme debugging in the stack or interprocess communication */
+	};
+
+	/*
+		If you add to this, make sure you update LogCategoryName
+		NOTE: Only add to the bottom of the enum because that is the type ID assignment
+	*/
+
+	enum LogCategory {
+		None = 0,
+		AA,
+		AI,
+		Aggro,
+		Attack,
+		Client_Server_Packet,
+		Combat,
+		Commands,
+		Crash,
+		Database,
+		Debug,
+		Doors,
+		Error,
+		Guilds,
+		Inventory,
+		Launcher,
+		LoginServer,
+		Netcode,
+		Normal,
+		Object,
+		Pathing,
+		QS_Server,
+		Quests,
+		Rules,
+		Skills,
+		Spawns,
+		Spells,
+		Status,
+		TCP_Connection,
+		Tasks,
+		Tradeskills,
+		Trading,
+		Tribute,
+		UCS_Server,
+		WebInterface_Server,
+		World_Server,
+		Zone_Server,
+		MySQLError,
+		MySQLQuery,
+		Mercenaries,
+		QuestDebug,
+		Server_Client_Packet,
+		Client_Server_Packet_Unhandled,
+		Server_Client_Packet_With_Dump,
+		Client_Server_Packet_With_Dump,
+		MaxCategoryID	/* Don't Remove this*/
+	};
+
+	/* If you add to this, make sure you update LogCategory */
+	static const char* LogCategoryName[LogCategory::MaxCategoryID] = {
+		"",
+		"AA",
+		"AI",
+		"Aggro",
+		"Attack",
+		"Packet :: Client -> Server",
+		"Combat",
+		"Commands",
+		"Crash",
+		"Database",
+		"Debug",
+		"Doors",
+		"Error",
+		"Guilds",
+		"Inventory",
+		"Launcher",
+		"LoginServer",
+		"Netcode",
+		"Normal",
+		"Object",
+		"Pathing",
+		"QS Server",
+		"Quests",
+		"Rules",
+		"Skills",
+		"Spawns",
+		"Spells",
+		"Status",
+		"TCP Connection",
+		"Tasks",
+		"Tradeskills",
+		"Trading",
+		"Tribute",
+		"UCS Server",
+		"WebInterface Server",
+		"World Server",
+		"Zone Server",
+		"MySQLError",
+		"MySQLQuery",
+		"Mercenaries",
+		"Quest Debug",
+		"Packet :: Server -> Client",
+		"Packet :: Client -> Server Unhandled",
+		"Packet :: Server -> Client (Dump)",
+		"Packet :: Client -> Server (Dump)",
+	};
+}
+
+class EQEmuLogSys {
+public:
+	EQEmuLogSys();
+	~EQEmuLogSys();
+
+	void CloseFileLogs(); /* Close File Logs wherever necessary, either at zone shutdown or entire process shutdown for everything else. This should be handled on deconstructor but to be safe we use it anyways. */
+	void LoadLogSettingsDefaults(); /* Initializes log_settings and sets some defaults if DB is not present */
+	void MakeDirectory(const std::string &directory_name); /* Platform independent way of performing a MakeDirectory based on name */
+	/*
+		The one and only Logging function that uses a debug level as a parameter, as well as a log_category
+		log_category - defined in Logs::LogCategory::[]
+		log_category name resolution works by passing the enum int ID to Logs::LogCategoryName[category_id]
+
+		Example: EQEmuLogSys::Out(Logs::General, Logs::Guilds, "This guild has no leader present");
+			- This would pipe the same category and debug level to all output formats, but the internal memory reference of log_settings would
+				be checked against to see if that piped output is set to actually process it for the category and debug level
+	*/
+	void Out(Logs::DebugLevel debug_level, uint16 log_category, std::string message, ...);
+	void SetCurrentTimeStamp(char* time_stamp); /* Used in file logs to prepend a timestamp entry for logs */ 
+	void StartFileLogs(const std::string &log_name = ""); /* Used to declare the processes file log and to keep it open for later use */
+
+	/*
+		LogSettings Struct
+
+		This struct is the master reference for all settings for each category, and for each output
+
+		log_to_file[category_id] = [1-3] - Sets debug level for category to output to file
+		log_to_console[category_id] = [1-3] - Sets debug level for category to output to console
+		log_to_gmsay[category_id] = [1-3] - Sets debug level for category to output to gmsay
+	*/
+
+	struct LogSettings {
+		uint8 log_to_file;
+		uint8 log_to_console;
+		uint8 log_to_gmsay;
+		uint8 is_category_enabled; /* When any log output in a category > 0, set this to 1 as (Enabled) */
+	};
+
+	/* Internally used memory reference for all log settings per category.
+		These are loaded via DB and have defaults loaded in LoadLogSettingsDefaults.
+		Database loaded via Database::LoadLogSettings(log_settings)
+	*/
+	LogSettings log_settings[Logs::LogCategory::MaxCategoryID];
+
+	bool file_logs_enabled; /* Set when log settings are loaded to determine if keeping a file open is necessary */
+
+	int log_platform; /* Sets Executable platform (Zone/World/UCS) etc. */
+
+	std::string platform_file_name; /* File name used in writing logs */
+
+	uint16 GetGMSayColorFromCategory(uint16 log_category); /* GMSay Client Message colors mapped by category */
+
+	void OnLogHookCallBackZone(std::function<void(uint16 log_type, const std::string&)> f) { on_log_gmsay_hook = f; }
+
+private:
+	std::function<void(uint16 log_category, const std::string&)> on_log_gmsay_hook; /* Callback pointer to zone process for hooking logs to zone using GMSay */
+	std::string FormatOutMessageString(uint16 log_category, const std::string &in_message); /* Formats log messages like '[Category] This is a log message' */
+	std::string GetLinuxConsoleColorFromCategory(uint16 log_category); /* Linux console color messages mapped by category */
+
+	uint16 GetWindowsConsoleColorFromCategory(uint16 log_category); /* Windows console color messages mapped by category */
+
+	void ProcessConsoleMessage(uint16 debug_level, uint16 log_category, const std::string &message); /* ProcessConsoleMessage called via Log.Out */
+	void ProcessGMSay(uint16 debug_level, uint16 log_category, const std::string &message); /* ProcessGMSay called via Log.Out */
+	void ProcessLogWrite(uint16 debug_level, uint16 log_category, const std::string &message); /* ProcessLogWrite called via Log.Out */
+};
+
+extern EQEmuLogSys Log;
+
+#endif

common/eqtime.cpp

@@ -17,7 +17,8 @@
 */
 
 #include <fstream>
-#include "../common/debug.h"
+#include "../common/global_define.h"
+#include "../common/eqemu_logsys.h"
 #include "../common/eqtime.h"
 #include "../common/eq_packet_structs.h"
 #include <memory.h>
@@ -140,11 +141,10 @@ bool EQTime::saveFile(const char *filename)
 	of.open(filename);
 	if(!of)
 	{
-		LogFile->write(EQEMuLog::Error, "EQTime::saveFile failed: Unable to open file '%s'", filename);
+		Log.Out(Logs::General, Logs::Error, "EQTime::saveFile failed: Unable to open file '%s'", filename);
 		return false;
 	}
 	//Enable for debugging
-	//std::cout << "SAVE: day=" << (long)eqTime.start_eqtime.day << ";hour=" << (long)eqTime.start_eqtime.hour << ";min=" << (long)eqTime.start_eqtime.minute << ";mon=" << (long)eqTime.start_eqtime.month << ";yr=" << eqTime.start_eqtime.year << ";timet=" << eqTime.start_realtime << std::endl;
 	of << EQT_VERSION << std::endl;
 	of << (long)eqTime.start_eqtime.day << std::endl;
 	of << (long)eqTime.start_eqtime.hour << std::endl;
@@ -164,14 +164,14 @@ bool EQTime::loadFile(const char *filename)
 	in.open(filename);
 	if(!in)
 	{
-		LogFile->write(EQEMuLog::Error, "Could not load EQTime file %s", filename);
+		Log.Out(Logs::General, Logs::Error, "Could not load EQTime file %s", filename);
 		return false;
 	}
 	in >> version;
 	in.ignore(80, '\n');
 	if(version != EQT_VERSION)
 	{
-		LogFile->write(EQEMuLog::Error, "'%s' is NOT a valid EQTime file. File version is %i, EQTime version is %i", filename, version, EQT_VERSION);
+		Log.Out(Logs::General, Logs::Error, "'%s' is NOT a valid EQTime file. File version is %i, EQTime version is %i", filename, version, EQT_VERSION);
 		return false;
 	}
 	//in >> eqTime.start_eqtime.day;
@@ -194,7 +194,6 @@ bool EQTime::loadFile(const char *filename)
 	in.ignore(80, '\n');
 	in >> eqTime.start_realtime;
 	//Enable for debugging...
-	//std::cout << "LOAD: day=" << (long)eqTime.start_eqtime.day << ";hour=" << (long)eqTime.start_eqtime.hour << ";min=" << (long)eqTime.start_eqtime.minute << ";mon=" << (long)eqTime.start_eqtime.month << ";yr=" << eqTime.start_eqtime.year << ";timet=" << eqTime.start_realtime << std::endl;
 	in.close();
 	return true;
 }

common/extprofile.cpp

@@ -16,7 +16,7 @@
 	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
 
-#include "debug.h"
+#include "global_define.h"
 #include "extprofile.h"
 
 //Set defaults in the extended profile...
@@ -26,6 +26,7 @@ void InitExtendedProfile(ExtendedProfile_Struct *p) {
 }
 
 bool SetExtendedProfile(ExtendedProfile_Struct *to, char *old, unsigned int len) {
+	_eqp
 	if(len == 0 || old == nullptr) {
 		//handle old chars without an extended profile...
 		InitExtendedProfile(to);

common/extprofile.h

@@ -19,8 +19,7 @@
 #define EXTENDED_PROFILE_H
 
 #include "eq_packet_structs.h"
-#include "Item.h"
-
+#include "item.h"
 
 #pragma pack(1)
 
@@ -37,24 +36,24 @@
 */
 struct ExtendedProfile_Struct {
 	// Pet stuff
-	uint16				pet_id;
-	uint16				old_pet_hp;
-	uint16				old_pet_mana;
-	SpellBuff_Struct	pet_buffs[BUFF_COUNT];
-	uint32				pet_items[_MaterialCount];
-	char				merc_name[64];
+	uint16				pet_id; /* Not Used */
+	uint16				old_pet_hp; /* Not Used */
+	uint16				old_pet_mana; /* Not Used */
+	SpellBuff_Struct	pet_buffs[BUFF_COUNT]; /* Not Used */
+	uint32				pet_items[_MaterialCount]; /* Not Used */
+	char				merc_name[64]; /* Used */
 
-	uint32				aa_effects;
-	uint32				perAA;		//% of exp going to AAs
-	uint32				expended_aa;		// Total of expended AA
-	uint32				pet_hp;
-	uint32				pet_mana;
-	uint32				mercTemplateID;
-	uint32				mercSuspendedTime;
-	bool				mercIsSuspended;
-	uint32				mercTimerRemaining;
-	uint8				mercGender;
-	int32				mercState;
+	uint32				aa_effects; /* Used */
+	uint32				perAA; /* Used: % of exp going to AAs */
+	uint32				expended_aa; /* Used: Total of expended AA */
+	uint32				pet_hp;  /* Not Used */
+	uint32				pet_mana; /* Not Used */
+	uint32				mercTemplateID; /* Not Used */
+	uint32				mercSuspendedTime; /* Not Used */
+	bool				mercIsSuspended; /* Not Used */
+	uint32				mercTimerRemaining; /* Not Used */
+	uint8				mercGender; /* Not Used */
+	int32				mercState; /* Not Used */
 };
 
 #pragma pack()

common/faction.cpp

@@ -1,4 +1,4 @@
-/*	EQEMu: Everquest Server Emulator
+/*	 EQEMu: Everquest Server Emulator
 	Copyright (C) 2001-2002 EQEMu Development Team (http://eqemu.org)
 
 	This program is free software; you can redistribute it and/or modify
@@ -15,126 +15,157 @@
 	along with this program; if not, write to the Free Software
 	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
-#include "debug.h"
+
 #include "faction.h"
 #include "races.h"
 
-const char *FactionValueToString(FACTION_VALUE fv) {
-	switch(fv) {
-	case FACTION_ALLY:
-		return("Ally");
-	case FACTION_WARMLY:
-		return("Warmly");
-	case FACTION_KINDLY:
-		return("Kindly");
-	case FACTION_AMIABLE:
-		return("Amiable");
-	case FACTION_INDIFFERENT:
-		return("Indifferent");
-	case FACTION_APPREHENSIVE:
-		return("Apprehensive");
-	case FACTION_DUBIOUS:
-		return("Dubious");
-	case FACTION_THREATENLY:
-		return("Threatenly");
-	case FACTION_SCOWLS:
-		return("Scowls, ready to attack.");
-	default:
-		break;
+const char *FactionValueToString(FACTION_VALUE fv)
+{
+	_eqp
+	switch (fv) {
+		case FACTION_ALLY:
+			return ("Ally");
+		case FACTION_WARMLY:
+			return ("Warmly");
+		case FACTION_KINDLY:
+			return ("Kindly");
+		case FACTION_AMIABLE:
+			return ("Amiable");
+		case FACTION_INDIFFERENT:
+			return ("Indifferent");
+		case FACTION_APPREHENSIVE:
+			return ("Apprehensive");
+		case FACTION_DUBIOUS:
+			return ("Dubious");
+		case FACTION_THREATENLY:
+			return ("Threatenly");
+		case FACTION_SCOWLS:
+			return ("Scowls, ready to attack.");
+		default:
+			break;
 	}
-	return("Unknown Faction Con");
+	return ("Unknown Faction Con");
 }
 
 
 //o--------------------------------------------------------------
-//| Name: CalculateFaction; rembrant, Dec. 16, 2001
+//| Name: CalculateFaction; Dec. 16, 2001
 //o--------------------------------------------------------------
 //| Notes: Returns the faction message value.
 //|		Modify these values to taste.
 //o--------------------------------------------------------------
 FACTION_VALUE CalculateFaction(FactionMods* fm, int32 tmpCharacter_value)
 {
+	_eqp
 	int32 character_value = tmpCharacter_value;
-	if (fm)
+	if (fm) {
 		character_value += fm->base + fm->class_mod + fm->race_mod + fm->deity_mod;
-	if(character_value >= 1101) return FACTION_ALLY;
-	if(character_value >= 701 && character_value <= 1100) return FACTION_WARMLY;
-	if(character_value >= 401 && character_value <= 700) return FACTION_KINDLY;
-	if(character_value >= 101 && character_value <= 400) return FACTION_AMIABLE;
-	if(character_value >= 0 && character_value <= 100) return FACTION_INDIFFERENT;
-	if(character_value >= -100 && character_value <= -1) return FACTION_APPREHENSIVE;
-	if(character_value >= -700 && character_value <= -101) return FACTION_DUBIOUS;
-	if(character_value >= -999 && character_value <= -701) return FACTION_THREATENLY;
-	if(character_value <= -1000) return FACTION_SCOWLS;
+	}
+	if (character_value >= 1101) {
+		return FACTION_ALLY;
+	}
+	if (character_value >= 701 && character_value <= 1100) {
+		return FACTION_WARMLY;
+	}
+	if (character_value >= 401 && character_value <= 700) {
+		return FACTION_KINDLY;
+	}
+	if (character_value >= 101 && character_value <= 400) {
+		return FACTION_AMIABLE;
+	}
+	if (character_value >= 0 && character_value <= 100) {
+		return FACTION_INDIFFERENT;
+	}
+	if (character_value >= -100 && character_value <= -1) {
+		return FACTION_APPREHENSIVE;
+	}
+	if (character_value >= -700 && character_value <= -101) {
+		return FACTION_DUBIOUS;
+	}
+	if (character_value >= -999 && character_value <= -701) {
+		return FACTION_THREATENLY;
+	}
+	if (character_value <= -1000) {
+		return FACTION_SCOWLS;
+	}
 	return FACTION_INDIFFERENT;
 }
 
-// neotokyo: this function should check if some races have more than one race define
+// this function should check if some races have more than one race define
 bool IsOfEqualRace(int r1, int r2)
 {
-	if (r1 == r2)
+	_eqp
+	if (r1 == r2) {
 		return true;
+	}
 	// TODO: add more values
-	switch(r1)
-	{
-	case DARK_ELF:
-		if (r2 == 77)
-			return true;
-		break;
-	case BARBARIAN:
-		if (r2 == 90)
-			return true;
+	switch (r1) {
+		case DARK_ELF:
+			if (r2 == 77) {
+				return true;
+			}
+			break;
+		case BARBARIAN:
+			if (r2 == 90) {
+				return true;
+			}
 	}
 	return false;
 }
 
-// neotokyo: trolls endure ogres, dark elves, ...
+// trolls endure ogres, dark elves, ...
 bool IsOfIndiffRace(int r1, int r2)
 {
-	if (r1 == r2)
+	_eqp
+	if (r1 == r2) {
 		return true;
+	}
 	// TODO: add more values
-	switch(r1)
-	{
-	case DARK_ELF:
-	case OGRE:
-	case TROLL:
-		if (r2 == OGRE || r2 == TROLL || r2 == DARK_ELF)
+	switch (r1) {
+		case DARK_ELF:
+		case OGRE:
+		case TROLL:
+			if (r2 == OGRE || r2 == TROLL || r2 == DARK_ELF) {
+				return true;
+			}
+			break;
+		case HUMAN:
+		case BARBARIAN:
+		case HALF_ELF:
+		case GNOME:
+		case HALFLING:
+		case WOOD_ELF:
+			if (r2 == HUMAN ||
+			    r2 == BARBARIAN ||
+			    r2 == ERUDITE ||
+			    r2 == HALF_ELF ||
+			    r2 == GNOME ||
+			    r2 == HALFLING ||
+			    r2 == DWARF ||
+			    r2 == HIGH_ELF ||
+			    r2 == WOOD_ELF) {
+				return true;
+			}
+			break;
+		case ERUDITE:
+			if (r2 == HUMAN || r2 == HALF_ELF) {
+				return true;
+			}
+			break;
+		case DWARF:
+			if (r2 == HALFLING || r2 == GNOME) {
+				return true;
+			}
+			break;
+		case HIGH_ELF:
+			if (r2 == WOOD_ELF) {
+				return true;
+			}
+			break;
+		case VAHSHIR:
 			return true;
-		break;
-	case HUMAN:
-	case BARBARIAN:
-	case HALF_ELF:
-	case GNOME:
-	case HALFLING:
-	case WOOD_ELF:
-		if (r2 == HUMAN ||
-			r2 == BARBARIAN ||
-			r2 == ERUDITE ||
-			r2 == HALF_ELF ||
-			r2 == GNOME ||
-			r2 == HALFLING ||
-			r2 == DWARF ||
-			r2 == HIGH_ELF ||
-			r2 == WOOD_ELF)
-			return true;
-		break;
-	case ERUDITE:
-		if (r2 == HUMAN || r2 == HALF_ELF)
-			return true;
-		break;
-	case DWARF:
-		if (r2 == HALFLING || r2 == GNOME)
-			return true;
-		break;
-	case HIGH_ELF:
-		if (r2 == WOOD_ELF)
-			return true;
-		break;
-	case VAHSHIR:
-		return true;
-	case IKSAR:
-		return false;
+		case IKSAR:
+			return false;
 	}
 	return false;
 }

common/features.h

@@ -163,7 +163,7 @@ enum {	//timer settings, all in milliseconds
 	CombatEventTimer_expire = 12000,
 	Tribute_duration = 600000,
 	ZoneTimerResolution = 3,			//sleep time between zone main loop runs (milliseconds)
-	FeignMemoryDuration = 120000, // EverHood - Duration player must feign death to clear zonewide agro.
+	FeignMemoryDuration = 120000, // Duration player must feign death to clear zonewide agro.
 	EnragedTimer = 360000,
 	EnragedDurationTimer = 10000
 };
@@ -208,12 +208,12 @@ enum {	//some random constants
 //chance ratio that a
 #define THREATENLY_ARRGO_CHANCE 32 // 32/128 (25%) chance that a mob will arrgo on con Threatenly
 
-// max factions per npc faction list
+//max factions per npc faction list
 #define MAX_NPC_FACTIONS 20
 
-//value caps
-#define MAX_FACTION 1500
-#define MIN_FACTION -1500
+//individual faction pool
+#define MAX_PERSONAL_FACTION 1200
+#define MIN_PERSONAL_FACTION -3000
 
 //The Level Cap:
 //#define LEVEL_CAP RuleI(Character, MaxLevel)	//hard cap is 127
@@ -261,7 +261,8 @@ enum {
 	commandChangeFlags = 200,		//ability to set/refresh flags
 	commandBanPlayers = 100,		//can set bans on players
 	commandChangeDatarate = 201,	//edit client's data rate
-	commandZoneToCoords = 0			//can #zone with coords
+	commandZoneToCoords = 0,		//can #zone with coords
+	commandInterrogateInv = 100		//below this == only log on error state and self-only target dump
 };
 
 //default states for logging flag on NPCs and clients (having NPCs on by default is prolly a bad idea)

common/glm/glm/CMakeLists.txt

@@ -30,11 +30,13 @@ source_group("GTX Files" FILES ${GTX_HEADER})
 
 include_directories(${CMAKE_CURRENT_SOURCE_DIR}/..)
 
-add_executable(${NAME} ${ROOT_TEXT}
-	${ROOT_SOURCE}    ${ROOT_INLINE}    ${ROOT_HEADER}
-	${CORE_SOURCE}    ${CORE_INLINE}    ${CORE_HEADER}
-	${GTC_SOURCE}     ${GTC_INLINE}     ${GTC_HEADER}
-	${GTX_SOURCE}     ${GTX_INLINE}     ${GTX_HEADER})
+if(GLM_TEST_ENABLE)
+	add_executable(${NAME} ${ROOT_TEXT}
+		${ROOT_SOURCE}    ${ROOT_INLINE}    ${ROOT_HEADER}
+		${CORE_SOURCE}    ${CORE_INLINE}    ${CORE_HEADER}
+		${GTC_SOURCE}     ${GTC_INLINE}     ${GTC_HEADER}
+		${GTX_SOURCE}     ${GTX_INLINE}     ${GTX_HEADER})
+endif(GLM_TEST_ENABLE)
 
 #add_library(glm STATIC glm.cpp)
 #add_library(glm_shared SHARED glm.cpp)

common/glm/glm/common.hpp

@@ -12,6 +12,10 @@
 /// The above copyright notice and this permission notice shall be included in
 /// all copies or substantial portions of the Software.
 /// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
 /// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 /// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 /// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
@@ -26,9 +30,6 @@
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_COMMON_INCLUDED
-#define GLM_COMMON_INCLUDED
+#pragma once
 
 #include "detail/func_common.hpp"
-
-#endif//GLM_COMMON_INCLUDED

common/glm/glm/detail/_features.hpp

@@ -12,6 +12,10 @@
 /// The above copyright notice and this permission notice shall be included in
 /// all copies or substantial portions of the Software.
 /// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
 /// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 /// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 /// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
@@ -21,13 +25,12 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/_features.hpp
+/// @file glm/detail/_features.hpp
 /// @date 2013-02-20 / 2013-02-20
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef glm_core_features
-#define glm_core_features
+#pragma once
 
 // #define GLM_CXX98_EXCEPTIONS
 // #define GLM_CXX98_RTTI
@@ -281,7 +284,7 @@
 #		define GLM_CXX11_STATIC_ASSERT
 #	endif
 
-#elif(GLM_COMPILER & GLM_COMPILER_CLANG)
+#elif(GLM_COMPILER & (GLM_COMPILER_APPLE_CLANG | GLM_COMPILER_LLVM))
 #	if(__has_feature(cxx_exceptions))
 #		define GLM_CXX98_EXCEPTIONS
 #	endif
@@ -422,6 +425,4 @@
 #		define GLM_CXX11_VARIADIC_TEMPLATES
 #	endif
 
-#endif//(GLM_COMPILER & GLM_COMPILER_CLANG)
-
-#endif//glm_core_features
+#endif//(GLM_COMPILER & (GLM_COMPILER_APPLE_CLANG | GLM_COMPILER_LLVM))

common/glm/glm/detail/_fixes.hpp

@@ -12,6 +12,10 @@
 /// The above copyright notice and this permission notice shall be included in
 /// all copies or substantial portions of the Software.
 /// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
 /// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 /// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 /// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
@@ -21,7 +25,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/_fixes.hpp
+/// @file glm/detail/_fixes.hpp
 /// @date 2011-02-21 / 2011-11-22
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////

common/glm/glm/detail/_noise.hpp

@@ -12,6 +12,10 @@
 /// The above copyright notice and this permission notice shall be included in
 /// all copies or substantial portions of the Software.
 /// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
 /// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 /// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 /// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
@@ -26,8 +30,12 @@
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_DETAIL_NOISE_INCLUDED
-#define GLM_DETAIL_NOISE_INCLUDED
+#pragma once
+
+#include "../vec2.hpp"
+#include "../vec3.hpp"
+#include "../vec4.hpp"
+#include "../common.hpp"
 
 namespace glm{
 namespace detail
@@ -75,19 +83,19 @@ namespace detail
 	}
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec2<T, P> taylorInvSqrt(detail::tvec2<T, P> const & r)
+	GLM_FUNC_QUALIFIER tvec2<T, P> taylorInvSqrt(tvec2<T, P> const & r)
 	{
 		return T(1.79284291400159) - T(0.85373472095314) * r;
 	}
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> taylorInvSqrt(detail::tvec3<T, P> const & r)
+	GLM_FUNC_QUALIFIER tvec3<T, P> taylorInvSqrt(tvec3<T, P> const & r)
 	{
 		return T(1.79284291400159) - T(0.85373472095314) * r;
 	}
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<T, P> taylorInvSqrt(detail::tvec4<T, P> const & r)
+	GLM_FUNC_QUALIFIER tvec4<T, P> taylorInvSqrt(tvec4<T, P> const & r)
 	{
 		return T(1.79284291400159) - T(0.85373472095314) * r;
 	}
@@ -100,19 +108,19 @@ namespace detail
 */
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec2<T, P> fade(detail::tvec2<T, P> const & t)
+	GLM_FUNC_QUALIFIER tvec2<T, P> fade(tvec2<T, P> const & t)
 	{
 		return (t * t * t) * (t * (t * T(6) - T(15)) + T(10));
 	}
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> fade(detail::tvec3<T, P> const & t)
+	GLM_FUNC_QUALIFIER tvec3<T, P> fade(tvec3<T, P> const & t)
 	{
 		return (t * t * t) * (t * (t * T(6) - T(15)) + T(10));
 	}
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<T, P> fade(detail::tvec4<T, P> const & t)
+	GLM_FUNC_QUALIFIER tvec4<T, P> fade(tvec4<T, P> const & t)
 	{
 		return (t * t * t) * (t * (t * T(6) - T(15)) + T(10));
 	}
@@ -126,5 +134,3 @@ namespace detail
 }//namespace detail
 }//namespace glm
 
-#endif//GLM_DETAIL_NOISE_INCLUDED
-

common/glm/glm/detail/_swizzle_func.hpp

@@ -12,6 +12,10 @@
 /// The above copyright notice and this permission notice shall be included in
 /// all copies or substantial portions of the Software.
 /// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
 /// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 /// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 /// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
@@ -21,13 +25,12 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/_swizzle_func.hpp
+/// @file glm/detail/_swizzle_func.hpp
 /// @date 2011-10-16 / 2011-10-16
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef glm_core_swizzle_func
-#define glm_core_swizzle_func
+#pragma once
 
 #define GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, CONST, A, B)	\
 	SWIZZLED_TYPE<TMPL_TYPE, PRECISION> A ## B() CONST												\
@@ -720,5 +723,3 @@
 	GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, s, t, p, q)
 
 //GLM_SWIZZLE_GEN_VEC_FROM_VEC4(valType, detail::vec4, detail::vec2, detail::vec3, detail::vec4)
-
-#endif//glm_core_swizzle_func

common/glm/glm/detail/_vectorize.hpp

@@ -12,6 +12,10 @@
 /// The above copyright notice and this permission notice shall be included in
 /// all copies or substantial portions of the Software.
 /// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
 /// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 /// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 /// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
@@ -21,197 +25,136 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/_vectorize.hpp
+/// @file glm/detail/_vectorize.hpp
 /// @date 2011-10-14 / 2011-10-14
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_CORE_DETAIL_INCLUDED
-#define GLM_CORE_DETAIL_INCLUDED
+#pragma once
 
 #include "type_vec1.hpp"
 #include "type_vec2.hpp"
 #include "type_vec3.hpp"
 #include "type_vec4.hpp"
 
-#define VECTORIZE1_VEC(func)						\
-	template <typename T, precision P>				\
-	GLM_FUNC_QUALIFIER detail::tvec1<T, P> func(	\
-		detail::tvec1<T, P> const & v)				\
-	{												\
-		return detail::tvec1<T, P>(					\
-			func(v.x));								\
-	}
-
-#define VECTORIZE2_VEC(func)						\
-	template <typename T, precision P>				\
-	GLM_FUNC_QUALIFIER detail::tvec2<T, P> func(	\
-		detail::tvec2<T, P> const & v)				\
-	{												\
-		return detail::tvec2<T, P>(					\
-			func(v.x),								\
-			func(v.y));								\
-	}
-
-#define VECTORIZE3_VEC(func)						\
-	template <typename T, precision P>				\
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> func(	\
-		detail::tvec3<T, P> const & v)				\
-	{												\
-		return detail::tvec3<T, P>(					\
-			func(v.x),								\
-			func(v.y),								\
-			func(v.z));								\
-	}
-
-#define VECTORIZE4_VEC(func)						\
-	template <typename T, precision P>				\
-	GLM_FUNC_QUALIFIER detail::tvec4<T, P> func(	\
-		detail::tvec4<T, P> const & v)				\
-	{												\
-		return detail::tvec4<T, P>(					\
-			func(v.x),								\
-			func(v.y),								\
-			func(v.z),								\
-			func(v.w));								\
-	}
-
-#define VECTORIZE_VEC(func)		\
-	VECTORIZE1_VEC(func)		\
-	VECTORIZE2_VEC(func)		\
-	VECTORIZE3_VEC(func)		\
-	VECTORIZE4_VEC(func)
-
-#define VECTORIZE1_VEC_SCA(func)							\
-	template <typename T, precision P>						\
-	GLM_FUNC_QUALIFIER detail::tvec1<T, P> func				\
-	(														\
-		detail::tvec1<T, P> const & x,						\
-		T const & y											\
-	)														\
-	{														\
-		return detail::tvec1<T, P>(							\
-			func(x.x, y));									\
-	}
-
-#define VECTORIZE2_VEC_SCA(func)							\
-	template <typename T, precision P>						\
-	GLM_FUNC_QUALIFIER detail::tvec2<T, P> func				\
-	(														\
-		detail::tvec2<T, P> const & x,						\
-		T const & y	\
-	)														\
-	{														\
-		return detail::tvec2<T, P>(							\
-			func(x.x, y),									\
-			func(x.y, y));									\
-	}
-
-#define VECTORIZE3_VEC_SCA(func)							\
-	template <typename T, precision P>						\
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> func				\
-	(														\
-		detail::tvec3<T, P> const & x,						\
-		T const & y	\
-	)														\
-	{														\
-		return detail::tvec3<T, P>(							\
-			func(x.x, y),									\
-			func(x.y, y),									\
-			func(x.z, y));									\
-	}
-
-#define VECTORIZE4_VEC_SCA(func)							\
-	template <typename T, precision P>						\
-	GLM_FUNC_QUALIFIER detail::tvec4<T, P> func				\
-	(														\
-		detail::tvec4<T, P> const & x,						\
-		T const & y	\
-	)														\
-	{														\
-		return detail::tvec4<T, P>(							\
-			func(x.x, y),									\
-			func(x.y, y),									\
-			func(x.z, y),									\
-			func(x.w, y));									\
-	}
-
-#define VECTORIZE_VEC_SCA(func)		\
-	VECTORIZE1_VEC_SCA(func)		\
-	VECTORIZE2_VEC_SCA(func)		\
-	VECTORIZE3_VEC_SCA(func)		\
-	VECTORIZE4_VEC_SCA(func)
-
-#define VECTORIZE2_VEC_VEC(func)					\
-	template <typename T, precision P>				\
-	GLM_FUNC_QUALIFIER detail::tvec2<T, P> func		\
-	(												\
-		detail::tvec2<T, P> const & x,				\
-		detail::tvec2<T, P> const & y				\
-	)												\
-	{												\
-		return detail::tvec2<T, P>(					\
-			func(x.x, y.x),							\
-			func(x.y, y.y));						\
-	}
-
-#define VECTORIZE3_VEC_VEC(func)					\
-	template <typename T, precision P>				\
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> func		\
-	(												\
-		detail::tvec3<T, P> const & x,				\
-		detail::tvec3<T, P> const & y				\
-	)												\
-	{												\
-		return detail::tvec3<T, P>(					\
-			func(x.x, y.x),							\
-			func(x.y, y.y),							\
-			func(x.z, y.z));						\
-	}
-
-#define VECTORIZE4_VEC_VEC(func)				\
-	template <typename T, precision P>			\
-	GLM_FUNC_QUALIFIER detail::tvec4<T, P> func	\
-	(											\
-		detail::tvec4<T, P> const & x,			\
-		detail::tvec4<T, P> const & y			\
-	)											\
-	{											\
-		return detail::tvec4<T, P>(				\
-			func(x.x, y.x),						\
-			func(x.y, y.y),						\
-			func(x.z, y.z),						\
-			func(x.w, y.w));					\
-	}
-
-#define VECTORIZE_VEC_VEC(func)		\
-	VECTORIZE2_VEC_VEC(func)		\
-	VECTORIZE3_VEC_VEC(func)		\
-	VECTORIZE4_VEC_VEC(func)
-
 namespace glm{
 namespace detail
 {
-	template<bool C>
-	struct If
+	template <typename R, typename T, precision P, template <typename, precision> class vecType>
+	struct functor1{};
+
+	template <typename R, typename T, precision P>
+	struct functor1<R, T, P, tvec1>
 	{
-		template<typename F, typename T>
-		static GLM_FUNC_QUALIFIER T apply(F functor, const T& val)
+		GLM_FUNC_QUALIFIER static tvec1<R, P> call(R (*Func) (T x), tvec1<T, P> const & v)
 		{
-			return functor(val);
+			return tvec1<R, P>(Func(v.x));
 		}
 	};
 
-	template<>
-	struct If<false>
+	template <typename R, typename T, precision P>
+	struct functor1<R, T, P, tvec2>
 	{
-		template<typename F, typename T>
-		static GLM_FUNC_QUALIFIER T apply(F, const T& val)
+		GLM_FUNC_QUALIFIER static tvec2<R, P> call(R (*Func) (T x), tvec2<T, P> const & v)
 		{
-			return val;
+			return tvec2<R, P>(Func(v.x), Func(v.y));
+		}
+	};
+
+	template <typename R, typename T, precision P>
+	struct functor1<R, T, P, tvec3>
+	{
+		GLM_FUNC_QUALIFIER static tvec3<R, P> call(R (*Func) (T x), tvec3<T, P> const & v)
+		{
+			return tvec3<R, P>(Func(v.x), Func(v.y), Func(v.z));
+		}
+	};
+
+	template <typename R, typename T, precision P>
+	struct functor1<R, T, P, tvec4>
+	{
+		GLM_FUNC_QUALIFIER static tvec4<R, P> call(R (*Func) (T x), tvec4<T, P> const & v)
+		{
+			return tvec4<R, P>(Func(v.x), Func(v.y), Func(v.z), Func(v.w));
+		}
+	};
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	struct functor2{};
+
+	template <typename T, precision P>
+	struct functor2<T, P, tvec1>
+	{
+		GLM_FUNC_QUALIFIER static tvec1<T, P> call(T (*Func) (T x, T y), tvec1<T, P> const & a, tvec1<T, P> const & b)
+		{
+			return tvec1<T, P>(Func(a.x, b.x));
+		}
+	};
+
+	template <typename T, precision P>
+	struct functor2<T, P, tvec2>
+	{
+		GLM_FUNC_QUALIFIER static tvec2<T, P> call(T (*Func) (T x, T y), tvec2<T, P> const & a, tvec2<T, P> const & b)
+		{
+			return tvec2<T, P>(Func(a.x, b.x), Func(a.y, b.y));
+		}
+	};
+
+	template <typename T, precision P>
+	struct functor2<T, P, tvec3>
+	{
+		GLM_FUNC_QUALIFIER static tvec3<T, P> call(T (*Func) (T x, T y), tvec3<T, P> const & a, tvec3<T, P> const & b)
+		{
+			return tvec3<T, P>(Func(a.x, b.x), Func(a.y, b.y), Func(a.z, b.z));
+		}
+	};
+
+	template <typename T, precision P>
+	struct functor2<T, P, tvec4>
+	{
+		GLM_FUNC_QUALIFIER static tvec4<T, P> call(T (*Func) (T x, T y), tvec4<T, P> const & a, tvec4<T, P> const & b)
+		{
+			return tvec4<T, P>(Func(a.x, b.x), Func(a.y, b.y), Func(a.z, b.z), Func(a.w, b.w));
+		}
+	};
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	struct functor2_vec_sca{};
+
+	template <typename T, precision P>
+	struct functor2_vec_sca<T, P, tvec1>
+	{
+		GLM_FUNC_QUALIFIER static tvec1<T, P> call(T (*Func) (T x, T y), tvec1<T, P> const & a, T b)
+		{
+			return tvec1<T, P>(Func(a.x, b));
+		}
+	};
+
+	template <typename T, precision P>
+	struct functor2_vec_sca<T, P, tvec2>
+	{
+		GLM_FUNC_QUALIFIER static tvec2<T, P> call(T (*Func) (T x, T y), tvec2<T, P> const & a, T b)
+		{
+			return tvec2<T, P>(Func(a.x, b), Func(a.y, b));
+		}
+	};
+
+	template <typename T, precision P>
+	struct functor2_vec_sca<T, P, tvec3>
+	{
+		GLM_FUNC_QUALIFIER static tvec3<T, P> call(T (*Func) (T x, T y), tvec3<T, P> const & a, T b)
+		{
+			return tvec3<T, P>(Func(a.x, b), Func(a.y, b), Func(a.z, b));
+		}
+	};
+
+	template <typename T, precision P>
+	struct functor2_vec_sca<T, P, tvec4>
+	{
+		GLM_FUNC_QUALIFIER static tvec4<T, P> call(T (*Func) (T x, T y), tvec4<T, P> const & a, T b)
+		{
+			return tvec4<T, P>(Func(a.x, b), Func(a.y, b), Func(a.z, b), Func(a.w, b));
 		}
 	};
 }//namespace detail
 }//namespace glm
-
-#endif//GLM_CORE_DETAIL_INCLUDED

common/glm/glm/detail/dummy.cpp

@@ -12,6 +12,10 @@
 /// The above copyright notice and this permission notice shall be included in
 /// all copies or substantial portions of the Software.
 /// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
 /// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 /// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 /// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
@@ -29,7 +33,6 @@
 /// dummy.cpp exist only a wordaround for CMake file.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#define GLM_FORCE_RADIANS
 #define GLM_MESSAGES
 #include "../glm.hpp"
 #include <limits>
@@ -42,6 +45,7 @@ struct material
 	glm::vec4 specular; // Scm
 	float shininess; // Srm
 };
+
 struct light
 {
 	glm::vec4 ambient; // Acli
@@ -60,6 +64,7 @@ struct light
 	float quadraticAttenuation;// K2
 };
 
+
 // Sample 1
 #include <glm/vec3.hpp>// glm::vec3
 #include <glm/geometric.hpp>// glm::cross, glm::normalize
@@ -184,7 +189,34 @@ glm::vec3 lighting
 	return Color;
 }
 */
+
+
+template <typename T, glm::precision P, template<typename, glm::precision> class vecType>
+T normalizeDotA(vecType<T, P> const & x, vecType<T, P> const & y)
+{
+	return glm::dot(x, y) * glm::inversesqrt(glm::dot(x, x) * glm::dot(y, y));
+}
+
+#define GLM_TEMPLATE_GENTYPE typename T, glm::precision P, template<typename, glm::precision> class
+
+template <GLM_TEMPLATE_GENTYPE vecType>
+T normalizeDotB(vecType<T, P> const & x, vecType<T, P> const & y)
+{
+	return glm::dot(x, y) * glm::inversesqrt(glm::dot(x, x) * glm::dot(y, y));
+}
+
+template <typename vecType>
+typename vecType::value_type normalizeDotC(vecType const & a, vecType const & b)
+{
+	return glm::dot(a, b) * glm::inversesqrt(glm::dot(a, a) * glm::dot(b, b));
+}
+
 int main()
 {
+	glm::vec4 v(1);
+	float a = normalizeDotA(v, v);
+	float b = normalizeDotB(v, v);
+	float c = normalizeDotC(v, v);
+
 	return 0;
 }

common/glm/glm/detail/func_common.hpp

@@ -12,6 +12,10 @@
 /// The above copyright notice and this permission notice shall be included in
 /// all copies or substantial portions of the Software.
 /// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
 /// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 /// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 /// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
@@ -21,7 +25,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/func_common.hpp
+/// @file glm/detail/func_common.hpp
 /// @date 2008-03-08 / 2010-01-26
 /// @author Christophe Riccio
 /// 
@@ -33,8 +37,7 @@
 /// These all operate component-wise. The description is per component.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_FUNC_COMMON_INCLUDED
-#define GLM_FUNC_COMMON_INCLUDED
+#pragma once
 
 #include "setup.hpp"
 #include "precision.hpp"
@@ -53,7 +56,10 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/abs.xml">GLSL abs man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
 	template <typename genType>
-	GLM_FUNC_DECL genType abs(genType const & x);
+	GLM_FUNC_DECL genType abs(genType x);
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> abs(vecType<T, P> const & x);
 
 	/// Returns 1.0 if x > 0, 0.0 if x == 0, or -1.0 if x < 0. 
 	/// 
@@ -61,17 +67,17 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/sign.xml">GLSL sign man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename genType>
-	GLM_FUNC_DECL genType sign(genType const & x);
-	
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> sign(vecType<T, P> const & x);
+
 	/// Returns a value equal to the nearest integer that is less then or equal to x. 
 	/// 
 	/// @tparam genType Floating-point scalar or vector types.
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/floor.xml">GLSL floor man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename genType>
-	GLM_FUNC_DECL genType floor(genType const & x);
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> floor(vecType<T, P> const & x);
 
 	/// Returns a value equal to the nearest integer to x
 	/// whose absolute value is not larger than the absolute value of x.
@@ -80,8 +86,8 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/trunc.xml">GLSL trunc man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename genType>
-	GLM_FUNC_DECL genType trunc(genType const & x);
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> trunc(vecType<T, P> const & x);
 
 	/// Returns a value equal to the nearest integer to x.
 	/// The fraction 0.5 will round in a direction chosen by the
@@ -93,9 +99,9 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/round.xml">GLSL round man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename genType>
-	GLM_FUNC_DECL genType round(genType const & x);
-	
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> round(vecType<T, P> const & x);
+
 	/// Returns a value equal to the nearest integer to x.
 	/// A fractional part of 0.5 will round toward the nearest even
 	/// integer. (Both 3.5 and 4.5 for x will return 4.0.)
@@ -105,8 +111,8 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/roundEven.xml">GLSL roundEven man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
 	/// @see <a href="http://developer.amd.com/documentation/articles/pages/New-Round-to-Even-Technique.aspx">New round to even technique</a>
-	template <typename genType>
-	GLM_FUNC_DECL genType roundEven(genType const & x);
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> roundEven(vecType<T, P> const & x);
 
 	/// Returns a value equal to the nearest integer
 	/// that is greater than or equal to x.
@@ -115,8 +121,8 @@ namespace glm
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/ceil.xml">GLSL ceil man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename genType>
-	GLM_FUNC_DECL genType ceil(genType const & x);
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> ceil(vecType<T, P> const & x);
 
 	/// Return x - floor(x).
 	/// 
@@ -125,7 +131,10 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/fract.xml">GLSL fract man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
 	template <typename genType>
-	GLM_FUNC_DECL genType fract(genType const & x);
+	GLM_FUNC_DECL genType fract(genType x);
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> fract(vecType<T, P> const & x);
 
 	/// Modulus. Returns x - y * floor(x / y)
 	/// for each component in x using the floating point value y.
@@ -135,21 +144,13 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/mod.xml">GLSL mod man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
 	template <typename genType>
-	GLM_FUNC_DECL genType mod(
-		genType const & x,
-		genType const & y);
+	GLM_FUNC_DECL genType mod(genType x, genType y);
 
-	/// Modulus. Returns x - y * floor(x / y)
-	/// for each component in x using the floating point value y.
-	/// 
-	/// @tparam genType Floating-point scalar or vector types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/mod.xml">GLSL mod man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename genType>
-	GLM_FUNC_DECL genType mod(
-		genType const & x,
-		typename genType::value_type const & y);
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> mod(vecType<T, P> const & x, T y);
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> mod(vecType<T, P> const & x, vecType<T, P> const & y);
 
 	/// Returns the fractional part of x and sets i to the integer
 	/// part (as a whole number floating point value). Both the
@@ -161,25 +162,22 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/modf.xml">GLSL modf man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
 	template <typename genType>
-	GLM_FUNC_DECL genType modf(
-		genType const & x,
-		genType & i);
+	GLM_FUNC_DECL genType modf(genType x, genType & i);
 
 	/// Returns y if y < x; otherwise, it returns x.
 	///
 	/// @tparam genType Floating-point or integer; scalar or vector types.
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/min.xml">GLSL min man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a><<<<<<< HEAD
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
 	template <typename genType>
-	GLM_FUNC_DECL genType min(
-		genType const & x,
-		genType const & y);
+	GLM_FUNC_DECL genType min(genType x, genType y);
 
-	template <typename genType>
-	GLM_FUNC_DECL genType min(
-		genType const & x,
-		typename genType::value_type const & y);
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> min(vecType<T, P> const & x, T y);
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> min(vecType<T, P> const & x, vecType<T, P> const & y);
 
 	/// Returns y if x < y; otherwise, it returns x.
 	/// 
@@ -188,14 +186,13 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/max.xml">GLSL max man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
 	template <typename genType>
-	GLM_FUNC_DECL genType max(
-		genType const & x,
-		genType const & y);
+	GLM_FUNC_DECL genType max(genType x, genType y);
 
-	template <typename genType>
-	GLM_FUNC_DECL genType max(
-		genType const & x,
-		typename genType::value_type const & y);
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> max(vecType<T, P> const & x, T y);
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> max(vecType<T, P> const & x, vecType<T, P> const & y);
 
 	/// Returns min(max(x, minVal), maxVal) for each component in x 
 	/// using the floating-point values minVal and maxVal.
@@ -205,16 +202,13 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/clamp.xml">GLSL clamp man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
 	template <typename genType>
-	GLM_FUNC_DECL genType clamp(
-		genType const & x,
-		genType const & minVal,
-		genType const & maxVal);
+	GLM_FUNC_DECL genType clamp(genType x, genType minVal, genType maxVal);
 
-	template <typename genType, precision P>
-	GLM_FUNC_DECL genType clamp(
-		genType const & x,
-		typename genType::value_type const & minVal,
-		typename genType::value_type const & maxVal);
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> clamp(vecType<T, P> const & x, T minVal, T maxVal);
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> clamp(vecType<T, P> const & x, vecType<T, P> const & minVal, vecType<T, P> const & maxVal);
 
 	/// If genTypeU is a floating scalar or vector:
 	/// Returns x * (1.0 - a) + y * a, i.e., the linear blend of
@@ -259,40 +253,34 @@ namespace glm
 	/// glm::vec4 u = glm::mix(g, h, r); // Interpolations can be perform per component with a vector for the last parameter.
 	/// @endcode
 	template <typename T, typename U, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> mix(
-		vecType<T, P> const & x,
-		vecType<T, P> const & y,
-		vecType<U, P> const & a);
+	GLM_FUNC_DECL vecType<T, P> mix(vecType<T, P> const & x, vecType<T, P> const & y, vecType<U, P> const & a);
 
 	template <typename T, typename U, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> mix(
-		vecType<T, P> const & x,
-		vecType<T, P> const & y,
-		U const & a);
+	GLM_FUNC_DECL vecType<T, P> mix(vecType<T, P> const & x, vecType<T, P> const & y, U a);
 
 	template <typename genTypeT, typename genTypeU>
-	GLM_FUNC_DECL genTypeT mix(
-		genTypeT const & x,
-		genTypeT const & y,
-		genTypeU const & a);
+	GLM_FUNC_DECL genTypeT mix(genTypeT x, genTypeT y, genTypeU a);
 
 	/// Returns 0.0 if x < edge, otherwise it returns 1.0 for each component of a genType.
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/step.xml">GLSL step man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
 	template <typename genType>
-	GLM_FUNC_DECL genType step(
-		genType const & edge,
-		genType const & x);
+	GLM_FUNC_DECL genType step(genType edge, genType x);
 
 	/// Returns 0.0 if x < edge, otherwise it returns 1.0.
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/step.xml">GLSL step man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
 	template <template <typename, precision> class vecType, typename T, precision P>
-	GLM_FUNC_DECL vecType<T, P> step(
-		T const & edge,
-		vecType<T, P> const & x);
+	GLM_FUNC_DECL vecType<T, P> step(T edge, vecType<T, P> const & x);
+
+	/// Returns 0.0 if x < edge, otherwise it returns 1.0.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/step.xml">GLSL step man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template <template <typename, precision> class vecType, typename T, precision P>
+	GLM_FUNC_DECL vecType<T, P> step(vecType<T, P> const & edge, vecType<T, P> const & x);
 
 	/// Returns 0.0 if x <= edge0 and 1.0 if x >= edge1 and
 	/// performs smooth Hermite interpolation between 0 and 1
@@ -309,16 +297,13 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/smoothstep.xml">GLSL smoothstep man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
 	template <typename genType>
-	GLM_FUNC_DECL genType smoothstep(
-		genType const & edge0,
-		genType const & edge1,
-		genType const & x);
+	GLM_FUNC_DECL genType smoothstep(genType edge0, genType edge1, genType x);
 
-	template <typename genType>
-	GLM_FUNC_DECL genType smoothstep(
-		typename genType::value_type const & edge0,
-		typename genType::value_type const & edge1,
-		genType const & x);
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> smoothstep(T edge0, T edge1, vecType<T, P> const & x);
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> smoothstep(vecType<T, P> const & edge0, vecType<T, P> const & edge1, vecType<T, P> const & x);
 
 	/// Returns true if x holds a NaN (not a number)
 	/// representation in the underlying implementation's set of
@@ -332,8 +317,8 @@ namespace glm
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/isnan.xml">GLSL isnan man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename genType> 
-	GLM_FUNC_DECL typename genType::bool_type isnan(genType const & x);
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<bool, P> isnan(vecType<T, P> const & x);
 
 	/// Returns true if x holds a positive infinity or negative
 	/// infinity representation in the underlying implementation's
@@ -345,8 +330,8 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/isinf.xml">GLSL isinf man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename genType> 
-	GLM_FUNC_DECL typename genType::bool_type isinf(genType const & x);
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<bool, P> isinf(vecType<T, P> const & x);
 
 	/// Returns a signed integer value representing
 	/// the encoding of a floating-point value. The floating-point
@@ -469,4 +454,3 @@ namespace glm
 
 #include "func_common.inl"
 
-#endif//GLM_FUNC_COMMON_INCLUDED

common/glm/glm/detail/func_exponential.hpp

@@ -12,6 +12,10 @@
 /// The above copyright notice and this permission notice shall be included in
 /// all copies or substantial portions of the Software.
 /// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
 /// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 /// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 /// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
@@ -21,7 +25,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/func_exponential.hpp
+/// @file glm/detail/func_exponential.hpp
 /// @date 2008-08-08 / 2011-06-14
 /// @author Christophe Riccio
 /// 
@@ -33,8 +37,7 @@
 /// These all operate component-wise. The description is per component.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef glm_core_func_exponential
-#define glm_core_func_exponential
+#pragma once
 
 #include "type_vec1.hpp"
 #include "type_vec2.hpp"
@@ -49,84 +52,81 @@ namespace glm
 
 	/// Returns 'base' raised to the power 'exponent'. 
 	///
-	/// @param base Floating point value. pow function is defined for input values of x defined in the range (inf-, inf+) in the limit of the type precision.
+	/// @param base Floating point value. pow function is defined for input values of 'base' defined in the range (inf-, inf+) in the limit of the type precision.
 	/// @param exponent Floating point value representing the 'exponent'.
 	/// @tparam genType Floating-point scalar or vector types.
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/pow.xml">GLSL pow man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
-	template <typename genType> 
-	GLM_FUNC_DECL genType pow(genType const & base, genType const & exponent);
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> pow(vecType<T, P> const & base, vecType<T, P> const & exponent);
 
 	/// Returns the natural exponentiation of x, i.e., e^x.
 	///
-	/// @param x exp function is defined for input values of x defined in the range (inf-, inf+) in the limit of the type precision.
+	/// @param v exp function is defined for input values of v defined in the range (inf-, inf+) in the limit of the type precision.
 	/// @tparam genType Floating-point scalar or vector types.
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/exp.xml">GLSL exp man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
-	template <typename genType> 
-	GLM_FUNC_DECL genType exp(genType const & x);
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> exp(vecType<T, P> const & v);
 
-	/// Returns the natural logarithm of x, i.e., 
+	/// Returns the natural logarithm of v, i.e., 
 	/// returns the value y which satisfies the equation x = e^y. 
-	/// Results are undefined if x <= 0.
+	/// Results are undefined if v <= 0.
 	///
-	/// @param x log function is defined for input values of x defined in the range (0, inf+) in the limit of the type precision.
+	/// @param v log function is defined for input values of v defined in the range (0, inf+) in the limit of the type precision.
 	/// @tparam genType Floating-point scalar or vector types.
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/log.xml">GLSL log man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
-	template <typename genType> 
-	GLM_FUNC_DECL genType log(genType const & x);
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> log(vecType<T, P> const & v);
 
-	/// Returns 2 raised to the x power.
+	/// Returns 2 raised to the v power.
 	/// 
-	/// @param x exp2 function is defined for input values of x defined in the range (inf-, inf+) in the limit of the type precision.
+	/// @param v exp2 function is defined for input values of v defined in the range (inf-, inf+) in the limit of the type precision.
 	/// @tparam genType Floating-point scalar or vector types.
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/exp2.xml">GLSL exp2 man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
-	template <typename genType> 
-	GLM_FUNC_DECL genType exp2(genType const & x);
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> exp2(vecType<T, P> const & v);
 
 	/// Returns the base 2 log of x, i.e., returns the value y, 
 	/// which satisfies the equation x = 2 ^ y.
 	/// 
-	/// @param x log2 function is defined for input values of x defined in the range (0, inf+) in the limit of the type precision.
+	/// @param v log2 function is defined for input values of v defined in the range (0, inf+) in the limit of the type precision.
 	/// @tparam genType Floating-point scalar or vector types.
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/log2.xml">GLSL log2 man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
-	template <typename genType>
-	GLM_FUNC_DECL genType log2(genType x);
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> log2(vecType<T, P> const & v);
 
-	/// Returns the positive square root of x.
+	/// Returns the positive square root of v.
 	/// 
-	/// @param x sqrt function is defined for input values of x defined in the range [0, inf+) in the limit of the type precision.
+	/// @param v sqrt function is defined for input values of v defined in the range [0, inf+) in the limit of the type precision.
 	/// @tparam genType Floating-point scalar or vector types.
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/sqrt.xml">GLSL sqrt man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
 	//template <typename genType>
 	//GLM_FUNC_DECL genType sqrt(genType const & x);
-
 	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> sqrt(vecType<T, P> const & x);
+	GLM_FUNC_DECL vecType<T, P> sqrt(vecType<T, P> const & v);
 	
-	/// Returns the reciprocal of the positive square root of x.
+	/// Returns the reciprocal of the positive square root of v.
 	/// 
-	/// @param x inversesqrt function is defined for input values of x defined in the range [0, inf+) in the limit of the type precision.
+	/// @param v inversesqrt function is defined for input values of v defined in the range [0, inf+) in the limit of the type precision.
 	/// @tparam genType Floating-point scalar or vector types.
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/inversesqrt.xml">GLSL inversesqrt man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
-	template <typename genType> 
-	GLM_FUNC_DECL genType inversesqrt(genType const & x);
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> inversesqrt(vecType<T, P> const & v);
 
 	/// @}
 }//namespace glm
 
 #include "func_exponential.inl"
-
-#endif//glm_core_func_exponential

common/glm/glm/detail/func_exponential.inl

@@ -12,6 +12,10 @@
 /// The above copyright notice and this permission notice shall be included in
 /// all copies or substantial portions of the Software.
 /// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
 /// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 /// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 /// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
@@ -21,7 +25,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/func_exponential.inl
+/// @file glm/detail/func_exponential.inl
 /// @date 2008-08-03 / 2011-06-15
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
@@ -29,25 +33,28 @@
 #include "func_vector_relational.hpp"
 #include "_vectorize.hpp"
 #include <limits>
+#include <cmath>
 #include <cassert>
 
 namespace glm{
 namespace detail
 {
-	template <bool isFloat>
+#	if GLM_HAS_CXX11_STL
+		using std::log2;
+#	else
+		template <typename genType>
+		genType log2(genType Value)
+		{
+			return std::log(Value) * static_cast<genType>(1.4426950408889634073599246810019);
+		}
+#	endif
+
+	template <typename T, precision P, template <class, precision> class vecType, bool isFloat = true>
 	struct compute_log2
 	{
-		template <typename T>
-		T operator() (T const & Value) const;
-	};
-
-	template <>
-	struct compute_log2<true>
-	{
-		template <typename T>
-		GLM_FUNC_QUALIFIER T operator() (T const & Value) const
+		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & vec)
 		{
-			return static_cast<T>(::std::log(Value)) * static_cast<T>(1.4426950408889634073599246810019);
+			return detail::functor1<T, T, P, vecType>::call(log2, vec);
 		}
 	};
 
@@ -78,170 +85,77 @@ namespace detail
 }//namespace detail
 
 	// pow
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType pow
-	(
-		genType const & x, 
-		genType const & y
-	)
+	using std::pow;
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> pow(vecType<T, P> const & base, vecType<T, P> const & exponent)
 	{
-		GLM_STATIC_ASSERT(
-			std::numeric_limits<genType>::is_iec559,
-			"'pow' only accept floating-point inputs");
-
-		return std::pow(x, y);
+		return detail::functor2<T, P, vecType>::call(pow, base, exponent);
 	}
 
-	VECTORIZE_VEC_VEC(pow)
-
 	// exp
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType exp
-	(
-		genType const & x
-	)
+	using std::exp;
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> exp(vecType<T, P> const & x)
 	{
-		GLM_STATIC_ASSERT(
-			std::numeric_limits<genType>::is_iec559,
-			"'exp' only accept floating-point inputs");
-
-		return std::exp(x);
+		return detail::functor1<T, T, P, vecType>::call(exp, x);
 	}
 
-	VECTORIZE_VEC(exp)
-
 	// log
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType log
-	(
-		genType const & x
-	)
+	using std::log;
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> log(vecType<T, P> const & x)
 	{
-		GLM_STATIC_ASSERT(
-			std::numeric_limits<genType>::is_iec559,
-			"'log' only accept floating-point inputs");
-
-		return std::log(x);
+		return detail::functor1<T, T, P, vecType>::call(log, x);
 	}
 
-	VECTORIZE_VEC(log)
-
 	//exp2, ln2 = 0.69314718055994530941723212145818f
 	template <typename genType>
-	GLM_FUNC_QUALIFIER genType exp2(genType const & x)
+	GLM_FUNC_QUALIFIER genType exp2(genType x)
 	{
-		GLM_STATIC_ASSERT(
-			std::numeric_limits<genType>::is_iec559,
-			"'exp2' only accept floating-point inputs");
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'exp2' only accept floating-point inputs");
 
 		return std::exp(static_cast<genType>(0.69314718055994530941723212145818) * x);
 	}
 
-	VECTORIZE_VEC(exp2)
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> exp2(vecType<T, P> const & x)
+	{
+		return detail::functor1<T, T, P, vecType>::call(exp2, x);
+	}
 
 	// log2, ln2 = 0.69314718055994530941723212145818f
 	template <typename genType>
 	GLM_FUNC_QUALIFIER genType log2(genType x)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || std::numeric_limits<genType>::is_integer,
-			"GLM core 'log2' only accept floating-point inputs. Include <glm/gtx/integer.hpp> for additional integer support.");
-
-		assert(x > genType(0)); // log2 is only defined on the range (0, inf]
-		return detail::compute_log2<std::numeric_limits<genType>::is_iec559>()(x);
+		return log2(tvec1<genType>(x)).x;
 	}
 
-	VECTORIZE_VEC(log2)
-
-	namespace detail
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> log2(vecType<T, P> const & x)
 	{
-		template <template <class, precision> class vecType, typename T, precision P>
-		struct compute_sqrt{};
-		
-		template <typename T, precision P>
-		struct compute_sqrt<detail::tvec1, T, P>
-		{
-			GLM_FUNC_QUALIFIER static detail::tvec1<T, P> call(detail::tvec1<T, P> const & x)
-			{
-				return detail::tvec1<T, P>(std::sqrt(x.x));
-			}
-		};
-		
-		template <typename T, precision P>
-		struct compute_sqrt<detail::tvec2, T, P>
-		{
-			GLM_FUNC_QUALIFIER static detail::tvec2<T, P> call(detail::tvec2<T, P> const & x)
-			{
-				return detail::tvec2<T, P>(std::sqrt(x.x), std::sqrt(x.y));
-			}
-		};
-		
-		template <typename T, precision P>
-		struct compute_sqrt<detail::tvec3, T, P>
-		{
-			GLM_FUNC_QUALIFIER static detail::tvec3<T, P> call(detail::tvec3<T, P> const & x)
-			{
-				return detail::tvec3<T, P>(std::sqrt(x.x), std::sqrt(x.y), std::sqrt(x.z));
-			}
-		};
-		
-		template <typename T, precision P>
-		struct compute_sqrt<detail::tvec4, T, P>
-		{
-			GLM_FUNC_QUALIFIER static detail::tvec4<T, P> call(detail::tvec4<T, P> const & x)
-			{
-				return detail::tvec4<T, P>(std::sqrt(x.x), std::sqrt(x.y), std::sqrt(x.z), std::sqrt(x.w));
-			}
-		};
-	}//namespace detail
-	
+		return detail::compute_log2<T, P, vecType, std::numeric_limits<T>::is_iec559>::call(x);
+	}
+
 	// sqrt
-	GLM_FUNC_QUALIFIER float sqrt(float x)
-	{
-#		ifdef __CUDACC__ // Wordaround for a CUDA compiler bug up to CUDA6
-			detail::tvec1<float, highp> tmp(detail::compute_sqrt<detail::tvec1, float, highp>::call(x));
-			return tmp.x;
-#		else
-			return detail::compute_sqrt<detail::tvec1, float, highp>::call(x).x;
-#		endif
-	}
-
-	GLM_FUNC_QUALIFIER double sqrt(double x)
-	{
-#		ifdef __CUDACC__ // Wordaround for a CUDA compiler bug up to CUDA6
-			detail::tvec1<double, highp> tmp(detail::compute_sqrt<detail::tvec1, double, highp>::call(x));
-			return tmp.x;
-#		else
-			return detail::compute_sqrt<detail::tvec1, double, highp>::call(x).x;
-#		endif
-	}
-		
+	using std::sqrt;
 	template <typename T, precision P, template <typename, precision> class vecType>
 	GLM_FUNC_QUALIFIER vecType<T, P> sqrt(vecType<T, P> const & x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'sqrt' only accept floating-point inputs");
-		return detail::compute_sqrt<vecType, T, P>::call(x);
+		return detail::functor1<T, T, P, vecType>::call(sqrt, x);
 	}
 
 	// inversesqrt
-	GLM_FUNC_QUALIFIER float inversesqrt(float const & x)
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType inversesqrt(genType x)
 	{
-		return 1.0f / sqrt(x);
+		return static_cast<genType>(1) / sqrt(x);
 	}
 	
-	GLM_FUNC_QUALIFIER double inversesqrt(double const & x)
-	{
-		return 1.0 / sqrt(x);
-	}
-	
-	template <template <class, precision> class vecType, typename T, precision P>
-	GLM_FUNC_QUALIFIER vecType<T, P> inversesqrt
-	(
-		vecType<T, P> const & x
-	)
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> inversesqrt(vecType<T, P> const & x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'inversesqrt' only accept floating-point inputs");
 		return detail::compute_inversesqrt<vecType, T, P>::call(x);
 	}
-
-	VECTORIZE_VEC(inversesqrt)
 }//namespace glm

common/glm/glm/detail/func_geometric.hpp

@@ -12,6 +12,10 @@
 /// The above copyright notice and this permission notice shall be included in
 /// all copies or substantial portions of the Software.
 /// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
 /// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 /// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 /// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
@@ -21,7 +25,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/func_geometric.hpp
+/// @file glm/detail/func_geometric.hpp
 /// @date 2008-08-03 / 2011-06-14
 /// @author Christophe Riccio
 ///
@@ -33,8 +37,7 @@
 /// These operate on vectors as vectors, not component-wise.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef glm_core_func_geometric
-#define glm_core_func_geometric
+#pragma once
 
 #include "type_vec3.hpp"
 
@@ -49,9 +52,9 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/length.xml">GLSL length man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
-	template <typename genType> 
-	GLM_FUNC_DECL typename genType::value_type length(
-		genType const & x); 
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL T length(
+		vecType<T, P> const & x);
 
 	/// Returns the distance betwwen p0 and p1, i.e., length(p0 - p1).
 	///
@@ -59,10 +62,10 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/distance.xml">GLSL distance man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
-	template <typename genType> 
-	GLM_FUNC_DECL typename genType::value_type distance(
-		genType const & p0, 
-		genType const & p1);
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL T distance(
+		vecType<T, P> const & p0,
+		vecType<T, P> const & p1);
 
 	/// Returns the dot product of x and y, i.e., result = x * y.
 	///
@@ -75,17 +78,6 @@ namespace glm
 		vecType<T, P> const & x,
 		vecType<T, P> const & y);
 
-	/// Returns the dot product of x and y, i.e., result = x * y.
-	///
-	/// @tparam genType Floating-point vector types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/dot.xml">GLSL dot man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
-	template <typename genType>
-	GLM_FUNC_DECL genType dot(
-		genType const & x,
-		genType const & y);
-
 	/// Returns the cross product of x and y.
 	///
 	/// @tparam valType Floating-point scalar types.
@@ -93,17 +85,18 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/cross.xml">GLSL cross man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tvec3<T, P> cross(
-		detail::tvec3<T, P> const & x,
-		detail::tvec3<T, P> const & y);
+	GLM_FUNC_DECL tvec3<T, P> cross(
+		tvec3<T, P> const & x,
+		tvec3<T, P> const & y);
 
 	/// Returns a vector in the same direction as x but with length of 1.
+	/// According to issue 10 GLSL 1.10 specification, if length(x) == 0 then result is undefined and generate an error.
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/normalize.xml">GLSL normalize man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
-	template <typename genType>
-	GLM_FUNC_DECL genType normalize(
-		genType const & x);
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> normalize(
+		vecType<T, P> const & x);
 
 	/// If dot(Nref, I) < 0.0, return N, otherwise, return -N.
 	///
@@ -141,11 +134,9 @@ namespace glm
 	GLM_FUNC_DECL vecType<T, P> refract(
 		vecType<T, P> const & I,
 		vecType<T, P> const & N,
-		T const & eta);
+		T eta);
 
 	/// @}
 }//namespace glm
 
 #include "func_geometric.inl"
-
-#endif//glm_core_func_geometric

common/glm/glm/detail/func_geometric.inl

@@ -12,6 +12,10 @@
 /// The above copyright notice and this permission notice shall be included in
 /// all copies or substantial portions of the Software.
 /// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
 /// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 /// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 /// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
@@ -21,7 +25,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/func_geometric.inl
+/// @file glm/detail/func_geometric.inl
 /// @date 2008-08-03 / 2011-06-15
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
@@ -39,45 +43,40 @@ namespace detail
 	struct compute_dot{};
 
 	template <typename T, precision P>
-	struct compute_dot<detail::tvec1, T, P>
+	struct compute_dot<tvec1, T, P>
 	{
-		GLM_FUNC_QUALIFIER static T call(detail::tvec1<T, P> const & x, detail::tvec1<T, P> const & y)
+		GLM_FUNC_QUALIFIER static T call(tvec1<T, P> const & a, tvec1<T, P> const & b)
 		{
-#			ifdef __CUDACC__ // Wordaround for a CUDA compiler bug up to CUDA6
-				detail::tvec1<T, P> tmp(x * y);
-				return tmp.x;
-#			else
-				return detail::tvec1<T, P>(x * y).x;
-#			endif
+			return a.x * b.x;
 		}
 	};
 
 	template <typename T, precision P>
-	struct compute_dot<detail::tvec2, T, P>
+	struct compute_dot<tvec2, T, P>
 	{
-		GLM_FUNC_QUALIFIER static T call(detail::tvec2<T, P> const & x, detail::tvec2<T, P> const & y)
+		GLM_FUNC_QUALIFIER static T call(tvec2<T, P> const & x, tvec2<T, P> const & y)
 		{
-			detail::tvec2<T, P> tmp(x * y);
+			tvec2<T, P> tmp(x * y);
 			return tmp.x + tmp.y;
 		}
 	};
 
 	template <typename T, precision P>
-	struct compute_dot<detail::tvec3, T, P>
+	struct compute_dot<tvec3, T, P>
 	{
-		GLM_FUNC_QUALIFIER static T call(detail::tvec3<T, P> const & x, detail::tvec3<T, P> const & y)
+		GLM_FUNC_QUALIFIER static T call(tvec3<T, P> const & x, tvec3<T, P> const & y)
 		{
-			detail::tvec3<T, P> tmp(x * y);
+			tvec3<T, P> tmp(x * y);
 			return tmp.x + tmp.y + tmp.z;
 		}
 	};
 
 	template <typename T, precision P>
-	struct compute_dot<detail::tvec4, T, P>
+	struct compute_dot<tvec4, T, P>
 	{
-		GLM_FUNC_QUALIFIER static T call(detail::tvec4<T, P> const & x, detail::tvec4<T, P> const & y)
+		GLM_FUNC_QUALIFIER static T call(tvec4<T, P> const & x, tvec4<T, P> const & y)
 		{
-			detail::tvec4<T, P> tmp(x * y);
+			tvec4<T, P> tmp(x * y);
 			return (tmp.x + tmp.y) + (tmp.z + tmp.w);
 		}
 	};
@@ -85,144 +84,58 @@ namespace detail
 
 	// length
 	template <typename genType>
-	GLM_FUNC_QUALIFIER genType length
-	(
-		genType const & x
-	)
+	GLM_FUNC_QUALIFIER genType length(genType x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'length' only accept floating-point inputs");
 
-		genType sqr = x * x;
-		return sqrt(sqr);
+		return abs(x);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER T length(detail::tvec2<T, P> const & v)
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER T length(vecType<T, P> const & v)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'length' only accept floating-point inputs");
 
-		T sqr = v.x * v.x + v.y * v.y;
-		return sqrt(sqr);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER T length(detail::tvec3<T, P> const & v)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'length' only accept floating-point inputs");
-
-		T sqr = v.x * v.x + v.y * v.y + v.z * v.z;
-		return sqrt(sqr);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER T length(detail::tvec4<T, P> const & v)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'length' only accept floating-point inputs");
-
-		T sqr = v.x * v.x + v.y * v.y + v.z * v.z + v.w * v.w;
-		return sqrt(sqr);
+		return sqrt(dot(v, v));
 	}
 
 	// distance
 	template <typename genType>
-	GLM_FUNC_QUALIFIER genType distance
-	(
-		genType const & p0,
-		genType const & p1
-	)
+	GLM_FUNC_QUALIFIER genType distance(genType const & p0, genType const & p1)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'distance' only accept floating-point inputs");
 
 		return length(p1 - p0);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER T distance
-	(
-		detail::tvec2<T, P> const & p0,
-		detail::tvec2<T, P> const & p1
-	)
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER T distance(vecType<T, P> const & p0, vecType<T, P> const & p1)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'distance' only accept floating-point inputs");
-
-		return length(p1 - p0);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER T distance
-	(
-		detail::tvec3<T, P> const & p0,
-		detail::tvec3<T, P> const & p1
-	)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'distance' only accept floating-point inputs");
-
-		return length(p1 - p0);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER T distance
-	(
-		detail::tvec4<T, P> const & p0,
-		detail::tvec4<T, P> const & p1
-	)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'distance' only accept floating-point inputs");
-
 		return length(p1 - p0);
 	}
 
 	// dot
 	template <typename T>
-	GLM_FUNC_QUALIFIER T dot
-	(
-		T const & x,
-		T const & y
-	)
+	GLM_FUNC_QUALIFIER T dot(T x, T y)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'dot' only accept floating-point inputs");
-		return detail::compute_dot<detail::tvec1, T, highp>::call(x, y);
+		return x * y;
 	}
 
 	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER T dot
-	(
-		vecType<T, P> const & x,
-		vecType<T, P> const & y
-	)
+	GLM_FUNC_QUALIFIER T dot(vecType<T, P> const & x, vecType<T, P> const & y)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'dot' only accept floating-point inputs");
 		return detail::compute_dot<vecType, T, P>::call(x, y);
 	}
 
-/* // SSE3
-	GLM_FUNC_QUALIFIER float dot(const tvec4<float>& x, const tvec4<float>& y)
-	{
-		float Result;
-		__asm
-		{
-			mov		esi, x
-			mov		edi, y
-			movaps	xmm0, [esi]
-			mulps	xmm0, [edi]
-			haddps(	_xmm0, _xmm0 )
-			haddps(	_xmm0, _xmm0 )
-			movss	Result, xmm0
-		}
-		return Result;
-	}
-*/
 	// cross
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> cross
-	(
-		detail::tvec3<T, P> const & x,
-		detail::tvec3<T, P> const & y
-	)
+	GLM_FUNC_QUALIFIER tvec3<T, P> cross(tvec3<T, P> const & x, tvec3<T, P> const & y)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'cross' only accept floating-point inputs");
 
-		return detail::tvec3<T, P>(
+		return tvec3<T, P>(
 			x.y * y.z - y.y * x.z,
 			x.z * y.x - y.z * x.x,
 			x.x * y.y - y.x * x.y);
@@ -230,111 +143,53 @@ namespace detail
 
 	// normalize
 	template <typename genType>
-	GLM_FUNC_QUALIFIER genType normalize
-	(
-		genType const & x
-	)
+	GLM_FUNC_QUALIFIER genType normalize(genType const & x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'normalize' only accept floating-point inputs");
 
 		return x < genType(0) ? genType(-1) : genType(1);
 	}
 
-	// According to issue 10 GLSL 1.10 specification, if length(x) == 0 then result is undefine and generate an error
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec2<T, P> normalize
-	(
-		detail::tvec2<T, P> const & x
-	)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'normalize' only accept floating-point inputs");
-		
-		T sqr = x.x * x.x + x.y * x.y;
-		return x * inversesqrt(sqr);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> normalize
-	(
-		detail::tvec3<T, P> const & x
-	)
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> normalize(vecType<T, P> const & x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'normalize' only accept floating-point inputs");
 
-		T sqr = x.x * x.x + x.y * x.y + x.z * x.z;
-		return x * inversesqrt(sqr);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<T, P> normalize
-	(
-		detail::tvec4<T, P> const & x
-	)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'normalize' only accept floating-point inputs");
-		
-		T sqr = x.x * x.x + x.y * x.y + x.z * x.z + x.w * x.w;
-		return x * inversesqrt(sqr);
+		return x * inversesqrt(dot(x, x));
 	}
 
 	// faceforward
 	template <typename genType>
-	GLM_FUNC_QUALIFIER genType faceforward
-	(
-		genType const & N,
-		genType const & I,
-		genType const & Nref
-	)
+	GLM_FUNC_QUALIFIER genType faceforward(genType const & N, genType const & I, genType const & Nref)
 	{
-		return dot(Nref, I) < 0 ? N : -N;
+		return dot(Nref, I) < static_cast<genType>(0) ? N : -N;
 	}
 
 	// reflect
 	template <typename genType>
-	GLM_FUNC_QUALIFIER genType reflect
-	(
-		genType const & I,
-		genType const & N
-	)
+	GLM_FUNC_QUALIFIER genType reflect(genType const & I, genType const & N)
 	{
-		return I - N * dot(N, I) * genType(2);
+		return I - N * dot(N, I) * static_cast<genType>(2);
 	}
 
 	// refract
 	template <typename genType>
-	GLM_FUNC_QUALIFIER genType refract
-	(
-		genType const & I,
-		genType const & N,
-		genType const & eta
-	)
+	GLM_FUNC_QUALIFIER genType refract(genType const & I, genType const & N, genType const & eta)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'refract' only accept floating-point inputs");
 
-		genType dotValue = dot(N, I);
-		genType k = genType(1) - eta * eta * (genType(1) - dotValue * dotValue);
-		if(k < genType(0))
-			return genType(0);
-		else
-			return eta * I - (eta * dotValue + sqrt(k)) * N;
+		genType const dotValue(dot(N, I));
+		genType const k(static_cast<genType>(1) - eta * eta * (static_cast<genType>(1) - dotValue * dotValue));
+		return (eta * I - (eta * dotValue + sqrt(k)) * N) * static_cast<genType>(k >= static_cast<genType>(0));
 	}
 
 	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> refract
-	(
-		vecType<T, P> const & I,
-		vecType<T, P> const & N,
-		T const & eta
-	)
+	GLM_FUNC_QUALIFIER vecType<T, P> refract(vecType<T, P> const & I, vecType<T, P> const & N, T eta)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'refract' only accept floating-point inputs");
 
-		T dotValue = dot(N, I);
-		T k = T(1) - eta * eta * (T(1) - dotValue * dotValue);
-		if(k < T(0))
-			return vecType<T, P>(0);
-		else
-			return eta * I - (eta * dotValue + std::sqrt(k)) * N;
+		T const dotValue(dot(N, I));
+		T const k(static_cast<T>(1) - eta * eta * (static_cast<T>(1) - dotValue * dotValue));
+		return (eta * I - (eta * dotValue + std::sqrt(k)) * N) * static_cast<T>(k >= static_cast<T>(0));
 	}
-
 }//namespace glm

common/glm/glm/detail/func_integer.hpp

@@ -12,6 +12,10 @@
 /// The above copyright notice and this permission notice shall be included in
 /// all copies or substantial portions of the Software.
 /// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
 /// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 /// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 /// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
@@ -21,7 +25,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/func_integer.hpp
+/// @file glm/detail/func_integer.hpp
 /// @date 2010-03-17 / 2011-06-18
 /// @author Christophe Riccio
 ///
@@ -35,10 +39,12 @@
 /// b, inclusive. The lowest-order bit is bit 0.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef glm_core_func_integer
-#define glm_core_func_integer
+#pragma once
 
 #include "setup.hpp"
+#include "precision.hpp"
+#include "func_common.hpp"
+#include "func_vector_relational.hpp"
 
 namespace glm
 {
@@ -53,11 +59,11 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/uaddCarry.xml">GLSL uaddCarry man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
-	template <typename genUType>
-	GLM_FUNC_DECL genUType uaddCarry(
-		genUType const & x,
-		genUType const & y,
-		genUType & carry);
+	template <precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<uint, P> uaddCarry(
+		vecType<uint, P> const & x,
+		vecType<uint, P> const & y,
+		vecType<uint, P> & carry);
 
 	/// Subtracts the 32-bit unsigned integer y from x, returning
 	/// the difference if non-negative, or pow(2, 32) plus the difference
@@ -67,12 +73,12 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/usubBorrow.xml">GLSL usubBorrow man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
-	template <typename genUType>
-	GLM_FUNC_DECL genUType usubBorrow(
-		genUType const & x,
-		genUType const & y,
-		genUType & borrow);
-		
+	template <precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<uint, P> usubBorrow(
+		vecType<uint, P> const & x,
+		vecType<uint, P> const & y,
+		vecType<uint, P> & borrow);
+
 	/// Multiplies 32-bit integers x and y, producing a 64-bit
 	/// result. The 32 least-significant bits are returned in lsb.
 	/// The 32 most-significant bits are returned in msb.
@@ -81,12 +87,12 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/umulExtended.xml">GLSL umulExtended man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
-	template <typename genUType>
+	template <precision P, template <typename, precision> class vecType>
 	GLM_FUNC_DECL void umulExtended(
-		genUType const & x,
-		genUType const & y,
-		genUType & msb,
-		genUType & lsb);
+		vecType<uint, P> const & x,
+		vecType<uint, P> const & y,
+		vecType<uint, P> & msb,
+		vecType<uint, P> & lsb);
 		
 	/// Multiplies 32-bit integers x and y, producing a 64-bit
 	/// result. The 32 least-significant bits are returned in lsb.
@@ -96,12 +102,12 @@ namespace glm
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/imulExtended.xml">GLSL imulExtended man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
-	template <typename genIType>
+	template <precision P, template <typename, precision> class vecType>
 	GLM_FUNC_DECL void imulExtended(
-		genIType const & x,
-		genIType const & y,
-		genIType & msb,
-		genIType & lsb);
+		vecType<int, P> const & x,
+		vecType<int, P> const & y,
+		vecType<int, P> & msb,
+		vecType<int, P> & lsb);
 
 	/// Extracts bits [offset, offset + bits - 1] from value,
 	/// returning them in the least significant bits of the result.
@@ -114,15 +120,15 @@ namespace glm
 	/// offset and bits is greater than the number of bits used
 	/// to store the operand.
 	///
-	/// @tparam genIUType Signed or unsigned integer scalar or vector types.
+	/// @tparam T Signed or unsigned integer scalar or vector types.
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitfieldExtract.xml">GLSL bitfieldExtract man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
-	template <typename genIUType>
-	GLM_FUNC_DECL genIUType bitfieldExtract(
-		genIUType const & Value,
-		int const & Offset,
-		int const & Bits);
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> bitfieldExtract(
+		vecType<T, P> const & Value,
+		int Offset,
+		int Bits);
 
 	/// Returns the insertion the bits least-significant bits of insert into base.
 	///
@@ -134,70 +140,93 @@ namespace glm
 	/// offset and bits is greater than the number of bits used to
 	/// store the operand.
 	///
-	/// @tparam genIUType Signed or unsigned integer scalar or vector types.
+	/// @tparam T Signed or unsigned integer scalar or vector types.
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitfieldInsert.xml">GLSL bitfieldInsert man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
-	template <typename genIUType>
-	GLM_FUNC_DECL genIUType bitfieldInsert(
-		genIUType const & Base,
-		genIUType const & Insert,
-		int const & Offset,
-		int const & Bits);
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> bitfieldInsert(
+		vecType<T, P> const & Base,
+		vecType<T, P> const & Insert,
+		int Offset,
+		int Bits);
 
 	/// Returns the reversal of the bits of value. 
 	/// The bit numbered n of the result will be taken from bit (bits - 1) - n of value, 
 	/// where bits is the total number of bits used to represent value.
 	///
-	/// @tparam genIUType Signed or unsigned integer scalar or vector types.
+	/// @tparam T Signed or unsigned integer scalar or vector types.
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitfieldReverse.xml">GLSL bitfieldReverse man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
-	template <typename genIUType>
-	GLM_FUNC_DECL genIUType bitfieldReverse(genIUType const & Value);
-		
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> bitfieldReverse(vecType<T, P> const & v);
+
 	/// Returns the number of bits set to 1 in the binary representation of value.
 	///
-	/// @tparam genIUType Signed or unsigned integer scalar or vector types.
+	/// @tparam T Signed or unsigned integer scalar or vector types.
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitCount.xml">GLSL bitCount man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	template <typename genType>
+	GLM_FUNC_DECL int bitCount(genType v);
+
+	/// Returns the number of bits set to 1 in the binary representation of value.
 	///
-	/// @todo Clarify the declaration to specify that scalars are suported.
-	template <typename T, template <typename> class genIUType>
-	GLM_FUNC_DECL typename genIUType<T>::signed_type bitCount(genIUType<T> const & Value);
+	/// @tparam T Signed or unsigned integer scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitCount.xml">GLSL bitCount man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<int, P> bitCount(vecType<T, P> const & v);
 
 	/// Returns the bit number of the least significant bit set to
 	/// 1 in the binary representation of value. 
 	/// If value is zero, -1 will be returned.
 	///
-	/// @tparam genIUType Signed or unsigned integer scalar or vector types.
+	/// @tparam T Signed or unsigned integer scalar types.
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/findLSB.xml">GLSL findLSB man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	template <typename genIUType>
+	GLM_FUNC_DECL int findLSB(genIUType x);
+
+	/// Returns the bit number of the least significant bit set to
+	/// 1 in the binary representation of value. 
+	/// If value is zero, -1 will be returned.
 	///
-	/// @todo Clarify the declaration to specify that scalars are suported.
-	template <typename T, template <typename> class genIUType>
-	GLM_FUNC_DECL typename genIUType<T>::signed_type findLSB(genIUType<T> const & Value);
+	/// @tparam T Signed or unsigned integer scalar types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/findLSB.xml">GLSL findLSB man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<int, P> findLSB(vecType<T, P> const & v);
 
 	/// Returns the bit number of the most significant bit in the binary representation of value.
 	/// For positive integers, the result will be the bit number of the most significant bit set to 1. 
 	/// For negative integers, the result will be the bit number of the most significant
 	/// bit set to 0. For a value of zero or negative one, -1 will be returned.
 	///
-	/// @tparam genIUType Signed or unsigned integer scalar or vector types.
+	/// @tparam T Signed or unsigned integer scalar types.
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/findMSB.xml">GLSL findMSB man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	template <typename genIUType>
+	GLM_FUNC_DECL int findMSB(genIUType x);
+
+	/// Returns the bit number of the most significant bit in the binary representation of value.
+	/// For positive integers, the result will be the bit number of the most significant bit set to 1. 
+	/// For negative integers, the result will be the bit number of the most significant
+	/// bit set to 0. For a value of zero or negative one, -1 will be returned.
 	///
-	/// @todo Clarify the declaration to specify that scalars are suported.
-	template <typename T, template <typename> class genIUType>
-	GLM_FUNC_DECL typename genIUType<T>::signed_type findMSB(genIUType<T> const & Value);
+	/// @tparam T Signed or unsigned integer scalar types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/findMSB.xml">GLSL findMSB man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<int, P> findMSB(vecType<T, P> const & v);
 
 	/// @}
 }//namespace glm
 
 #include "func_integer.inl"
-
-#endif//glm_core_func_integer
-

common/glm/glm/detail/func_integer.inl

@@ -12,6 +12,10 @@
 /// The above copyright notice and this permission notice shall be included in
 /// all copies or substantial portions of the Software.
 /// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
 /// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 /// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 /// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
@@ -21,7 +25,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/func_integer.inl
+/// @file glm/detail/func_integer.inl
 /// @date 2010-03-17 / 2011-06-15
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
@@ -39,73 +43,186 @@
 #endif//(GLM_ARCH != GLM_ARCH_PURE)
 #include <limits>
 
-namespace glm
+namespace glm{
+namespace detail
 {
+	template <typename T>
+	GLM_FUNC_QUALIFIER T mask(T Bits)
+	{
+		return Bits >= sizeof(T) * 8 ? ~static_cast<T>(0) : (static_cast<T>(1) << Bits) - static_cast<T>(1);
+	}
+
+	template <bool EXEC = false>
+	struct compute_bitfieldReverseStep
+	{
+		template <typename T, glm::precision P, template <class, glm::precision> class vecType>
+		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & v, T, T)
+		{
+			return v;
+		}
+	};
+
+	template <>
+	struct compute_bitfieldReverseStep<true>
+	{
+		template <typename T, glm::precision P, template <class, glm::precision> class vecType>
+		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & v, T Mask, T Shift)
+		{
+			return (v & Mask) << Shift | (v & (~Mask)) >> Shift;
+		}
+	};
+
+	template <bool EXEC = false>
+	struct compute_bitfieldBitCountStep
+	{
+		template <typename T, glm::precision P, template <class, glm::precision> class vecType>
+		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & v, T, T)
+		{
+			return v;
+		}
+	};
+
+	template <>
+	struct compute_bitfieldBitCountStep<true>
+	{
+		template <typename T, glm::precision P, template <class, glm::precision> class vecType>
+		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & v, T Mask, T Shift)
+		{
+			return (v & Mask) + ((v >> Shift) & Mask);
+		}
+	};
+
+	template <typename genIUType, size_t Bits>
+	struct compute_findLSB
+	{
+		GLM_FUNC_QUALIFIER static int call(genIUType Value)
+		{
+			if(Value == 0)
+				return -1;
+
+			return glm::bitCount(~Value & (Value - static_cast<genIUType>(1)));
+		}
+	};
+
+#	if GLM_HAS_BITSCAN_WINDOWS
+		template <typename genIUType>
+		struct compute_findLSB<genIUType, 32>
+		{
+			GLM_FUNC_QUALIFIER static int call(genIUType Value)
+			{
+				unsigned long Result(0);
+				unsigned char IsNotNull = _BitScanForward(&Result, *reinterpret_cast<unsigned long*>(&Value));
+				return IsNotNull ? int(Result) : -1;
+			}
+		};
+
+#		if !((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_MODEL == GLM_MODEL_32))
+		template <typename genIUType>
+		struct compute_findLSB<genIUType, 64>
+		{
+			GLM_FUNC_QUALIFIER static int call(genIUType Value)
+			{
+				unsigned long Result(0);
+				unsigned char IsNotNull = _BitScanForward64(&Result, *reinterpret_cast<unsigned __int64*>(&Value));
+				return IsNotNull ? int(Result) : -1;
+			}
+		};
+#		endif
+#	endif//GLM_HAS_BITSCAN_WINDOWS
+
+	template <typename T, glm::precision P, template <class, glm::precision> class vecType, bool EXEC = true>
+	struct compute_findMSB_step_vec
+	{
+		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x, T Shift)
+		{
+			return x | (x >> Shift);
+		}
+	};
+
+	template <typename T, glm::precision P, template <typename, glm::precision> class vecType>
+	struct compute_findMSB_step_vec<T, P, vecType, false>
+	{
+		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x, T)
+		{
+			return x;
+		}
+	};
+
+	template <typename T, glm::precision P, template <typename, glm::precision> class vecType, int>
+	struct compute_findMSB_vec
+	{
+		GLM_FUNC_QUALIFIER static vecType<int, P> call(vecType<T, P> const & vec)
+		{
+			vecType<T, P> x(vec);
+			x = compute_findMSB_step_vec<T, P, vecType, sizeof(T) * 8 >=  8>::call(x, static_cast<T>( 1));
+			x = compute_findMSB_step_vec<T, P, vecType, sizeof(T) * 8 >=  8>::call(x, static_cast<T>( 2));
+			x = compute_findMSB_step_vec<T, P, vecType, sizeof(T) * 8 >=  8>::call(x, static_cast<T>( 4));
+			x = compute_findMSB_step_vec<T, P, vecType, sizeof(T) * 8 >= 16>::call(x, static_cast<T>( 8));
+			x = compute_findMSB_step_vec<T, P, vecType, sizeof(T) * 8 >= 32>::call(x, static_cast<T>(16));
+			x = compute_findMSB_step_vec<T, P, vecType, sizeof(T) * 8 >= 64>::call(x, static_cast<T>(32));
+			return vecType<int, P>(sizeof(T) * 8 - 1) - glm::bitCount(~x);
+		}
+	};
+
+#	if GLM_HAS_BITSCAN_WINDOWS
+		template <typename genIUType>
+		GLM_FUNC_QUALIFIER int compute_findMSB_32(genIUType Value)
+		{
+			unsigned long Result(0);
+			unsigned char IsNotNull = _BitScanReverse(&Result, *reinterpret_cast<unsigned long*>(&Value));
+			return IsNotNull ? int(Result) : -1;
+		}
+
+		template <typename T, glm::precision P, template <class, glm::precision> class vecType>
+		struct compute_findMSB_vec<T, P, vecType, 32>
+		{
+			GLM_FUNC_QUALIFIER static vecType<int, P> call(vecType<T, P> const & x)
+			{
+				return detail::functor1<int, T, P, vecType>::call(compute_findMSB_32, x);
+			}
+		};
+
+#		if !((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_MODEL == GLM_MODEL_32))
+		template <typename genIUType>
+		GLM_FUNC_QUALIFIER int compute_findMSB_64(genIUType Value)
+		{
+			unsigned long Result(0);
+			unsigned char IsNotNull = _BitScanReverse64(&Result, *reinterpret_cast<unsigned __int64*>(&Value));
+			return IsNotNull ? int(Result) : -1;
+		}
+
+		template <typename T, glm::precision P, template <class, glm::precision> class vecType>
+		struct compute_findMSB_vec<T, P, vecType, 64>
+		{
+			GLM_FUNC_QUALIFIER static vecType<int, P> call(vecType<T, P> const & x)
+			{
+				return detail::functor1<int, T, P, vecType>::call(compute_findMSB_64, x);
+			}
+		};
+#		endif
+#	endif//GLM_HAS_BITSCAN_WINDOWS
+}//namespace detail
+
 	// uaddCarry
-	template <>
-	GLM_FUNC_QUALIFIER uint uaddCarry
-	(
-		uint const & x,
-		uint const & y,
-		uint & Carry
-	)
+	GLM_FUNC_QUALIFIER uint uaddCarry(uint const & x, uint const & y, uint & Carry)
 	{
-		uint64 Value64 = static_cast<uint64>(x) + static_cast<uint64>(y);
-		uint32 Result = static_cast<uint32>(Value64 % (static_cast<uint64>(1) << static_cast<uint64>(32)));
-		Carry = (Value64 % (static_cast<uint64>(1) << static_cast<uint64>(32))) > 1 ? static_cast<uint32>(1) : static_cast<uint32>(0);
-		return Result;
+		uint64 const Value64(static_cast<uint64>(x) + static_cast<uint64>(y));
+		uint64 const Max32((static_cast<uint64>(1) << static_cast<uint64>(32)) - static_cast<uint64>(1));
+		Carry = Value64 > Max32 ? 1 : 0;
+		return static_cast<uint32>(Value64 % (Max32 + static_cast<uint64>(1)));
 	}
 
-	template <>
-	GLM_FUNC_QUALIFIER uvec2 uaddCarry
-	(
-		uvec2 const & x,
-		uvec2 const & y,
-		uvec2 & Carry
-	)
+	template <precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<uint, P> uaddCarry(vecType<uint, P> const & x, vecType<uint, P> const & y, vecType<uint, P> & Carry)
 	{
-		return uvec2(
-			uaddCarry(x[0], y[0], Carry[0]),
-			uaddCarry(x[1], y[1], Carry[1]));
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER uvec3 uaddCarry
-	(
-		uvec3 const & x,
-		uvec3 const & y,
-		uvec3 & Carry
-	)
-	{
-		return uvec3(
-			uaddCarry(x[0], y[0], Carry[0]),
-			uaddCarry(x[1], y[1], Carry[1]),
-			uaddCarry(x[2], y[2], Carry[2]));
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER uvec4 uaddCarry
-	(
-		uvec4 const & x,
-		uvec4 const & y,
-		uvec4 & Carry
-	)
-	{
-		return uvec4(
-			uaddCarry(x[0], y[0], Carry[0]),
-			uaddCarry(x[1], y[1], Carry[1]),
-			uaddCarry(x[2], y[2], Carry[2]),
-			uaddCarry(x[3], y[3], Carry[3]));
+		vecType<uint64, P> Value64(vecType<uint64, P>(x) + vecType<uint64, P>(y));
+		vecType<uint64, P> Max32((static_cast<uint64>(1) << static_cast<uint64>(32)) - static_cast<uint64>(1));
+		Carry = mix(vecType<uint32, P>(0), vecType<uint32, P>(1), greaterThan(Value64, Max32));
+		return vecType<uint32,P>(Value64 % (Max32 + static_cast<uint64>(1)));
 	}
 
 	// usubBorrow
-	template <>
-	GLM_FUNC_QUALIFIER uint usubBorrow
-	(
-		uint const & x,
-		uint const & y,
-		uint & Borrow
-	)
+	GLM_FUNC_QUALIFIER uint usubBorrow(uint const & x, uint const & y, uint & Borrow)
 	{
 		GLM_STATIC_ASSERT(sizeof(uint) == sizeof(uint32), "uint and uint32 size mismatch");
 
@@ -116,57 +233,17 @@ namespace glm
 			return static_cast<uint32>((static_cast<int64>(1) << static_cast<int64>(32)) + (static_cast<int64>(y) - static_cast<int64>(x)));
 	}
 
-	template <>
-	GLM_FUNC_QUALIFIER uvec2 usubBorrow
-	(
-		uvec2 const & x,
-		uvec2 const & y,
-		uvec2 & Borrow
-	)
+	template <precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<uint, P> usubBorrow(vecType<uint, P> const & x, vecType<uint, P> const & y, vecType<uint, P> & Borrow)
 	{
-		return uvec2(
-			usubBorrow(x[0], y[0], Borrow[0]),
-			usubBorrow(x[1], y[1], Borrow[1]));
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER uvec3 usubBorrow
-	(
-		uvec3 const & x,
-		uvec3 const & y,
-		uvec3 & Borrow
-	)
-	{
-		return uvec3(
-			usubBorrow(x[0], y[0], Borrow[0]),
-			usubBorrow(x[1], y[1], Borrow[1]),
-			usubBorrow(x[2], y[2], Borrow[2]));
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER uvec4 usubBorrow
-	(
-		uvec4 const & x,
-		uvec4 const & y,
-		uvec4 & Borrow
-	)
-	{
-		return uvec4(
-			usubBorrow(x[0], y[0], Borrow[0]),
-			usubBorrow(x[1], y[1], Borrow[1]),
-			usubBorrow(x[2], y[2], Borrow[2]),
-			usubBorrow(x[3], y[3], Borrow[3]));
+		Borrow = mix(vecType<uint, P>(1), vecType<uint, P>(0), greaterThanEqual(x, y));
+		vecType<uint, P> const YgeX(y - x);
+		vecType<uint, P> const XgeY(vecType<uint32, P>((static_cast<int64>(1) << static_cast<int64>(32)) + (vecType<int64, P>(y) - vecType<int64, P>(x))));
+		return mix(XgeY, YgeX, greaterThanEqual(y, x));
 	}
 
 	// umulExtended
-	template <>
-	GLM_FUNC_QUALIFIER void umulExtended
-	(
-		uint const & x,
-		uint const & y,
-		uint & msb,
-		uint & lsb
-	)
+	GLM_FUNC_QUALIFIER void umulExtended(uint const & x, uint const & y, uint & msb, uint & lsb)
 	{
 		GLM_STATIC_ASSERT(sizeof(uint) == sizeof(uint32), "uint and uint32 size mismatch");
 
@@ -177,57 +254,18 @@ namespace glm
 		lsb = *PointerLSB;
 	}
 
-	template <>
-	GLM_FUNC_QUALIFIER void umulExtended
-	(
-		uvec2 const & x,
-		uvec2 const & y,
-		uvec2 & msb,
-		uvec2 & lsb
-	)
+	template <precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER void umulExtended(vecType<uint, P> const & x, vecType<uint, P> const & y, vecType<uint, P> & msb, vecType<uint, P> & lsb)
 	{
-		umulExtended(x[0], y[0], msb[0], lsb[0]);
-		umulExtended(x[1], y[1], msb[1], lsb[1]);
-	}
+		GLM_STATIC_ASSERT(sizeof(uint) == sizeof(uint32), "uint and uint32 size mismatch");
 
-	template <>
-	GLM_FUNC_QUALIFIER void umulExtended
-	(
-		uvec3 const & x,
-		uvec3 const & y,
-		uvec3 & msb,
-		uvec3 & lsb
-	)
-	{
-		umulExtended(x[0], y[0], msb[0], lsb[0]);
-		umulExtended(x[1], y[1], msb[1], lsb[1]);
-		umulExtended(x[2], y[2], msb[2], lsb[2]);
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER void umulExtended
-	(
-		uvec4 const & x,
-		uvec4 const & y,
-		uvec4 & msb,
-		uvec4 & lsb
-	)
-	{
-		umulExtended(x[0], y[0], msb[0], lsb[0]);
-		umulExtended(x[1], y[1], msb[1], lsb[1]);
-		umulExtended(x[2], y[2], msb[2], lsb[2]);
-		umulExtended(x[3], y[3], msb[3], lsb[3]);
+		vecType<uint64, P> Value64(vecType<uint64, P>(x) * vecType<uint64, P>(y));
+		msb = vecType<uint32, P>(Value64 >> static_cast<uint64>(32));
+		lsb = vecType<uint32, P>(Value64);
 	}
 
 	// imulExtended
-	template <>
-	GLM_FUNC_QUALIFIER void imulExtended
-	(
-		int const & x,
-		int const & y,
-		int & msb,
-		int & lsb
-	)
+	GLM_FUNC_QUALIFIER void imulExtended(int x, int y, int & msb, int & lsb)
 	{
 		GLM_STATIC_ASSERT(sizeof(int) == sizeof(int32), "int and int32 size mismatch");
 
@@ -238,417 +276,118 @@ namespace glm
 		lsb = *PointerLSB;
 	}
 
-	template <>
-	GLM_FUNC_QUALIFIER void imulExtended
-	(
-		ivec2 const & x,
-		ivec2 const & y,
-		ivec2 & msb,
-		ivec2 & lsb
-	)
+	template <precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER void imulExtended(vecType<int, P> const & x, vecType<int, P> const & y, vecType<int, P> & msb, vecType<int, P> & lsb)
 	{
-		imulExtended(x[0], y[0], msb[0], lsb[0]),
-		imulExtended(x[1], y[1], msb[1], lsb[1]);
-	}
+		GLM_STATIC_ASSERT(sizeof(int) == sizeof(int32), "int and int32 size mismatch");
 
-	template <>
-	GLM_FUNC_QUALIFIER void imulExtended
-	(
-		ivec3 const & x,
-		ivec3 const & y,
-		ivec3 & msb,
-		ivec3 & lsb
-	)
-	{
-		imulExtended(x[0], y[0], msb[0], lsb[0]),
-		imulExtended(x[1], y[1], msb[1], lsb[1]);
-		imulExtended(x[2], y[2], msb[2], lsb[2]);
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER void imulExtended
-	(
-		ivec4 const & x,
-		ivec4 const & y,
-		ivec4 & msb,
-		ivec4 & lsb
-	)
-	{
-		imulExtended(x[0], y[0], msb[0], lsb[0]),
-		imulExtended(x[1], y[1], msb[1], lsb[1]);
-		imulExtended(x[2], y[2], msb[2], lsb[2]);
-		imulExtended(x[3], y[3], msb[3], lsb[3]);
+		vecType<int64, P> Value64(vecType<int64, P>(x) * vecType<int64, P>(y));
+		lsb = vecType<int32, P>(Value64 & static_cast<int64>(0xFFFFFFFF));
+		msb = vecType<int32, P>((Value64 >> static_cast<int64>(32)) & static_cast<int64>(0xFFFFFFFF));
 	}
 
 	// bitfieldExtract
 	template <typename genIUType>
-	GLM_FUNC_QUALIFIER genIUType bitfieldExtract
-	(
-		genIUType const & Value,
-		int const & Offset,
-		int const & Bits
-	)
+	GLM_FUNC_QUALIFIER genIUType bitfieldExtract(genIUType Value, int Offset, int Bits)
 	{
-		int GenSize = int(sizeof(genIUType)) << int(3);
-
-		assert(Offset + Bits <= GenSize);
-
-		genIUType ShiftLeft = Bits ? Value << (GenSize - (Bits + Offset)) : genIUType(0);
-		genIUType ShiftBack = ShiftLeft >> genIUType(GenSize - Bits);
-
-		return ShiftBack;
+		return bitfieldExtract(tvec1<genIUType>(Value), Offset, Bits).x;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec2<T, P> bitfieldExtract
-	(
-		detail::tvec2<T, P> const & Value,
-		int const & Offset,
-		int const & Bits
-	)
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> bitfieldExtract(vecType<T, P> const & Value, int Offset, int Bits)
 	{
-		return detail::tvec2<T, P>(
-			bitfieldExtract(Value[0], Offset, Bits),
-			bitfieldExtract(Value[1], Offset, Bits));
-	}
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'bitfieldExtract' only accept integer inputs");
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> bitfieldExtract
-	(
-		detail::tvec3<T, P> const & Value,
-		int const & Offset,
-		int const & Bits
-	)
-	{
-		return detail::tvec3<T, P>(
-			bitfieldExtract(Value[0], Offset, Bits),
-			bitfieldExtract(Value[1], Offset, Bits),
-			bitfieldExtract(Value[2], Offset, Bits));
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<T, P> bitfieldExtract
-	(
-		detail::tvec4<T, P> const & Value,
-		int const & Offset,
-		int const & Bits
-	)
-	{
-		return detail::tvec4<T, P>(
-			bitfieldExtract(Value[0], Offset, Bits),
-			bitfieldExtract(Value[1], Offset, Bits),
-			bitfieldExtract(Value[2], Offset, Bits),
-			bitfieldExtract(Value[3], Offset, Bits));
+		return (Value >> static_cast<T>(Offset)) & static_cast<T>(detail::mask(Bits));
 	}
 
 	// bitfieldInsert
 	template <typename genIUType>
-	GLM_FUNC_QUALIFIER genIUType bitfieldInsert
-	(
-		genIUType const & Base,
-		genIUType const & Insert,
-		int const & Offset,
-		int const & Bits
-	)
+	GLM_FUNC_QUALIFIER genIUType bitfieldInsert(genIUType const & Base, genIUType const & Insert, int Offset, int Bits)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'bitfieldInsert' only accept integer values");
-		assert(Offset + Bits <= sizeof(genIUType));
+		return bitfieldInsert(tvec1<genIUType>(Base), tvec1<genIUType>(Insert), Offset, Bits).x;
+	}
 
-		if(Bits == 0)
-			return Base;
-
-		genIUType Mask = 0;
-		for(int Bit = Offset; Bit < Offset + Bits; ++Bit)
-			Mask |= (1 << Bit);
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> bitfieldInsert(vecType<T, P> const & Base, vecType<T, P> const & Insert, int Offset, int Bits)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'bitfieldInsert' only accept integer values");
 
+		T const Mask = static_cast<T>(detail::mask(Bits) << Offset);
 		return (Base & ~Mask) | (Insert & Mask);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec2<T, P> bitfieldInsert
-	(
-		detail::tvec2<T, P> const & Base,
-		detail::tvec2<T, P> const & Insert,
-		int const & Offset,
-		int const & Bits
-	)
-	{
-		return detail::tvec2<T, P>(
-			bitfieldInsert(Base[0], Insert[0], Offset, Bits),
-			bitfieldInsert(Base[1], Insert[1], Offset, Bits));
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> bitfieldInsert
-	(
-		detail::tvec3<T, P> const & Base,
-		detail::tvec3<T, P> const & Insert,
-		int const & Offset,
-		int const & Bits
-	)
-	{
-		return detail::tvec3<T, P>(
-			bitfieldInsert(Base[0], Insert[0], Offset, Bits),
-			bitfieldInsert(Base[1], Insert[1], Offset, Bits),
-			bitfieldInsert(Base[2], Insert[2], Offset, Bits));
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<T, P> bitfieldInsert
-	(
-		detail::tvec4<T, P> const & Base,
-		detail::tvec4<T, P> const & Insert,
-		int const & Offset,
-		int const & Bits
-	)
-	{
-		return detail::tvec4<T, P>(
-			bitfieldInsert(Base[0], Insert[0], Offset, Bits),
-			bitfieldInsert(Base[1], Insert[1], Offset, Bits),
-			bitfieldInsert(Base[2], Insert[2], Offset, Bits),
-			bitfieldInsert(Base[3], Insert[3], Offset, Bits));
-	}
-
 	// bitfieldReverse
-	template <typename genIUType>
-	GLM_FUNC_QUALIFIER genIUType bitfieldReverse(genIUType const & Value)
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType bitfieldReverse(genType x)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'bitfieldReverse' only accept integer values");
+		return bitfieldReverse(glm::tvec1<genType, glm::defaultp>(x)).x;
+	}
 
-		genIUType Out = 0;
-		std::size_t BitSize = sizeof(genIUType) * 8;
-		for(std::size_t i = 0; i < BitSize; ++i)
-			if(Value & (genIUType(1) << i))
-				Out |= genIUType(1) << (BitSize - 1 - i);
-		return Out;
-	}	
-
-	VECTORIZE_VEC(bitfieldReverse)
+	template <typename T, glm::precision P, template <typename, glm::precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> bitfieldReverse(vecType<T, P> const & v)
+	{
+		vecType<T, P> x(v);
+		x = detail::compute_bitfieldReverseStep<sizeof(T) * 8 >=  2>::call(x, T(0x5555555555555555ull), static_cast<T>( 1));
+		x = detail::compute_bitfieldReverseStep<sizeof(T) * 8 >=  4>::call(x, T(0x3333333333333333ull), static_cast<T>( 2));
+		x = detail::compute_bitfieldReverseStep<sizeof(T) * 8 >=  8>::call(x, T(0x0F0F0F0F0F0F0F0Full), static_cast<T>( 4));
+		x = detail::compute_bitfieldReverseStep<sizeof(T) * 8 >= 16>::call(x, T(0x00FF00FF00FF00FFull), static_cast<T>( 8));
+		x = detail::compute_bitfieldReverseStep<sizeof(T) * 8 >= 32>::call(x, T(0x0000FFFF0000FFFFull), static_cast<T>(16));
+		x = detail::compute_bitfieldReverseStep<sizeof(T) * 8 >= 64>::call(x, T(0x00000000FFFFFFFFull), static_cast<T>(32));
+		return x;
+	}
 
 	// bitCount
-	template <typename genIUType>
-	GLM_FUNC_QUALIFIER int bitCount(genIUType const & Value)
+	template <typename genType>
+	GLM_FUNC_QUALIFIER int bitCount(genType x)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'bitCount' only accept integer values");
-
-		int Count = 0;
-		for(std::size_t i = 0; i < sizeof(genIUType) * std::size_t(8); ++i)
-		{
-			if(Value & (1 << i))
-				++Count;
-		}
-		return Count;
+		return bitCount(glm::tvec1<genType, glm::defaultp>(x)).x;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec2<int, P> bitCount
-	(
-		detail::tvec2<T, P> const & value
-	)
+	template <typename T, glm::precision P, template <typename, glm::precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<int, P> bitCount(vecType<T, P> const & v)
 	{
-		return detail::tvec2<int, P>(
-			bitCount(value[0]),
-			bitCount(value[1]));
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<int, P> bitCount
-	(
-		detail::tvec3<T, P> const & value
-	)
-	{
-		return detail::tvec3<int, P>(
-			bitCount(value[0]),
-			bitCount(value[1]),
-			bitCount(value[2]));
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<int, P> bitCount
-	(
-		detail::tvec4<T, P> const & value
-	)
-	{
-		return detail::tvec4<int, P>(
-			bitCount(value[0]),
-			bitCount(value[1]),
-			bitCount(value[2]),
-			bitCount(value[3]));
+		vecType<typename detail::make_unsigned<T>::type, P> x(*reinterpret_cast<vecType<typename detail::make_unsigned<T>::type, P> const *>(&v));
+		x = detail::compute_bitfieldBitCountStep<sizeof(T) * 8 >=  2>::call(x, typename detail::make_unsigned<T>::type(0x5555555555555555ull), typename detail::make_unsigned<T>::type( 1));
+		x = detail::compute_bitfieldBitCountStep<sizeof(T) * 8 >=  4>::call(x, typename detail::make_unsigned<T>::type(0x3333333333333333ull), typename detail::make_unsigned<T>::type( 2));
+		x = detail::compute_bitfieldBitCountStep<sizeof(T) * 8 >=  8>::call(x, typename detail::make_unsigned<T>::type(0x0F0F0F0F0F0F0F0Full), typename detail::make_unsigned<T>::type( 4));
+		x = detail::compute_bitfieldBitCountStep<sizeof(T) * 8 >= 16>::call(x, typename detail::make_unsigned<T>::type(0x00FF00FF00FF00FFull), typename detail::make_unsigned<T>::type( 8));
+		x = detail::compute_bitfieldBitCountStep<sizeof(T) * 8 >= 32>::call(x, typename detail::make_unsigned<T>::type(0x0000FFFF0000FFFFull), typename detail::make_unsigned<T>::type(16));
+		x = detail::compute_bitfieldBitCountStep<sizeof(T) * 8 >= 64>::call(x, typename detail::make_unsigned<T>::type(0x00000000FFFFFFFFull), typename detail::make_unsigned<T>::type(32));
+		return vecType<int, P>(x);
 	}
 
 	// findLSB
 	template <typename genIUType>
-	GLM_FUNC_QUALIFIER int findLSB
-	(
-		genIUType const & Value
-	)
+	GLM_FUNC_QUALIFIER int findLSB(genIUType Value)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'findLSB' only accept integer values");
-		if(Value == 0)
-			return -1;
 
-		genIUType Bit;
-		for(Bit = genIUType(0); !(Value & (1 << Bit)); ++Bit){}
-		return Bit;
+		return detail::compute_findLSB<genIUType, sizeof(genIUType) * 8>::call(Value);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec2<int, P> findLSB
-	(
-		detail::tvec2<T, P> const & value
-	)
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<int, P> findLSB(vecType<T, P> const & x)
 	{
-		return detail::tvec2<int, P>(
-			findLSB(value[0]),
-			findLSB(value[1]));
-	}
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'findLSB' only accept integer values");
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<int, P> findLSB
-	(
-		detail::tvec3<T, P> const & value
-	)
-	{
-		return detail::tvec3<int, P>(
-			findLSB(value[0]),
-			findLSB(value[1]),
-			findLSB(value[2]));
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<int, P> findLSB
-	(
-		detail::tvec4<T, P> const & value
-	)
-	{
-		return detail::tvec4<int, P>(
-			findLSB(value[0]),
-			findLSB(value[1]),
-			findLSB(value[2]),
-			findLSB(value[3]));
+		return detail::functor1<int, T, P, vecType>::call(findLSB, x);
 	}
 
 	// findMSB
-#if((GLM_ARCH != GLM_ARCH_PURE) && (GLM_COMPILER & GLM_COMPILER_VC))
-
 	template <typename genIUType>
-	GLM_FUNC_QUALIFIER int findMSB
-	(
-		genIUType const & Value
-	)
+	GLM_FUNC_QUALIFIER int findMSB(genIUType x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'findMSB' only accept integer values");
-		if(Value == 0)
-			return -1;
 
-		unsigned long Result(0);
-		_BitScanReverse(&Result, Value);
-		return int(Result);
-	}
-/*
-// __builtin_clz seems to be buggy as it crasks for some values, from 0x00200000 to 80000000
-#elif((GLM_ARCH != GLM_ARCH_PURE) && (GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC40))
-
-	template <typename genIUType>
-	GLM_FUNC_QUALIFIER int findMSB
-	(
-		genIUType const & Value
-	)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'findMSB' only accept integer values");
-		if(Value == 0)
-			return -1;
-
-		// clz returns the number or trailing 0-bits; see
-		// http://gcc.gnu.org/onlinedocs/gcc-4.7.1/gcc/Other-Builtins.html
-		//
-		// NoteBecause __builtin_clz only works for unsigned ints, this
-		// implementation will not work for 64-bit integers.
-		//
-		return 31 - __builtin_clzl(Value);
-	}
-*/
-#else
-
-/* SSE implementation idea
-
-		__m128i const Zero = _mm_set_epi32( 0,  0,  0,  0);
-		__m128i const One = _mm_set_epi32( 1,  1,  1,  1);
-		__m128i Bit = _mm_set_epi32(-1, -1, -1, -1);
-		__m128i Tmp = _mm_set_epi32(Value, Value, Value, Value);
-		__m128i Mmi = Zero;
-		for(int i = 0; i < 32; ++i)
-		{
-			__m128i Shilt = _mm_and_si128(_mm_cmpgt_epi32(Tmp, One), One);
-			Tmp = _mm_srai_epi32(Tmp, One);
-			Bit = _mm_add_epi32(Bit, _mm_and_si128(Shilt, i));
-			Mmi = _mm_and_si128(Mmi, One);
-		}
-		return Bit;
-
-*/
-
-	template <typename genIUType>
-	GLM_FUNC_QUALIFIER int findMSB
-	(
-		genIUType const & Value
-	)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'findMSB' only accept integer values");
-		
-		if(Value == genIUType(0) || Value == genIUType(-1))
-			return -1;
-		else if(Value > 0)
-		{
-			genIUType Bit = genIUType(-1);
-			for(genIUType tmp = Value; tmp > 0; tmp >>= 1, ++Bit){}
-			return Bit;
-		}
-		else //if(Value < 0)
-		{
-			int const BitCount(sizeof(genIUType) * 8);
-			int MostSignificantBit(-1);
-			for(int BitIndex(0); BitIndex < BitCount; ++BitIndex)
-				MostSignificantBit = (Value & (1 << BitIndex)) ? MostSignificantBit : BitIndex;
-			assert(MostSignificantBit >= 0);
-			return MostSignificantBit;
-		}
-	}
-#endif//(GLM_COMPILER)
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec2<int, P> findMSB
-	(
-		detail::tvec2<T, P> const & value
-	)
-	{
-		return detail::tvec2<int, P>(
-			findMSB(value[0]),
-			findMSB(value[1]));
+		return findMSB(tvec1<genIUType>(x)).x;
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<int, P> findMSB
-	(
-		detail::tvec3<T, P> const & value
-	)
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<int, P> findMSB(vecType<T, P> const & x)
 	{
-		return detail::tvec3<int, P>(
-			findMSB(value[0]),
-			findMSB(value[1]),
-			findMSB(value[2]));
-	}
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'findMSB' only accept integer values");
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<int, P> findMSB
-	(
-		detail::tvec4<T, P> const & value
-	)
-	{
-		return detail::tvec4<int, P>(
-			findMSB(value[0]),
-			findMSB(value[1]),
-			findMSB(value[2]),
-			findMSB(value[3]));
+		return detail::compute_findMSB_vec<T, P, vecType, sizeof(T) * 8>::call(x);
 	}
 }//namespace glm