Updated/activated EQDictionary code to use the new possessions enumeration

Allow merchants to use 80th slot.

.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,36 @@
-#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
 
 #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 +39,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)
 
@@ -75,7 +104,7 @@ IF(MSVC)
 		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)
@@ -105,12 +134,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 +252,17 @@ 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)
 
 #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 +292,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)
@@ -319,10 +345,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,472 @@
 EQEMu Changelog (Started on Sept 24, 2003 15:50)
 -------------------------------------------------------
+== 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,7 +11,7 @@ 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 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")
@@ -33,4 +33,4 @@ IF(UNIX)
 	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

@@ -19,11 +19,11 @@
 #include <stdio.h>
 #include "../../common/debug.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"
 
 void ExportSpells(SharedDatabase *db);
 void ExportSkillCaps(SharedDatabase *db);
@@ -32,7 +32,7 @@ void ExportBaseData(SharedDatabase *db);
 int main(int argc, char **argv) {
 	RegisterExecutablePlatform(ExePlatformClientExport);
 	set_exception_handler();
-	
+
 	LogFile->write(EQEMuLog::Status, "Client Files Export Utility");
 	if(!EQEmuConfig::LoadConfig()) {
 		LogFile->write(EQEMuLog::Error, "Unable to load configuration file.");
@@ -52,11 +52,11 @@ int main(int argc, char **argv) {
 			"database connection");
 		return 1;
 	}
-	
+
 	ExportSpells(&database);
 	ExportSkillCaps(&database);
 	ExportBaseData(&database);
-	
+
 	return 0;
 }
 
@@ -69,72 +69,69 @@ void ExportSpells(SharedDatabase *db) {
 		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);
+		LogFile->write(EQEMuLog::Error, "Error in ExportSpells query '%s' %s", query.c_str(), results.ErrorMessage().c_str());
 	}
-	
+
 	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()) {
+        LogFile->write(EQEMuLog::Error, "Error in skill_usable query '%s' %s", query.c_str(), results.ErrorMessage().c_str());
+        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()) {
+        LogFile->write(EQEMuLog::Error, "Error in get_skill query '%s' %s", query.c_str(), results.ErrorMessage().c_str());
+        return 0;
+    }
+
+    if (results.RowCount() == 0)
+        return 0;
+
+    auto row = results.begin();
+	return atoi(row[0]);
 }
 
 void ExportSkillCaps(SharedDatabase *db) {
@@ -175,27 +172,25 @@ void ExportBaseData(SharedDatabase *db) {
 		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);
+		LogFile->write(EQEMuLog::Error, "Error in ExportBaseData query '%s' %s", query.c_str(), results.ErrorMessage().c_str());
 	}
 
 	fclose(f);

client_files/import/CMakeLists.txt

@@ -11,7 +11,7 @@ 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 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")
@@ -33,4 +33,4 @@ IF(UNIX)
 	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

@@ -18,11 +18,11 @@
 
 #include "../../common/debug.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"
 
 void ImportSpells(SharedDatabase *db);
 void ImportSkillCaps(SharedDatabase *db);
@@ -31,7 +31,7 @@ void ImportBaseData(SharedDatabase *db);
 int main(int argc, char **argv) {
 	RegisterExecutablePlatform(ExePlatformClientImport);
 	set_exception_handler();
-	
+
 	LogFile->write(EQEMuLog::Status, "Client Files Import Utility");
 	if(!EQEmuConfig::LoadConfig()) {
 		LogFile->write(EQEMuLog::Error, "Unable to load configuration file.");
@@ -55,26 +55,20 @@ int main(int argc, char **argv) {
 	ImportSpells(&database);
 	ImportSkillCaps(&database);
 	ImportBaseData(&database);
-	
+
 	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()) {
+        LogFile->write(EQEMuLog::Error, "Error in GetSpellColumns query '%s' %s", query.c_str(), results.ErrorMessage().c_str());
+        return 0;
+    }
+
+	return results.RowCount();
 }
 
 void ImportSpells(SharedDatabase *db) {
@@ -85,8 +79,8 @@ void ImportSpells(SharedDatabase *db) {
 		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 +97,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) {
@@ -140,7 +134,7 @@ void ImportSpells(SharedDatabase *db) {
 			sql += ");";
 		}
 
-		db->RunQuery(sql.c_str(), (uint32)sql.length());
+		db->QueryDatabase(sql);
 
 		spells_imported++;
 		if(spells_imported % 1000 == 0) {
@@ -165,27 +159,27 @@ void ImportSkillCaps(SharedDatabase *db) {
 	}
 
 	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);
@@ -201,7 +195,7 @@ void ImportBaseData(SharedDatabase *db) {
 	}
 
 	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 +220,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,79 @@
 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
 	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_error.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
+	item.cpp
 	logsys.cpp
 	logsys_eqemu.cpp
 	md5.cpp
 	memory_mapped_file.cpp
 	misc.cpp
-	MiscFunctions.cpp
+	misc_functions.cpp
 	moremath.cpp
-	Mutex.cpp
+	mutex.cpp
+	mysql_request_result.cpp
+	mysql_request_row.cpp
 	opcode_map.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
 	worldconn.cpp
-	XMLParser.cpp
+	xml_parser.cpp
 	platform.cpp
-	patches/Client62.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/titanium.cpp
+	patches/underfoot.cpp
 	SocketLib/Base64.cpp
 	SocketLib/File.cpp
 	SocketLib/HttpdCookies.cpp
@@ -90,40 +93,42 @@ 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_error.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
@@ -134,7 +139,7 @@ SET(common_headers
 	guild_base.h
 	guilds.h
 	ipc_mutex.h
-	Item.h
+	item.h
 	item_fieldlist.h
 	item_struct.h
 	languages.h
@@ -146,16 +151,19 @@ SET(common_headers
 	md5.h
 	memory_mapped_file.h
 	misc.h
-	MiscFunctions.h
+	misc_functions.h
 	moremath.h
-	Mutex.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
+	platform.h
+	proc_launcher.h
 	profiler.h
 	ptimer.h
 	queue.h
@@ -169,11 +177,11 @@ 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
@@ -181,38 +189,44 @@ SET(common_headers
 	useperl.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/client62.h
+	patches/client62_constants.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/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_constants.h
+	patches/titanium.h
+	patches/titanium_constants.h
+	patches/titanium_itemfields.h
+	patches/titanium_ops.h
+	patches/titanium_structs.h
+	patches/underfoot.h
+	patches/underfoot_constants.h
+	patches/underfoot_itemfields.h
+	patches/underfoot_ops.h
+	patches/underfoot_structs.h
 	SocketLib/Base64.h
 	SocketLib/File.h
 	SocketLib/HttpdCookies.h
@@ -231,42 +245,49 @@ SET(common_headers
 )
 
 SOURCE_GROUP(Patches FILES
-	patches/Client62.h
-	patches/Client62_itemfields.h
-	patches/Client62_ops.h
-	patches/Client62_structs.h
+	patches/client62.h
+	patches/client62_itemfields.h
+	patches/client62_ops.h
+	patches/client62_constants.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/rof2_constants.h
+	patches/rof_structs.h
+	patches/titanium.h
+	patches/titanium_itemfields.h
+	patches/titanium_ops.h
+	patches/titanium_constants.h
+	patches/titanium_structs.h
+	patches/underfoot.h
+	patches/underfoot_itemfields.h
+	patches/underfoot_ops.h
+	patches/underfoot_constants.h
+	patches/underfoot_structs.h
+	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/titanium.cpp
+	patches/underfoot.cpp
 )
 
 SOURCE_GROUP(SocketLib FILES
@@ -311,11 +332,11 @@ 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("patches/sod.cpp" "patches/sof.cpp" "patches/rof.cpp" "patches/underfoot.cpp" PROPERTIES COMPILE_FLAGS -O0)
 ENDIF(UNIX)
 
-SET(LIBRARY_OUTPUT_PATH ${PROJECT_BINARY_DIR}/Bin)
+SET(LIBRARY_OUTPUT_PATH ${PROJECT_BINARY_DIR}/bin)

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

@@ -46,7 +46,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 #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/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/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

@@ -16,7 +16,7 @@
 	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
 #include "debug.h"
-#include "BasePacket.h"
+#include "base_packet.h"
 #include "misc.h"
 #include "packet_dump.h"
 

common/clientversions.h

@@ -1,27 +1,76 @@
 #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;
+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_RoF2		= 64;
 
-typedef enum {
+static const uint32 BIT_TitaniumAndEarlier	= 0x00000003;
+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_RoF2AndLater		= 0xFFFFFFC0;
+static const uint32 BIT_AllClients			= 0xFFFFFFFF;
+
+typedef enum
+{
 	EQClientUnknown = 0,
-	EQClient62,
-	EQClientTitanium,
-	EQClientSoF,
-	EQClientSoD,
-	EQClientUnderfoot,
-	EQClientRoF
+	EQClient62,				// Build: 'Aug  4 2005 15:40:59'
+	EQClientTitanium,		// Build: 'Oct 31 2005 10:33:37'
+	EQClientSoF,			// Build: 'Sep  7 2007 09:11:49'
+	EQClientSoD,			// Build: 'Dec 19 2008 15:22:49'
+	EQClientUnderfoot,		// Build: 'Jun  8 2010 16:44:32'
+	EQClientRoF,			// Build: 'Dec 10 2012 17:35:44'
+	EQClientRoF2,			// Build: 'May 10 2013 23:30:08'
+
+	_EQClientCount,			// place new clients before this point (preferably, in release/attribute order)
+
+	// Values below are not implemented, as yet...
+
+	EmuNPC = _EQClientCount,
+	EmuMerc,
+	EmuBot,
+	EmuPet,
+
+	_EmuClientCount			// array size for EQLimits
 } EQClientVersion;
 
+static const char* EQClientVersionName(EQClientVersion version)
+{
+	switch (version)
+	{
+	case EQClientUnknown:
+		return "EQClientUnknown";
+	case EQClient62:
+		return "EQClient62";
+	case EQClientTitanium:
+		return "EQClientTitanium";
+	case EQClientSoF:
+		return "EQClientSoF";
+	case EQClientSoD:
+		return "EQClientSoD";
+	case EQClientUnderfoot:
+		return "EQClientUnderfoot";
+	case EQClientRoF:
+		return "EQClientRoF";
+	case EQClientRoF2:
+		return "EQClientRoF2";
+	case EmuNPC:
+		return "EmuNPC";
+	case EmuMerc:
+		return "EmuMerc";
+	case EmuBot:
+		return "EmuBot";
+	case EmuPet:
+		return "EmuPet";
+	default:
+		return "ERROR: Invalid EQClientVersion";
+	};
+}
+
 #endif /* CLIENTVERSIONS_H */

common/condition.cpp

@@ -17,7 +17,7 @@
 */
 
 #include "debug.h"
-#include "Condition.h"
+#include "condition.h"
 
 #ifdef _WINDOWS
 

common/data_verification.h

@@ -0,0 +1,48 @@
+/*	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 COMMON_DATA_VERIFICATION_H
+#define COMMON_DATA_VERIFICATION_H
+
+#include <algorithm>
+
+namespace EQEmu
+{
+
+template <typename T>
+T Clamp(const T& value, const T& lower, const T& upper) {
+	return std::max(lower, std::min(value, upper));
+}
+
+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

@@ -26,12 +26,6 @@
 #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 <string>
 #include <vector>
 #include <map>
@@ -105,10 +99,16 @@ public:
 	Database(const char* host, const char* user, const char* passwd, const char* database,uint32 port);
 	bool Connect(const char* host, const char* user, const char* passwd, const char* database,uint32 port);
 	~Database();
+	bool	ThrowDBError(std::string ErrorMessage, std::string query_title, std::string query);
+
 
 	/*
 	* General Character Related Stuff
 	*/
+
+	/* Character Creation */
+	bool	SaveCharacterCreate(uint32 character_id, uint32 account_id, PlayerProfile_Struct* pp);
+
 	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);
@@ -118,9 +118,8 @@ public:
 	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	StoreCharacter(uint32 account_id, PlayerProfile_Struct* pp, Inventory* inv);
 	bool	DeleteCharacter(char* name);
-	uint8	CopyCharacter(const char* oldname, const char* newname, uint32 acctid);
 
 	/*
 	* General Information Getting Queries
@@ -130,7 +129,7 @@ public:
 	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	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);
@@ -207,6 +206,7 @@ public:
 	char*	GetGroupLeadershipInfo(uint32 gid, char* leaderbuf, char* maintank = nullptr, char* assist = nullptr, char* puller = nullptr, char *marknpc = nullptr,
 						GroupLeadershipAA_Struct* GLAA = nullptr);
 	void	ClearGroupLeader(uint32 gid = 0);
+	
 
 	/*
 	* Raids
@@ -216,6 +216,8 @@ public:
 	uint32	GetRaidID(const char* name);
 	const char *GetRaidLeaderName(uint32 rid);
 
+	bool CheckDatabaseConversions();
+
 	/*
 	* Database Variables
 	*/
@@ -223,7 +225,7 @@ public:
 	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
@@ -249,10 +251,6 @@ public:
 	void	SetLoginFlags(uint32 CharID, bool LFP, bool LFG, uint8 firstlogon);
 	void	AddReport(std::string who, std::string against, std::string lines);
 
-
-protected:
-	void	HandleMysqlError(uint32 errnum);
-
 private:
 	void DBInitVars();
 
@@ -262,7 +260,20 @@ 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();
 };
 
-bool	FetchRowMap(MYSQL_RES *result, std::map<std::string,std::string> &rowmap);
 #endif

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

@@ -10,7 +10,7 @@
 #include <limits.h>
 #include "dbcore.h"
 #include <string.h>
-#include "../common/MiscFunctions.h"
+#include "../common/misc_functions.h"
 #include <cstdlib>
 
 #ifdef _WINDOWS
@@ -58,6 +58,93 @@ void DBcore::ping() {
 	MDatabase.unlock();
 }
 
+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();
+
+	// 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;
+
+		// 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;
+				MySQLRequestResult requestResult = QueryDatabase(query, querylen, false);
+
+				if (requestResult.Success())
+				{
+					std::cout << "Reconnection to database successful." << std::endl;
+					return requestResult;
+				}
+
+			}
+
+			pStatus = Error;
+
+			char *errorBuffer = new char[MYSQL_ERRMSG_SIZE];
+
+			snprintf(errorBuffer, MYSQL_ERRMSG_SIZE, "#%i: %s", mysql_errno(&mysql), mysql_error(&mysql));
+
+			std::cout << "DB Query Error #" << mysql_errno(&mysql) << ": " << mysql_error(&mysql) << std::endl;
+
+			return MySQLRequestResult(nullptr, 0, 0, 0, 0, (uint32)mysql_errno(&mysql), errorBuffer);
+		}
+
+		char *errorBuffer = new char[MYSQL_ERRMSG_SIZE];
+		snprintf(errorBuffer, 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
+		return MySQLRequestResult(nullptr, 0, 0, 0, 0, mysql_errno(&mysql),errorBuffer);
+
+	}
+
+	// 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 DEBUG_MYSQL_QUERIES >= 1
+	if (requestResult.Success())
+	{
+		std::cout << "query successful";
+		if (requestResult.Result())
+			std::cout << ", " << (int) mysql_num_rows(requestResult.Result()) << " rows returned";
+
+		std::cout << ", " << requestResult.RowCount() << " rows affected";
+		std::cout<< std::endl;
+	}
+	else {
+		std::cout << "QUERY: query FAILED" << std::endl;
+	}
+#endif
+
+	return requestResult;
+}
+
 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;
@@ -111,7 +198,7 @@ bool DBcore::RunQuery(const char* query, uint32 querylen, char* errbuf, MYSQL_RE
 		if (affected_rows)
 			*affected_rows = mysql_affected_rows(&mysql);
 		if (last_insert_id)
-			*last_insert_id = mysql_insert_id(&mysql);
+			*last_insert_id = (uint32)mysql_insert_id(&mysql);
 		if (result) {
 			if (*result) {
 				ret = true;

common/dbcore.h

@@ -4,15 +4,17 @@
 #ifdef _WINDOWS
 	#include <winsock.h>
 	#include <windows.h>
-	//#include <winsock.h>
 #endif
+
 #include <mysql.h>
+#include <string.h>
 #include "../common/types.h"
-#include "../common/Mutex.h"
+#include "../common/mutex.h"
 #include "../common/linked_list.h"
 #include "../common/queue.h"
 #include "../common/timer.h"
-#include "../common/Condition.h"
+#include "../common/condition.h"
+#include "../common/mysql_request_result.h"
 
 class DBcore {
 public:
@@ -22,6 +24,8 @@ public:
 	~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);
 	uint32	DoEscapeString(char* tobuf, const char* frombuf, uint32 fromlen);
 	void	ping();
 	MYSQL*	getMySQL(){ return &mysql; }

common/debug.cpp

@@ -19,8 +19,8 @@
 #endif
 
 #include "debug.h"
-#include "StringUtil.h"
-#include "MiscFunctions.h"
+#include "string_util.h"
+#include "misc_functions.h"
 #include "platform.h"
 
 #ifndef va_copy

common/debug.h

@@ -69,7 +69,7 @@
 
 #include "logsys.h"
 
-#include "../common/Mutex.h"
+#include "../common/mutex.h"
 #include <stdio.h>
 #include <stdarg.h>
 
@@ -80,14 +80,15 @@ public:
 	~EQEMuLog();
 
 	enum LogIDs {
-		Status = 0,	//this must stay the first entry in this list
-		Normal,
-		Error,
-		Debug,
-		Quest,
-		Commands,
-		Crash,
-		MaxLogID
+		Status = 0,	 /* This must stay the first entry in this list */
+		Normal,		 /* Normal Logs */
+		Error,		 /* Error Logs */
+		Debug,		 /* Debug Logs */
+		Quest,		 /* Quest Logs */
+		Commands,	 /* Issued Comamnds */
+		Crash,		 /* Crash Logs */
+		Save,		 /* Client Saves */
+		MaxLogID	 /* Max, used in functions to get the max log ID */
 	};
 
 	//these are callbacks called for each
@@ -113,6 +114,7 @@ private:
 	Mutex	MOpen;
 	Mutex	MLog[MaxLogID];
 	FILE*	fp[MaxLogID];
+
 /* LogStatus: bitwise variable
 	1 = output to file
 	2 = output to stdout

common/emu_tcp_connection.cpp

@@ -30,8 +30,8 @@ tremendously.
 #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"
 
@@ -366,7 +366,6 @@ bool EmuTCPConnection::LineOutQueuePush(char* line) {
 			safe_delete_array(line);
 			return(true);
 		}
-
 	}
 
 	return(TCPConnection::LineOutQueuePush(line));
@@ -419,7 +418,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;

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

common/emu_tcp_server.cpp

@@ -1,6 +1,6 @@
 #include "debug.h"
-#include "EmuTCPServer.h"
-#include "EmuTCPConnection.h"
+#include "emu_tcp_server.h"
+#include "emu_tcp_connection.h"
 
 EmuTCPServer::EmuTCPServer(uint16 iPort, bool iOldFormat)
 :	TCPServer<EmuTCPConnection>(iPort),

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

@@ -138,45 +138,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
 };
 
 /*
@@ -735,10 +776,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 +810,97 @@ enum MaterialUseSlots : uint8
 **
 */
 
-enum InventorySlot
-{
-	////////////////////////
-	// Equip slots
-	////////////////////////
+#define INVALID_INDEX	-1
+#define NOT_USED		0
+#define NO_ITEM			0
 
-	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,
+#define DB_ITEM_CONTAINER_SIZE	255 // probably need to move to database.h
 
-	////////////////////////
-	// All other slots
-	////////////////////////
-	SLOT_PERSONAL_BEGIN = 22,
-	SLOT_PERSONAL_END = 29,
+// 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
 
-	SLOT_CURSOR		= 30,
+namespace legacy {
+	// this is for perl and other legacy systems
 
-	SLOT_CURSOR_END	= (int16)0xFFFE,	// Last item on cursor queue
-	// Cursor bag slots are 331->340 (10 slots)
+	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,
 
-	// Personal Inventory Slots
-	// Slots 1 through 8 are slots 22->29
-	// Inventory bag slots are 251->330 (10 slots per bag)
+		SLOT_POSSESSIONS_BEGIN	= 0,
+		SLOT_POSSESSIONS_END	= 30,
 
-	// Tribute slots are 400-404? (upper bound unknown)
-	// storing these in worn item's map
+		SLOT_EQUIPMENT_BEGIN	= 0,
+		SLOT_EQUIPMENT_END		= 21,
 
-	// Bank slots
-	// Bank slots 1 through 16 are slots 2000->2015
-	// Bank bag slots are 2031->2190
+		SLOT_PERSONAL_BEGIN		= 22,
+		SLOT_PERSONAL_END		= 29,
+		SLOT_PERSONAL_BAGS_BEGIN	= 251,
+		SLOT_PERSONAL_BAGS_END		= 330,
 
-	// Shared bank slots
-	// Shared bank slots 1 through 2 are slots 2500->2501
-	// Shared bank bag slots are 2531->2550
+		SLOT_CURSOR_BAG_BEGIN		= 331,
+		SLOT_CURSOR_BAG_END			= 340,
 
-	// 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_TRIBUTE_BEGIN	= 400,
+		SLOT_TRIBUTE_END	= 404,
 
-	// 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
-};
+		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;
+}
 
 #endif

common/eq_dictionary.h

@@ -0,0 +1,211 @@
+/*
+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/client62_constants.h"
+#include "../common/patches/titanium_constants.h"
+#include "../common/patches/sof_constants.h"
+#include "../common/patches/sod_constants.h"
+#include "../common/patches/underfoot_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
+
+using namespace RoF2::maps;		// server inventory maps enumeration (code and database sync'd to reference)
+using namespace RoF2::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 EQClientVersion CHARACTER_CREATION_CLIENT = EQClientRoF; // adjust according to starting item placement and target client
+
+	// inventory
+	static uint16 InventoryMapSize(int16 map);
+	//static std::string InventoryLocationName(Location_Struct location);
+	static std::string InventoryMapName(int16 map);
+	static std::string InventoryMainName(int16 main);
+	static std::string InventorySubName(int16 sub);
+	static std::string InventoryAugName(int16 aug);
+
+	// 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 = RoF2::consts::MAP_POSSESSIONS_SIZE;
+	static const uint16 MAP_BANK_SIZE = RoF2::consts::MAP_BANK_SIZE;
+	static const uint16 MAP_SHARED_BANK_SIZE = RoF2::consts::MAP_SHARED_BANK_SIZE;
+	static const uint16 MAP_TRADE_SIZE = RoF2::consts::MAP_TRADE_SIZE;
+	static const uint16 MAP_WORLD_SIZE = RoF2::consts::MAP_WORLD_SIZE;
+	static const uint16 MAP_LIMBO_SIZE = RoF2::consts::MAP_LIMBO_SIZE;
+	static const uint16 MAP_TRIBUTE_SIZE = Titanium::consts::MAP_TRIBUTE_SIZE; // server is setup for 'presumed' Titanium value of 5..if Titanium::consts is changed, hard-code this to '5' until server/db is updated
+	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 = RoF2::consts::MAP_CORPSE_SIZE; // no bitmask use..limits to size of client corpse window (see EQLimits::InventoryMapSize(MapCorpse, <EQClientVersion))
+	static const uint16 MAP_BAZAAR_SIZE = Titanium::consts::MAP_BAZAAR_SIZE;
+	static const uint16 MAP_INSPECT_SIZE = RoF2::consts::MAP_INSPECT_SIZE;
+	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 = RoF::consts::MAP_KRONO_SIZE;
+	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 = RoF2::consts::EQUIPMENT_BEGIN;
+	static const int16 EQUIPMENT_END = RoF2::consts::EQUIPMENT_END;
+	static const uint16 EQUIPMENT_SIZE = RoF2::consts::EQUIPMENT_SIZE;
+
+	static const int16 GENERAL_BEGIN = RoF2::consts::GENERAL_BEGIN;
+	static const int16 GENERAL_END = RoF2::consts::GENERAL_END;
+	static const uint16 GENERAL_SIZE = RoF2::consts::GENERAL_SIZE;
+	static const int16 GENERAL_BAGS_BEGIN = RoF2::consts::GENERAL_BAGS_BEGIN;
+	static const int16 GENERAL_BAGS_END_OFFSET = RoF2::consts::GENERAL_BAGS_END_OFFSET;
+	static const int16 GENERAL_BAGS_END = RoF2::consts::GENERAL_BAGS_END;
+
+	static const int16 CURSOR_BAG_BEGIN = RoF2::consts::CURSOR_BAG_BEGIN;
+	static const int16 CURSOR_BAG_END_OFFSET = RoF2::consts::CURSOR_BAG_END_OFFSET;
+	static const int16 CURSOR_BAG_END = RoF2::consts::CURSOR_BAG_END;
+
+	static const int16 BANK_BEGIN = RoF2::consts::BANK_BEGIN;
+	static const int16 BANK_END = RoF2::consts::BANK_END;
+	static const int16 BANK_BAGS_BEGIN = RoF2::consts::BANK_BAGS_BEGIN;
+	static const int16 BANK_BAGS_END_OFFSET = RoF2::consts::BANK_BAGS_END_OFFSET;
+	static const int16 BANK_BAGS_END = RoF2::consts::BANK_BAGS_END;
+
+	static const int16 SHARED_BANK_BEGIN = RoF2::consts::SHARED_BANK_BEGIN;
+	static const int16 SHARED_BANK_END = RoF2::consts::SHARED_BANK_END;
+	static const int16 SHARED_BANK_BAGS_BEGIN = RoF2::consts::SHARED_BANK_BAGS_BEGIN;
+	static const int16 SHARED_BANK_BAGS_END_OFFSET = RoF2::consts::SHARED_BANK_BAGS_END_OFFSET;
+	static const int16 SHARED_BANK_BAGS_END = RoF2::consts::SHARED_BANK_BAGS_END;
+
+	static const int16 TRADE_BEGIN = RoF2::consts::TRADE_BEGIN;
+	static const int16 TRADE_END = RoF2::consts::TRADE_END;
+	static const int16 TRADE_NPC_END = RoF2::consts::TRADE_NPC_END;
+	static const int16 TRADE_NPC_SIZE = RoF2::consts::TRADE_NPC_SIZE;
+	static const int16 TRADE_BAGS_BEGIN = RoF2::consts::TRADE_BAGS_BEGIN;
+	static const int16 TRADE_BAGS_END_OFFSET = RoF2::consts::TRADE_BAGS_END_OFFSET;
+	static const int16 TRADE_BAGS_END = RoF2::consts::TRADE_BAGS_END;
+
+	static const int16 WORLD_BEGIN = RoF2::consts::WORLD_BEGIN;
+	static const int16 WORLD_END = RoF2::consts::WORLD_END;
+	static const int16 WORLD_SIZE = MAP_WORLD_SIZE;
+
+	static const int16 TRIBUTE_BEGIN = RoF2::consts::TRIBUTE_BEGIN;
+	static const int16 TRIBUTE_END = RoF2::consts::TRIBUTE_END;
+	static const int16 TRIBUTE_SIZE = MAP_TRIBUTE_SIZE;
+
+	static const int16 CORPSE_BEGIN = RoF2::consts::CORPSE_BEGIN;
+	static const int16 CORPSE_END = RoF2::consts::CORPSE_END;
+
+	static const int16 MATERIAL_BEGIN = Underfoot::consts::MATERIAL_BEGIN;
+	static const int16 MATERIAL_END = Underfoot::consts::MATERIAL_END;
+	static const int16 MATERIAL_TINT_END = Underfoot::consts::MATERIAL_TINT_END;
+	static const int16 MATERIAL_SIZE = Underfoot::consts::MATERIAL_SIZE;
+
+	// items
+	// common and container sizes will not increase until the new 'location' struct is implemented
+	static const uint16 ITEM_COMMON_SIZE = Underfoot::consts::ITEM_COMMON_SIZE;
+	static const uint16 ITEM_CONTAINER_SIZE = Underfoot::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;
+
+	// 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				IsValidClientVersion(uint32 version);
+	static uint32			ValidateClientVersion(uint32 version);
+	static EQClientVersion	ValidateClientVersion(EQClientVersion version);
+
+	// basically..any non-client classes - do not when setting a valid client
+	static bool				IsValidNPCVersion(uint32 version);
+	static uint32			ValidateNPCVersion(uint32 version);
+	static EQClientVersion	ValidateNPCVersion(EQClientVersion version);
+
+	// these are 'universal' - do not when setting a valid client
+	static bool				IsValidMobVersion(uint32 version);
+	static uint32			ValidateMobVersion(uint32 version);
+	static EQClientVersion	ValidateMobVersion(EQClientVersion version);
+
+	// inventory
+	static uint16	InventoryMapSize(int16 map, uint32 version);
+	static uint64	PossessionsBitmask(uint32 version);
+	static uint64	EquipmentBitmask(uint32 version);
+	static uint64	GeneralBitmask(uint32 version);
+	static uint64	CursorBitmask(uint32 version);
+
+	static bool	AllowsEmptyBagInBag(uint32 version);
+	static bool AllowsClickCastFromBag(uint32 version);
+
+	// items
+	static uint16	ItemCommonSize(uint32 version);
+	static uint16	ItemContainerSize(uint32 version);
+
+	// player profile
+	static bool	CoinHasWeight(uint32 version);
+
+	static uint32	BandoliersCount(uint32 version);
+	static uint32	BandolierSize(uint32 version);
+
+	static uint32	PotionBeltSize(uint32 version);
+};
+
+#endif /* EQ_LIMITS_H */
+
+/*
+Working Notes:
+--------------
+
+- full review of client_packet.cpp and client translators needed
+
+
+*/

common/eq_packet.cpp

@@ -19,10 +19,10 @@
 #include <stdio.h>
 #include <iostream>
 #include <iomanip>
-#include "EQPacket.h"
+#include "eq_packet.h"
 #include "misc.h"
 #include "op_codes.h"
-#include "CRC16.h"
+#include "crc16.h"
 #include "platform.h"
 #ifndef STATIC_OPCODE
 #include "opcodemgr.h"
@@ -476,7 +476,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];

common/eq_packet.h

@@ -18,8 +18,8 @@
 #ifndef _EQPACKET_H
 #define _EQPACKET_H
 
-#include "BasePacket.h"
-#include "EQStreamType.h"
+#include "base_packet.h"
+#include "eq_stream_type.h"
 #include "op_codes.h"
 #include "platform.h"
 
@@ -97,16 +97,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 +118,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; }
 
 };
 

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
@@ -533,7 +534,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;
@@ -688,7 +689,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 +721,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 +744,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 {
@@ -803,9 +800,12 @@ 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_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		= _SkillPacketArraySize;	// 100 - actual skills buffer size
 static const uint32 MAX_PP_AA_ARRAY		= 240;
 static const uint32 MAX_GROUP_MEMBERS	= 6;
@@ -883,7 +883,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 +922,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 +999,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 +1026,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;
@@ -1449,17 +1449,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 +1468,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*/
 };
 
 //
@@ -2280,10 +2293,13 @@ 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
@@ -3342,8 +3358,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 +3403,7 @@ struct Split_Struct
 */
 struct NewCombine_Struct {
 /*00*/	int16	container_slot;
-/*02*/	char	unknown02[2];
+/*02*/	int16	guildtribute_slot;
 /*04*/
 };
 
@@ -3461,6 +3477,7 @@ struct MerchantList {
 	int8	level_required;
 	uint16	alt_currency_cost;
 	uint32	classes_required;
+	uint8	probability;
 };
 
 struct TempMerchantList {
@@ -4053,7 +4070,7 @@ struct GroupInvite_Struct {
 //	uint8	unknown128[65];
 };
 
-struct BuffFadeMsg_Struct {
+struct ColoredText_Struct {
 	uint32 color;
 	char msg[1];
 };
@@ -4250,6 +4267,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
@@ -4288,9 +4312,9 @@ struct ControlBoat_Struct {
 
 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*/ uint8	window;			// window to display the information in
+/*005*/ uint8	unknown005[67];	// total packet length 72, all the rest were always 00
 /*072*/
 };
 
@@ -4453,6 +4477,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 +4602,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];
 };

common/eq_stream.cpp

@@ -17,12 +17,12 @@
 */
 
 #include "debug.h"
-#include "EQPacket.h"
-#include "EQStream.h"
+#include "eq_packet.h"
+#include "eq_stream.h"
 #include "misc.h"
-#include "Mutex.h"
+#include "mutex.h"
 #include "op_codes.h"
-#include "CRC16.h"
+#include "crc16.h"
 #include "platform.h"
 
 #include <string>
@@ -532,9 +532,12 @@ void EQStream::FastQueuePacket(EQApplicationPacket **p, bool ack_req)
 		return;
 	}
 
-	uint16 opcode = (*OpMgr)->EmuToEQ(pack->emu_opcode);
-
-	_log(NET__APP_TRACE, "Queueing %sacked packet with opcode 0x%x (%s) and length %d", ack_req?"":"non-", opcode, OpcodeManager::EmuToName(pack->emu_opcode), pack->size);
+	uint16 opcode = 0;
+	if(pack->GetOpcodeBypass() != 0) {
+		opcode = pack->GetOpcodeBypass();
+	} else {
+		opcode = (*OpMgr)->EmuToEQ(pack->emu_opcode);
+	}
 
 	if (!ack_req) {
 		NonSequencedPush(new EQProtocolPacket(opcode, pack->pBuffer, pack->size));
@@ -877,43 +880,6 @@ sockaddr_in address;
 	AddBytesSent(length);
 }
 
-/*
-commented out since im not sure theres a lot of merit in it.
-Really it was bitterness towards allocating a 2k buffer on the stack each call.
-Im sure the thought was client side, but even then, they will
-likely need a whole thread to call this method, in which case, they should
-supply the buffer so we dont re-allocate it each time.
-EQProtocolPacket *EQStream::Read(int eq_fd, sockaddr_in *from)
-{
-int socklen;
-int length=0;
-EQProtocolPacket *p=nullptr;
-char temp[15];
-
-	socklen=sizeof(sockaddr);
-#ifdef _WINDOWS
-	length=recvfrom(eq_fd, (char *)_tempBuffer, 2048, 0, (struct sockaddr*)from, (int *)&socklen);
-#else
-	length=recvfrom(eq_fd, _tempBuffer, 2048, 0, (struct sockaddr*)from, (socklen_t *)&socklen);
-#endif
-
-	if (length>=2) {
-		p=new EQProtocolPacket(_tempBuffer[1],&_tempBuffer[2],length-2);
-
-		uint32 ip=from->sin_addr.s_addr;
-		sprintf(temp,"%d.%d.%d.%d:%d",
-			*(unsigned char *)&ip,
-			*((unsigned char *)&ip+1),
-			*((unsigned char *)&ip+2),
-			*((unsigned char *)&ip+3),
-			ntohs(from->sin_port));
-		//std::cout << timestamp() << "Data from: " << temp << " OpCode 0x" << std::hex << std::setw(2) << std::setfill('0') << (int)p->opcode << std::dec << std::endl;
-		//dump_message(p->pBuffer,p->size,timestamp());
-
-	}
-	return p;
-}*/
-
 void EQStream::SendSessionResponse()
 {
 EQProtocolPacket *out=new EQProtocolPacket(OP_SessionResponse,nullptr,sizeof(SessionResponse));
@@ -1101,14 +1067,6 @@ EQProtocolPacket *p=nullptr;
 		SequencedQueue.clear();
 	}
 	MOutboundQueue.unlock();
-
-/*if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
-	_log(NET__ERROR, _L "Out-bound Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
-}
-if(NextSequencedSend > SequencedQueue.size()) {
-	_log(NET__ERROR, _L "Out-bound Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size());
-}*/
-	//NOTE: we prolly want to reset counters if we are stupposed to do anything after this.
 }
 
 void EQStream::PacketQueueClear()

common/eq_stream.h

@@ -9,13 +9,13 @@
 #ifndef WIN32
 #include <netinet/in.h>
 #endif
-#include "EQStreamType.h"
-#include "EQPacket.h"
-#include "EQStreamIntf.h"
-#include "Mutex.h"
+#include "eq_stream_type.h"
+#include "eq_packet.h"
+#include "eq_stream_intf.h"
+#include "mutex.h"
 #include "../common/opcodemgr.h"
 #include "../common/misc.h"
-#include "../common/Condition.h"
+#include "../common/condition.h"
 #include "../common/timer.h"
 
 #define FLAG_COMPRESSED	0x01

common/eq_stream_factory.cpp

@@ -1,5 +1,5 @@
 #include "debug.h"
-#include "EQStreamFactory.h"
+#include "eq_stream_factory.h"
 #ifdef _WINDOWS
 	#include <winsock.h>
 	#include <process.h>
@@ -16,7 +16,7 @@
 #include <fcntl.h>
 #include <iostream>
 #include "op_codes.h"
-#include "EQStream.h"
+#include "eq_stream.h"
 #include "logsys.h"
 
 ThreadReturnType EQStreamFactoryReaderLoop(void *eqfs)

common/eq_stream_factory.h

@@ -4,8 +4,8 @@
 
 #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"

common/eq_stream_ident.cpp

@@ -1,6 +1,6 @@
 #include "debug.h"
-#include "EQStreamIdent.h"
-#include "EQStreamProxy.h"
+#include "eq_stream_ident.h"
+#include "eq_stream_proxy.h"
 #include "logsys.h"
 
 EQStreamIdentifier::~EQStreamIdentifier() {

common/eq_stream_ident.h

@@ -1,7 +1,7 @@
 #ifndef EQSTREAMIDENT_H_
 #define EQSTREAMIDENT_H_
 
-#include "EQStream.h"
+#include "eq_stream.h"
 #include "timer.h"
 #include <vector>
 #include <string>

common/eq_stream_proxy.cpp

@@ -1,8 +1,8 @@
 
 #include "debug.h"
-#include "EQStreamProxy.h"
-#include "EQStream.h"
-#include "StructStrategy.h"
+#include "eq_stream_proxy.h"
+#include "eq_stream.h"
+#include "struct_strategy.h"
 
 
 EQStreamProxy::EQStreamProxy(EQStream *&stream, const StructStrategy *structs, OpcodeManager **opcodes)

common/eq_stream_proxy.h

@@ -3,7 +3,7 @@
 
 
 #include "types.h"
-#include "EQStreamIntf.h"
+#include "eq_stream_intf.h"
 
 class EQStream;
 class StructStrategy;

common/eqdb.cpp

@@ -16,7 +16,7 @@
 	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
 #include "debug.h"
-#include "EQDB.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

@@ -16,7 +16,7 @@
 	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
 #include "debug.h"
-#include "EQDBRes.h"
+#include "eqdb_res.h"
 #include <mysql.h>
 
 std::vector<std::string> EQDBRes::fetch_row_array() {

common/eqemu_config.cpp

@@ -16,8 +16,8 @@
 	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
 #include "../common/debug.h"
-#include "EQEmuConfig.h"
-#include "MiscFunctions.h"
+#include "eqemu_config.h"
+#include "misc_functions.h"
 #include <iostream>
 #include <sstream>
 

common/eqemu_config.h

@@ -18,7 +18,7 @@
 #ifndef __EQEmuConfig_H
 #define __EQEmuConfig_H
 
-#include "XMLParser.h"
+#include "xml_parser.h"
 #include "linked_list.h"
 
 struct LoginConfig {
@@ -112,14 +112,14 @@ protected:
 
 #define ELEMENT(name) \
 	void do_##name(TiXmlElement *ele);
-	#include "EQEmuConfig_elements.h"
+	#include "eqemu_config_elements.h"
 
 
 	EQEmuConfig() {
 		// import the needed handler prototypes
 #define ELEMENT(name) \
 		Handlers[#name]=(ElementHandler)&EQEmuConfig::do_##name;
-	#include "EQEmuConfig_elements.h"
+	#include "eqemu_config_elements.h"
 
 		// Set sane defaults
 

common/eqemu_error.cpp

@@ -18,10 +18,10 @@
 #ifdef _WINDOWS
 #include <windows.h>
 #endif
-#include "EQEMuError.h"
+#include "eqemu_error.h"
 #include "linked_list.h"
-#include "Mutex.h"
-#include "MiscFunctions.h"
+#include "mutex.h"
+#include "misc_functions.h"
 #include <stdio.h>
 #include <string.h>
 #ifdef _WINDOWS

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/guild_base.h

@@ -54,6 +54,7 @@ public:
 	bool	SetGuild(uint32 charid, uint32 guild_id, uint8 rank);
 	bool	SetGuildRank(uint32 charid, uint8 rank);
 	bool	SetBankerFlag(uint32 charid, bool is_banker);
+	bool	ForceRankUpdate(uint32 charid);
 	bool	GetAltFlag(uint32 CharID);
 	bool	SetAltFlag(uint32 charid, bool is_alt);
 	bool	GetBankerFlag(uint32 CharID);
@@ -108,7 +109,7 @@ protected:
 	bool	DBSetAltFlag(uint32 charid, bool is_alt);
 	bool	DBSetTributeFlag(uint32 charid, bool enabled);
 	bool	DBSetPublicNote(uint32 charid, const char *note);
-	bool	_RunQuery(char *&query, int len, const char *errmsg);
+	bool	QueryWithLogging(std::string query, const char *errmsg);
 //	void	DBSetPublicNote(uint32 guild_id,char* charname, char* note);
 
 	bool	LocalDeleteGuild(uint32 guild_id);

common/guilds.cpp

@@ -16,7 +16,7 @@
 	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
 #include "../common/debug.h"
-#include "MiscFunctions.h"
+#include "misc_functions.h"
 #include "guilds.h"
 #include "database.h"
 #include "eq_packet_structs.h"
@@ -24,318 +24,4 @@
 
 #ifndef WIN32
 #include <netinet/in.h>	//for htonl
-#endif
-
-/*
-void Database::GetGuildMembers(uint32 guild_id, GuildMember_Struct* gms){
-	char errbuf[MYSQL_ERRMSG_SIZE];
-	char *query = 0;
-	MYSQL_RES *result;
-	MYSQL_ROW row;
-	uint32 count=0;
-	uint32 length=0;
-	if (RunQuery(query, MakeAnyLenString(&query, "Select name,profile,timelaston,guildrank,publicnote from character_ where guild=%i", guild_id), errbuf, &result)) {
-		safe_delete_array(query);
-		while( ( row = mysql_fetch_row(result) ) ){
-			strcpy(gms->member[count].name,row[0]);
-			length+=strlen(row[0])+strlen(row[4]);
-			PlayerProfile_Struct* pps=(PlayerProfile_Struct*)row[1];
-			gms->member[count].level=htonl(pps->level);
-			gms->member[count].zoneid=(pps->zone_id*256);
-			gms->member[count].timelaston=htonl(atol(row[2]));
-			gms->member[count].class_=htonl(pps->class_);
-			gms->member[count].rank=atoi(row[3]);
-			strcpy(gms->member[count].publicnote,row[4]);
-			count++;
-		}
-		mysql_free_result(result);
-	}
-	else {
-		LogFile->write(EQEMuLog::Error, "Error in GetGuildMembers query '%s': %s", query, errbuf);
-		safe_delete_array(query);
-	}
-	gms->count=count;
-	gms->length=length;
-}
-
-uint32 Database::NumberInGuild(uint32 guild_id) {
-		char errbuf[MYSQL_ERRMSG_SIZE];
-		char *query = 0;
-		MYSQL_RES *result;
-		MYSQL_ROW row;
-
-	if (RunQuery(query, MakeAnyLenString(&query, "Select count(id) from character_ where guild=%i", guild_id), errbuf, &result)) {
-		safe_delete_array(query);
-		if (mysql_num_rows(result) == 1) {
-			row = mysql_fetch_row(result);
-			uint32 ret = atoi(row[0]);
-			mysql_free_result(result);
-			return ret;
-		}
-		mysql_free_result(result);
-	}
-	else {
-		LogFile->write(EQEMuLog::Error, "Error in NumberInGuild query '%s': %s", query, errbuf);
-		safe_delete_array(query);
-		return 0;
-	}
-	return 0;
-}
-bool Database::SetGuild(char* name, uint32 guild_id, uint8 guildrank) {
-	char errbuf[MYSQL_ERRMSG_SIZE];
-	char *query = 0;
-	uint32 affected_rows = 0;
-
-	if (RunQuery(query, MakeAnyLenString(&query, "UPDATE character_ SET guild=%i, guildrank=%i WHERE name='%s'", guild_id, guildrank, name), errbuf, 0, &affected_rows)) {
-		safe_delete_array(query);
-		if (affected_rows == 1)
-			return true;
-		else
-			return false;
-	}
-	else {
-		LogFile->write(EQEMuLog::Error, "Error in SetGuild query '%s': %s", query, errbuf);
-		safe_delete_array(query);
-		return false;
-	}
-	return false;
-}
-
-bool Database::SetGuild(uint32 charid, uint32 guild_id, uint8 guildrank) {
-	char errbuf[MYSQL_ERRMSG_SIZE];
-	char *query = 0;
-	uint32 affected_rows = 0;
-
-	if (RunQuery(query, MakeAnyLenString(&query, "UPDATE character_ SET guild=%i, guildrank=%i WHERE id=%i", guild_id, guildrank, charid), errbuf, 0, &affected_rows)) {
-		safe_delete_array(query);
-		if (affected_rows == 1)
-			return true;
-
-		else
-			return false;
-	}
-	else {
-		LogFile->write(EQEMuLog::Error, "Error in SetGuild query '%s': %s", query, errbuf);
-		safe_delete_array(query);
-		return false;
-	}
-
-	return false;
-}
-
-bool Database::DeleteGuild(uint32 guild_id)
-{
-	char errbuf[MYSQL_ERRMSG_SIZE];
-	char *query = 0;
-	char *query2 = 0;
-	uint32 affected_rows = 0;
-
-	if (RunQuery(query, MakeAnyLenString(&query, "DELETE FROM guilds WHERE id=%i;", guild_id), errbuf, 0, &affected_rows)) {
-		safe_delete_array(query);
-		if (affected_rows == 1) {
-			if(!RunQuery(query2, MakeAnyLenString(&query2, "update character_ set guild=0,guildrank=0 where guild=%i", guild_id), errbuf, 0, &affected_rows))
-				LogFile->write(EQEMuLog::Error, "Error in DeleteGuild cleanup query '%s': %s", query2, errbuf);
-			safe_delete_array(query2);
-			return true;
-		}
-		else
-			return false;
-	}
-	else {
-		LogFile->write(EQEMuLog::Error, "Error in DeleteGuild query '%s': %s", query, errbuf);
-		safe_delete_array(query);
-		return false;
-	}
-
-	return false;
-}
-
-bool Database::RenameGuild(uint32 guild_id, const char* name) {
-	char errbuf[MYSQL_ERRMSG_SIZE];
-	char *query = 0;
-	uint32 affected_rows = 0;
-	char buf[65];
-	DoEscapeString(buf, name, strlen(name)) ;
-
-	if (RunQuery(query, MakeAnyLenString(&query, "Update guilds set name='%s' WHERE id=%i;", buf, guild_id), errbuf, 0, &affected_rows)) {
-		safe_delete_array(query);
-		if (affected_rows == 1)
-			return true;
-		else
-			return false;
-	}
-	else {
-		LogFile->write(EQEMuLog::Error, "Error in RenameGuild query '%s': %s", query, errbuf);
-		safe_delete_array(query);
-		return false;
-	}
-
-	return false;
-}
-
-
-
-bool Database::EditGuild(uint32 guild_id, uint8 ranknum, GuildRankLevel_Struct* grl)
-{
-	char errbuf[MYSQL_ERRMSG_SIZE];
-	char *query = 0;
-	int chars = 0;
-	uint32 affected_rows = 0;
-	char buf[203];
-	char buf2[8];
-	DoEscapeString(buf, grl->rankname, strlen(grl->rankname)) ;
-	buf2[GUILD_HEAR] = grl->heargu + '0';
-	buf2[GUILD_SPEAK] = grl->speakgu + '0';
-	buf2[GUILD_INVITE] = grl->invite + '0';
-	buf2[GUILD_REMOVE] = grl->remove + '0';
-	buf2[GUILD_PROMOTE] = grl->promote + '0';
-	buf2[GUILD_DEMOTE] = grl->demote + '0';
-	buf2[GUILD_MOTD] = grl->motd + '0';
-	buf2[GUILD_WARPEACE] = grl->warpeace + '0';
-
-	if (ranknum == 0)
-		chars = MakeAnyLenString(&query, "Update guilds set rank%ititle='%s' WHERE id=%i;", ranknum, buf, guild_id);
-	else
-		chars = MakeAnyLenString(&query, "Update guilds set rank%ititle='%s', rank%i='%s' WHERE id=%i;", ranknum, buf, ranknum, buf2, guild_id);
-
-	if (RunQuery(query, chars, errbuf, 0, &affected_rows)) {
-		safe_delete_array(query);
-		if (affected_rows == 1)
-			return true;
-		else
-			return false;
-	}
-	else {
-		LogFile->write(EQEMuLog::Error, "Error in EditGuild query '%s': %s", query, errbuf);
-		safe_delete_array(query);
-		return false;
-	}
-
-	return false;
-}
-
-bool Database::GetGuildNameByID(uint32 guild_id, char * name) {
-	if (!name || !guild_id) return false;
-	char errbuf[MYSQL_ERRMSG_SIZE];
-	char *query = 0;
-	MYSQL_RES *result;
-	MYSQL_ROW row;
-
-	if (RunQuery(query, MakeAnyLenString(&query, "select name from guilds where id='%i'", guild_id), errbuf, &result)) {
-		safe_delete_array(query);
-		row = mysql_fetch_row(result);
-		if (row[0])
-			sprintf(name,"%s",row[0]);
-		mysql_free_result(result);
-		return true;
-	}
-	else {
-		LogFile->write(EQEMuLog::Error, "Error in GetGuildNameByID query '%s': %s", query, errbuf);
-		safe_delete_array(query);
-		return false;
-	}
-
-	return false;
-}
-
-uint32 Database::GetGuildIDbyLeader(uint32 leader)
-{
-	char errbuf[MYSQL_ERRMSG_SIZE];
-	char *query = 0;
-	MYSQL_RES *result;
-	MYSQL_ROW row;
-
-	if (RunQuery(query, MakeAnyLenString(&query, "SELECT id FROM guilds WHERE leader=%i", leader), errbuf, &result)) {
-		safe_delete_array(query);
-		if (mysql_num_rows(result) == 1)
-		{
-			row = mysql_fetch_row(result);
-			uint32 tmp = atoi(row[0]);
-			mysql_free_result(result);
-			return tmp;
-		}
-		mysql_free_result(result);
-	}
-	else {
-		LogFile->write(EQEMuLog::Error, "Error in Getguild_idbyLeader query '%s': %s", query, errbuf);
-		safe_delete_array(query);
-	}
-
-	return 0;
-}
-
-bool Database::SetGuildLeader(uint32 guild_id, uint32 leader)
-{
-	char errbuf[MYSQL_ERRMSG_SIZE];
-	char *query = 0;
-	uint32 affected_rows = 0;
-
-	if (RunQuery(query, MakeAnyLenString(&query, "UPDATE guilds SET leader=%i WHERE id=%i", leader, guild_id), errbuf, 0, &affected_rows)) {
-		safe_delete_array(query);
-		if (affected_rows == 1)
-			return true;
-		else
-			return false;
-	}
-	else {
-		LogFile->write(EQEMuLog::Error, "Error in SetGuildLeader query '%s': %s", query, errbuf);
-		safe_delete_array(query);
-		return false;
-	}
-
-	return false;
-}
-
-bool Database::SetGuildMOTD(uint32 guild_id, const char* motd) {
-	char errbuf[MYSQL_ERRMSG_SIZE];
-	char *query = 0;
-	char* motdbuf = 0;
-	uint32 affected_rows = 0;
-
-	motdbuf = new char[(strlen(motd)*2)+3];
-
-	DoEscapeString(motdbuf, motd, strlen(motd)) ;
-
-	if (RunQuery(query, MakeAnyLenString(&query, "Update guilds set motd='%s' WHERE id=%i;", motdbuf, guild_id), errbuf, 0, &affected_rows)) {
-		safe_delete_array(query);
-		delete motdbuf;
-		if (affected_rows == 1)
-			return true;
-		else
-			return false;
-	}
-	else
-	{
-		LogFile->write(EQEMuLog::Error, "Error in SetGuildMOTD query '%s': %s", query, errbuf);
-		safe_delete_array(query);
-		delete motdbuf;
-		return false;
-	}
-
-	return false;
-}
-
-string Database::GetGuildMOTD(uint32 guild_id)
-{
-	char errbuf[MYSQL_ERRMSG_SIZE];
-	char *query = 0;
-	MYSQL_RES *result;
-	MYSQL_ROW row;
-	string motd_str;
-	if (RunQuery(query, MakeAnyLenString(&query, "SELECT motd FROM guilds WHERE id=%i", guild_id), errbuf, &result)) {
-		safe_delete_array(query);
-		if (mysql_num_rows(result) == 1) {
-			row = mysql_fetch_row(result);
-			if (row[0])
-				motd_str = row[0];
-		}
-		mysql_free_result(result);
-	}
-	else {
-		LogFile->write(EQEMuLog::Error, "Error in GetGuildMOTD query '%s': %s", query, errbuf);
-		safe_delete_array(query);
-	}
-	return motd_str;
-}
-*/
-
+#endif

common/item.h

@@ -55,21 +55,6 @@ namespace ItemField
 	};
 };
 
-// Indexing positions to the beginning slot_id's for a bucket of slots
-#define IDX_EQUIP		0
-#define IDX_CURSOR_BAG	331
-#define IDX_INV			22
-#define IDX_INV_BAG		251
-#define IDX_TRIBUTE		400
-#define IDX_BANK		2000
-#define IDX_BANK_BAG	2031
-#define IDX_SHBANK		2500
-#define IDX_SHBANK_BAG	2531
-#define IDX_TRADE		3000
-#define IDX_TRADE_BAG	3031
-#define IDX_TRADESKILL	4000
-#define MAX_ITEMS_PER_BAG 10
-
 // Specifies usage type for item inside ItemInst
 enum ItemInstTypes
 {
@@ -136,8 +121,22 @@ public:
 	// Public Methods
 	///////////////////////////////
 
+	Inventory() { m_version = EQClientUnknown; m_versionset = false; }
 	~Inventory();
 
+	// Inventory v2 creep
+	bool SetInventoryVersion(EQClientVersion version) {
+		if (!m_versionset) {
+			m_version = version;
+			return (m_versionset = true);
+		}
+		else {
+			return false;
+		}
+	}
+
+	EQClientVersion GetInventoryVersion() { return m_version; }
+
 	static void CleanDirty();
 	static void MarkDirty(ItemInst *inst);
 
@@ -147,7 +146,7 @@ public:
 
 	inline iter_queue cursor_begin()	{ return m_cursor.begin(); }
 	inline iter_queue cursor_end()		{ return m_cursor.end(); }
-	inline bool CursorEmpty()		{ return (m_cursor.size() == 0); }
+	inline bool CursorEmpty()			{ return (m_cursor.size() == 0); }
 
 	// Retrieve a read-only item from inventory
 	inline const ItemInst* operator[](int16 slot_id) const { return GetItem(slot_id); }
@@ -187,6 +186,7 @@ public:
 
 	// Locate an available inventory slot
 	int16 FindFreeSlot(bool for_bag, bool try_cursor, uint8 min_size = 0, bool is_arrow = false);
+	int16 FindFreeSlotForTradeItem(const ItemInst* inst);
 
 	// Calculate slot_id for an item within a bag
 	static int16 CalcSlotId(int16 slot_id); // Calc parent bag's slot_id
@@ -197,6 +197,10 @@ public:
 
 	static bool CanItemFitInContainer(const Item_Struct *ItemToTry, const Item_Struct *Container);
 
+	//  Test for valid inventory casting slot
+	bool SupportsClickCasting(int16 slot_id);
+	bool SupportsPotionBeltCasting(int16 slot_id);
+
 	// Test whether a given slot can support a container item
 	static bool SupportsContainers(int16 slot_id);
 
@@ -243,7 +247,12 @@ protected:
 	std::map<int16, ItemInst*>	m_bank;		// Items in character bank
 	std::map<int16, ItemInst*>	m_shbank;	// Items in character shared bank
 	std::map<int16, ItemInst*>	m_trade;	// Items in a trade session
-	ItemInstQueue			m_cursor;	// Items on cursor: FIFO
+	ItemInstQueue				m_cursor;	// Items on cursor: FIFO
+
+private:
+	// Active inventory version
+	EQClientVersion m_version;
+	bool m_versionset;
 };
 
 class SharedDatabase;
@@ -288,6 +297,7 @@ public:
 	inline bool IsAugmentable() const { return m_item->AugSlotType[0]!=0 || m_item->AugSlotType[1]!=0 || m_item->AugSlotType[2]!=0 || m_item->AugSlotType[3]!=0 || m_item->AugSlotType[4]!=0; }
 	bool AvailableWearSlot(uint32 aug_wear_slots) const;
 	int8 AvailableAugmentSlot(int32 augtype) const;
+	bool IsAugmentSlotAvailable(int32 augtype, uint8 slot) const;
 	inline int32 GetAugmentType() const { return m_item->AugType; }
 
 	inline bool IsExpendable() const { return ((m_item->Click.Type == ET_Expendable ) || (m_item->ItemType == ItemTypePotion)); }
@@ -380,7 +390,7 @@ public:
 	bool IsActivated()					{ return m_activated; }
 	void SetActivated(bool activated)	{ m_activated = activated; }
 	int8 GetEvolveLvl() const			{ return m_evolveLvl; }
-	void SetScaling(bool v) { m_scaling = v; }
+	void SetScaling(bool v)				{ m_scaling = v; }
 
 	void Initialize(SharedDatabase *db = nullptr);
 	void ScaleItem();
@@ -428,9 +438,9 @@ protected:
 
 	//
 	// Items inside of this item (augs or contents);
-	std::map<uint8, ItemInst*> m_contents; // Zero-based index: min=0, max=9
-	std::map<std::string, std::string> m_custom_data;
-	std::map<std::string, Timer> m_timers;
+	std::map<uint8, ItemInst*>			m_contents; // Zero-based index: min=0, max=9
+	std::map<std::string, std::string>	m_custom_data;
+	std::map<std::string, Timer>		m_timers;
 };
 
 class EvolveInfo {

common/item_struct.h

@@ -42,7 +42,8 @@
  *	Made ya look! Ha!
  */
 
-#include "eq_constants.h"
+//#include "eq_constants.h"
+#include "eq_dictionary.h"
 
 /*
 ** Child struct of Item_Struct:
@@ -68,7 +69,8 @@ struct InternalSerializedItem_Struct {
 	const void * inst;
 };
 
-#define MAX_AUGMENT_SLOTS 5
+// use EmuConstants::ITEM_COMMON_SIZE
+//#define MAX_AUGMENT_SLOTS 5
 
 struct Item_Struct {
 	bool IsEquipable(uint16 Race, uint16 Class) const;
@@ -180,9 +182,9 @@ struct Item_Struct {
 	int32	FactionAmt4;	// Faction Amt 4
 	char	CharmFile[32];	// ?
 	uint32	AugType;
-	uint8	AugSlotType[MAX_AUGMENT_SLOTS];		// LDoN: Augment Slot 1-5 Type
-	uint8	AugSlotVisible[MAX_AUGMENT_SLOTS];	// LDoN: Augment Slot 1-5 Visible
-	uint8	AugSlotUnk2[MAX_AUGMENT_SLOTS];		// LDoN: Augment Slot 1-5 Unknown
+	uint8	AugSlotType[EmuConstants::ITEM_COMMON_SIZE];	// LDoN: Augment Slot 1-5 Type
+	uint8	AugSlotVisible[EmuConstants::ITEM_COMMON_SIZE];	// LDoN: Augment Slot 1-5 Visible
+	uint8	AugSlotUnk2[EmuConstants::ITEM_COMMON_SIZE];	// LDoN: Augment Slot 1-5 Unknown
 	uint32	LDoNTheme;
 	uint32	LDoNPrice;
 	uint32	LDoNSold;

common/logsys.cpp

@@ -22,7 +22,7 @@
 #include <stdio.h>
 #include <string.h>
 #include "misc.h"
-#include "EQPacket.h"
+#include "eq_packet.h"
 
 
 #define LOG_CATEGORY(category) #category ,

common/logsys.h

@@ -92,8 +92,8 @@ extern void log_raw_packet(LogType type, uint16 seq, const BasePacket *p);
 			class Mob;
 			extern void log_message_mob(LogType type, Mob *who, const char *fmt, ...);
 			#define mlog( type, format, ...) \
-				if(IsLoggingEnabled()) \
 				do { \
+				if(IsLoggingEnabled()) \
 					if(log_type_info[ type ].enabled) { \
 						log_message_mob(type, this, format, ##__VA_ARGS__); \
 					} \
@@ -150,16 +150,16 @@ extern void log_raw_packet(LogType type, uint16 seq, const BasePacket *p);
 	class Mob;
 	extern void log_hex_mob(LogType type, Mob *who, const char *data, uint32 length);
 	#define mhex( type, data, len) \
-		if(IsLoggingEnabled()) \
 		do { \
+		if(IsLoggingEnabled()) \
 			if(log_type_info[ type ].enabled) { \
 				log_hex_mob(type, this, data, len); \
 			} \
 		} while(false)
 	extern void log_packet_mob(LogType type, Mob *who, const BasePacket *p);
 	#define mpkt( type, packet) \
-		if(IsLoggingEnabled()) \
 		do { \
+		if(IsLoggingEnabled()) \
 			if(log_type_info[ type ].enabled) { \
 				log_packet_mob(type, this, packet); \
 			} \

common/logsys_eqemu.cpp

@@ -18,7 +18,7 @@
 
 #include "debug.h"
 #include "logsys.h"
-#include "StringUtil.h"
+#include "string_util.h"
 
 #include <stdarg.h>
 #include <stdio.h>
@@ -33,9 +33,7 @@ void log_message(LogType type, const char *fmt, ...) {
 }
 
 void log_messageVA(LogType type, const char *fmt, va_list args) {
-	std::string prefix_buffer;
-	
-	StringFormat(prefix_buffer, "[%s] ", log_type_info[type].name);
+	std::string prefix_buffer = StringFormat("[%s] ", log_type_info[type].name);
 	
 	LogFile->writePVA(EQEMuLog::Debug, prefix_buffer.c_str(), fmt, args);
 }

common/logtypes.h

@@ -60,11 +60,18 @@ LOG_TYPE( UCS, PACKETS, DISABLED)
 
 LOG_CATEGORY( QUERYSERV )
 LOG_TYPE( QUERYSERV, INIT, ENABLED )
-LOG_TYPE( QUERYSERV, ERROR, ENABLED )
+LOG_TYPE( QUERYSERV, ERROR, ENABLED ) 
 LOG_TYPE( QUERYSERV, CLIENT, DISABLED )
 LOG_TYPE( QUERYSERV, TRACE, DISABLED )
 LOG_TYPE( QUERYSERV, PACKETS, DISABLED)
 
+LOG_CATEGORY( SOCKET_SERVER)
+LOG_TYPE( SOCKET_SERVER, INIT, ENABLED)
+LOG_TYPE( SOCKET_SERVER, ERROR, ENABLED)
+LOG_TYPE( SOCKET_SERVER, CLIENT, DISABLED)
+LOG_TYPE( SOCKET_SERVER, TRACE, DISABLED)
+LOG_TYPE( SOCKET_SERVER, PACKETS, DISABLED)
+
 LOG_CATEGORY( SPAWNS )
 LOG_TYPE( SPAWNS, MAIN, DISABLED )
 LOG_TYPE( SPAWNS, CONDITIONS, DISABLED )
@@ -101,6 +108,7 @@ LOG_CATEGORY( FACTION )
 
 LOG_CATEGORY( ZONE )
 LOG_TYPE( ZONE, GROUND_SPAWNS, DISABLED )
+LOG_TYPE( ZONE, SPAWNS, ENABLED)
 LOG_TYPE( ZONE, INIT, ENABLED )
 LOG_TYPE( ZONE, INIT_ERR, ENABLED )
 LOG_TYPE( ZONE, WORLD, ENABLED )
@@ -109,7 +117,7 @@ LOG_TYPE( ZONE, WORLD_TRACE, DISABLED )
 
 LOG_CATEGORY( TASKS )
 LOG_TYPE( TASKS, GLOBALLOAD, DISABLED )
-LOG_TYPE( TASKS, CLIENTLOAD, DISABLED )
+LOG_TYPE( TASKS, CLIENTLOAD, DISABLED ) 
 LOG_TYPE( TASKS, UPDATE, DISABLED )
 LOG_TYPE( TASKS, CLIENTSAVE, DISABLED )
 LOG_TYPE( TASKS, PACKETS, DISABLED )

common/mail_oplist.h

@@ -1,13 +1,13 @@
 //Mail and Chat Channels
-N(OP_MailLogin),
-N(OP_Mail),
+N(OP_Buddy),
 N(OP_ChannelAnnounceJoin),
 N(OP_ChannelAnnounceLeave),
-N(OP_Buddy),
-N(OP_MailHeaderCount),
-N(OP_MailHeader),
-N(OP_MailSendBody),
-N(OP_MailNew),
-N(OP_MailDeliveryStatus),
-N(OP_MailboxChange),
 N(OP_Ignore),
+N(OP_Mail),
+N(OP_MailboxChange),
+N(OP_MailDeliveryStatus),
+N(OP_MailHeader),
+N(OP_MailHeaderCount),
+N(OP_MailLogin),
+N(OP_MailNew),
+N(OP_MailSendBody),

common/md5.cpp

@@ -9,7 +9,7 @@
 */
 #include <string.h> /* for memcpy() */
 #include "../common/md5.h"
-#include "../common/StringUtil.h"
+#include "../common/string_util.h"
 #include "../common/seperator.h"
 
 MD5::MD5() {

common/misc_functions.cpp

@@ -16,7 +16,7 @@
 	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
 #include "../common/debug.h"
-#include "MiscFunctions.h"
+#include "misc_functions.h"
 #include <string.h>
 #include <time.h>
 #include <math.h>
@@ -387,3 +387,26 @@ float EQHtoFloat(int d)
 {
 	return(360.0f - float((d * 360) >> 11));
 }
+
+// returns a swapped-bit value for use in client translator and inventory functions
+uint32 SwapBits21and22(uint32 mask)
+{
+	static const uint32 BIT21 = 1 << 21;
+	static const uint32 BIT22 = 1 << 22;
+	static const uint32 SWAPBITS = (BIT21 | BIT22);
+
+	if ((bool)(mask & BIT21) != (bool)(mask & BIT22))
+		mask ^= SWAPBITS;
+
+	return mask;
+}
+
+// returns an unset bit 22 value for use in client translators
+uint32 Catch22(uint32 mask)
+{
+	static const uint32 KEEPBITS = ~(1 << 22);
+
+	mask &= KEEPBITS;
+
+	return mask;
+}

common/misc_functions.h

@@ -102,8 +102,11 @@ int FloatToEQ13(float d);
 int NewFloatToEQ13(float d);
 int FloatToEQ19(float d);
 int FloatToEQH(float d);
+uint32 SwapBits21and22(uint32 mask);
+uint32 Catch22(uint32 mask);
 
-
+// macro to catch fp errors (provided by noudness)
+#define FCMP(a,b) (fabs(a-b) < FLT_EPSILON)
 
 #define _ITOA_BUFLEN	25
 const char *itoa(int num);	//not thread safe

common/mutex.cpp

@@ -16,7 +16,7 @@
 	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
 #include "../common/debug.h"
-#include "../common/Mutex.h"
+#include "../common/mutex.h"
 
 #include <iostream>
 

common/mysql_request_result.cpp

@@ -0,0 +1,139 @@
+#include "mysql_request_result.h"
+
+
+MySQLRequestResult::MySQLRequestResult()
+	: m_CurrentRow(), m_OneBeyondRow()
+{
+	ZeroOut();
+}
+
+MySQLRequestResult::MySQLRequestResult(MYSQL_RES* result, uint32 rowsAffected, uint32 rowCount, uint32 columnCount, uint32 lastInsertedID, uint32 errorNumber, char *errorBuffer)
+	: m_CurrentRow(result), m_OneBeyondRow()
+{
+	m_Result = result;
+	m_RowsAffected = rowsAffected;
+	m_RowCount = rowCount;
+	m_ColumnCount = columnCount;
+	m_LastInsertedID = lastInsertedID;
+
+	// If we actually need the column length / fields it will be
+	// requested at that time, no need to pull it in just to cache it.
+	// Normal usage would have it as nullptr most likely anyways.
+	m_ColumnLengths = nullptr;
+	m_Fields = nullptr;
+
+	m_Success = true;
+	if (errorBuffer != nullptr)
+		m_Success = false;
+
+	m_ErrorNumber = errorNumber;
+	m_ErrorBuffer = errorBuffer;
+}
+
+void MySQLRequestResult::FreeInternals()
+{
+
+	safe_delete_array(m_ErrorBuffer);
+
+	if (m_Result != nullptr)
+		mysql_free_result(m_Result);
+
+	ZeroOut();
+}
+
+void MySQLRequestResult::ZeroOut()
+{
+	m_Success = false;
+	m_Result = nullptr;
+	m_ErrorBuffer = nullptr;
+	m_ColumnLengths = nullptr;
+	m_Fields = nullptr;
+	m_RowCount = 0;
+	m_RowsAffected = 0;
+	m_LastInsertedID = 0;
+}
+
+MySQLRequestResult::~MySQLRequestResult()
+{
+	FreeInternals();
+}
+
+uint32 MySQLRequestResult::LengthOfColumn(int columnIndex)
+{
+	if (m_ColumnLengths == nullptr && m_Result != nullptr)
+		m_ColumnLengths = mysql_fetch_lengths(m_Result);
+
+	// If someone screws up and tries to get the length of a
+	// column when no result occured (check Success! argh!)
+	// then we always return 0. Also applies if mysql screws
+	// up and can't get the column lengths for whatever reason.
+	if (m_ColumnLengths == nullptr)
+		return 0;
+
+	// Want to index check to be sure we don't read passed
+	// the end of the array. Just default to 0 in that case.
+	// We *shouldn't* need this or the previous checks if all
+	// interface code is correctly written.
+	if (columnIndex >= m_ColumnCount)
+		return 0;
+
+	return m_ColumnLengths[columnIndex];
+}
+
+const std::string MySQLRequestResult::FieldName(int columnIndex)
+{
+	if (columnIndex >= m_ColumnCount || m_Result == nullptr)
+		return std::string();
+
+	if (m_Fields == nullptr)
+		m_Fields = mysql_fetch_fields(m_Result);
+
+	return std::string(m_Fields[columnIndex].name);
+}
+
+MySQLRequestResult::MySQLRequestResult(MySQLRequestResult&& moveItem)
+	: m_CurrentRow(moveItem.m_CurrentRow), m_OneBeyondRow()
+{
+	m_Result = moveItem.m_Result;
+	m_ErrorBuffer = moveItem.m_ErrorBuffer;
+	m_Success = moveItem.m_Success;
+	m_RowCount = moveItem.m_RowCount;
+	m_RowsAffected = moveItem.m_RowsAffected;
+	m_LastInsertedID = moveItem.m_LastInsertedID;
+	m_ColumnLengths = moveItem.m_ColumnLengths;
+	m_ColumnCount = moveItem.m_ColumnCount;
+	m_Fields = moveItem.m_Fields;
+
+	// Keeps deconstructor from double freeing
+	// pre move instance.
+	moveItem.ZeroOut();
+}
+
+MySQLRequestResult& MySQLRequestResult::operator=(MySQLRequestResult&& other)
+{
+	// Assigning something to itself?
+	// Silly! (but happens)
+	if (this == &other)
+		return *this;
+
+	FreeInternals();
+
+	m_Success = other.m_Success;
+
+	m_Result = other.m_Result;
+	m_ErrorBuffer = other.m_ErrorBuffer;
+
+	m_RowCount = other.m_RowCount;
+	m_RowsAffected = other.m_RowsAffected;
+	m_LastInsertedID = other.m_LastInsertedID;
+	m_CurrentRow = other.m_CurrentRow;
+	m_OneBeyondRow = other.m_OneBeyondRow;
+	m_ColumnLengths = other.m_ColumnLengths;
+	m_ColumnCount = other.m_ColumnCount;
+	m_Fields = other.m_Fields;
+
+	// Keeps deconstructor from double freeing
+	// pre move instance.
+	other.ZeroOut();
+	return *this;
+}

common/mysql_request_result.h

@@ -0,0 +1,63 @@
+#ifndef MYSQL_REQUEST_RESULT_H
+#define MYSQL_REQUEST_RESULT_H
+
+#ifdef _WINDOWS
+	#include <winsock.h>
+	#include <windows.h>
+#endif
+
+#include <mysql.h>
+#include "types.h"
+#include "mysql_request_row.h"
+#include <string>
+#include <string.h>
+#include <limits.h>
+
+class MySQLRequestResult {
+private:
+	MYSQL_RES* m_Result;
+	MYSQL_FIELD* m_Fields;
+	char* m_ErrorBuffer;
+	unsigned long* m_ColumnLengths;
+	MySQLRequestRow m_CurrentRow;
+	MySQLRequestRow m_OneBeyondRow;
+
+	bool m_Success;
+	uint32 m_RowsAffected;
+	uint32 m_RowCount;
+	uint32 m_ColumnCount;
+	uint32 m_LastInsertedID;
+	uint32 m_ErrorNumber;
+
+
+public:
+
+	MySQLRequestResult(MYSQL_RES* result, uint32 rowsAffected = 0, uint32 rowCount = 0, uint32 columnCount = 0, uint32 lastInsertedID = 0, uint32 errorNumber = 0, char *errorBuffer = nullptr);
+	MySQLRequestResult();	
+	MySQLRequestResult(MySQLRequestResult&& moveItem);
+	~MySQLRequestResult();
+
+	MySQLRequestResult& operator=(MySQLRequestResult&& other);
+
+	bool Success() const { return m_Success;}
+	std::string ErrorMessage() const {return m_ErrorBuffer ? std::string(m_ErrorBuffer) : std::string("");}
+	uint32 ErrorNumber() const {return m_ErrorNumber;}
+	uint32 RowsAffected() const {return m_RowsAffected;}
+	uint32 RowCount() const {return m_RowCount;}
+	uint32 ColumnCount() const {return m_ColumnCount;}
+	uint32 LastInsertedID() const {return m_LastInsertedID;}
+	// default to 0 index since we mostly use it that way anyways.
+	uint32 LengthOfColumn(int columnIndex = 0); 
+	const std::string FieldName(int columnIndex);
+
+	MySQLRequestRow& begin() { return m_CurrentRow; }
+	MySQLRequestRow& end() { return m_OneBeyondRow;}
+
+private:
+	void FreeInternals();
+	void ZeroOut();
+};
+
+
+#endif
+

common/mysql_request_row.cpp

@@ -0,0 +1,68 @@
+#include "mysql_request_row.h"
+
+MySQLRequestRow::MySQLRequestRow(const MySQLRequestRow& row)
+	: m_Result(row.m_Result), m_MySQLRow(row.m_MySQLRow)
+{
+}
+
+MySQLRequestRow::MySQLRequestRow()
+	: m_Result(nullptr), m_MySQLRow(nullptr)
+{
+}
+
+MySQLRequestRow::MySQLRequestRow(MySQLRequestRow&& moveItem)
+{
+	m_Result = moveItem.m_Result;
+	m_MySQLRow = moveItem.m_MySQLRow;
+
+	moveItem.m_Result = nullptr;
+	moveItem.m_MySQLRow = nullptr;
+}
+
+MySQLRequestRow& MySQLRequestRow::operator=(MySQLRequestRow& moveItem)
+{
+	m_Result = moveItem.m_Result;
+	m_MySQLRow = moveItem.m_MySQLRow;
+
+	moveItem.m_Result = nullptr;
+	moveItem.m_MySQLRow = nullptr;
+
+	return *this;
+}
+
+MySQLRequestRow::MySQLRequestRow(MYSQL_RES *result)
+	: m_Result(result)
+{
+    if (result != nullptr)
+        m_MySQLRow = mysql_fetch_row(result);
+    else
+        m_MySQLRow = nullptr;
+}
+
+MySQLRequestRow& MySQLRequestRow::operator++()
+{
+	m_MySQLRow = mysql_fetch_row(m_Result);
+	return *this;
+}
+
+MySQLRequestRow MySQLRequestRow::operator++(int)
+{
+	MySQLRequestRow tmp(*this);
+	operator++();
+	return tmp;
+}
+
+bool MySQLRequestRow::operator==(const MySQLRequestRow& rhs)
+{
+	return m_MySQLRow == rhs.m_MySQLRow;
+}
+
+bool MySQLRequestRow::operator!=(const MySQLRequestRow& rhs)
+{
+	return m_MySQLRow != rhs.m_MySQLRow;
+}
+
+char* MySQLRequestRow::operator[](int index)
+{
+	return m_MySQLRow[index];
+}

common/mysql_request_row.h

@@ -0,0 +1,38 @@
+#ifndef MYSQL_REQUEST_ROW_H
+#define MYSQL_REQUEST_ROW_H
+
+#ifdef _WINDOWS
+	#include <winsock.h>
+	#include <windows.h>
+#endif
+
+#include <mysql.h>
+#include <iterator>
+#include "types.h"
+
+class MySQLRequestRow : public std::iterator<std::input_iterator_tag, MYSQL_ROW>
+{
+
+private:
+	MYSQL_RES* m_Result;
+	MYSQL_ROW m_MySQLRow;
+
+public:
+
+	MySQLRequestRow();
+	MySQLRequestRow(MYSQL_RES *result);
+	MySQLRequestRow(const MySQLRequestRow& row);
+	MySQLRequestRow(MySQLRequestRow&& moveItem);
+	MySQLRequestRow& operator=(MySQLRequestRow& moveItem);
+	MySQLRequestRow& operator++();
+	MySQLRequestRow operator++(int);
+	bool operator==(const MySQLRequestRow& rhs);
+	bool operator!=(const MySQLRequestRow& rhs);
+
+	char* operator[](int index);
+
+};
+
+
+
+#endif

common/opcode_dispatch.h

@@ -305,7 +305,8 @@ OUTz(OP_FinishWindow2);
 //OUTv(OP_AdventureInfo, strlen(p)+1);
 //OUTv(OP_AdventureMerchantResponse, strlen(msg)+2);
 OUTv(OP_ItemPacket, ItemPacket_Struct);
-OUTv(OP_BuffFadeMsg, BuffFadeMsg_Struct);
+OUTv(OP_ColoredText, ColoredText_Struct);
+OUTv(OP_ItemRecastDelay, ItemRecastDelay_Struct);
 OUTv(OP_FormattedMessage, FormattedMessage_Struct);
 OUTv(OP_GuildMemberList, uint32);		//variable length, but nasty
 OUTv(OP_InterruptCast, InterruptCast_Struct);

common/opcode_map.cpp

@@ -160,7 +160,7 @@ void load_opcode_names()
 	opcode_map[0x0192]="LiveOP_YellForHelp";
 	opcode_map[0x00ef]="LiveOP_SafePoint";
 	opcode_map[0x0157]="LiveOP_Buff";
-	opcode_map[0x00c0]="LiveOP_BuffFadeMsg";
+	opcode_map[0x00c0]="LiveOP_ColoredText";
 	opcode_map[0x0440]="LiveOP_MultiLineMsg";
 	opcode_map[0x021c]="LiveOP_SpecialMesg";
 	opcode_map[0x0013]="LiveOP_Consent";

common/opcodemgr.h

@@ -20,7 +20,7 @@
 #define OPCODE_MANAGER_H
 
 #include "types.h"
-#include "Mutex.h"
+#include "mutex.h"
 #include "emu_opcodes.h"
 
 #include <map>

common/packet_dump.cpp

@@ -21,7 +21,7 @@
 #include <stdio.h>
 
 #include "packet_dump.h"
-#include "EQPacket.h"
+#include "eq_packet.h"
 #include "../common/servertalk.h"
 
 void DumpPacketAscii(const uchar* buf, uint32 size, uint32 cols, uint32 skip) {

common/packet_dump_file.cpp

@@ -35,7 +35,7 @@
 	#include <stdarg.h>
 #endif
 
-#include "EQStream.h"
+#include "eq_stream.h"
 #include "packet_dump_file.h"
 
 void FileDumpPacketAscii(const char* filename, const uchar* buf, uint32 size, uint32 cols, uint32 skip) {

common/patches/client62.h

@@ -1,8 +1,8 @@
 #ifndef CLIENT62_H_
 #define CLIENT62_H_
 
-#include "../StructStrategy.h"
-#include "../Item.h"
+#include "../struct_strategy.h"
+#include "../item.h"
 
 class EQStreamIdentifier;
 
@@ -27,8 +27,8 @@ namespace Client62 {
 		virtual const EQClientVersion ClientVersion() const;
 
 		//magic macro to declare our opcode processors
-		#include "SSDeclare.h"
-		#include "Client62_ops.h"
+		#include "ss_declare.h"
+		#include "client62_ops.h"
 
 	};
 

common/patches/client62_constants.h

@@ -0,0 +1,218 @@
+/*
+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 CLIENT62_CONSTANTS_H_
+#define CLIENT62_CONSTANTS_H_
+
+#include "../types.h"
+
+namespace Client62 {
+	namespace maps {
+		typedef enum : int16 {
+			// this needs work to match actual client equivilents
+			MapPossessions = 0,
+			MapBank,
+			MapSharedBank,
+			MapTrade,
+			MapWorld,
+			MapLimbo,
+			MapTribute,
+			MapTrophyTribute,
+			MapGuildTribute,
+			MapMerchant,
+			MapDeleted,
+			MapCorpse,
+			MapBazaar,
+			MapInspect,
+			MapRealEstate,
+			MapViewMODPC,
+			MapViewMODBank,
+			MapViewMODSharedBank,
+			MapViewMODLimbo,
+			MapAltStorage,
+			MapArchived,
+			MapMail,
+			MapGuildTrophyTribute,
+			MapOther,
+			_MapCount
+		} InventoryMaps;
+	}
+
+	namespace slots {
+		typedef enum : int16 {
+			MainCharm = 0,
+			MainEar1,
+			MainHead,
+			MainFace,
+			MainEar2,
+			MainNeck,
+			MainShoulders,
+			MainArms,
+			MainBack,
+			MainWrist1,
+			MainWrist2,
+			MainRange,
+			MainHands,
+			MainPrimary,
+			MainSecondary,
+			MainFinger1,
+			MainFinger2,
+			MainChest,
+			MainLegs,
+			MainFeet,
+			MainWaist,
+			MainAmmo,
+			MainGeneral1,
+			MainGeneral2,
+			MainGeneral3,
+			MainGeneral4,
+			MainGeneral5,
+			MainGeneral6,
+			MainGeneral7,
+			MainGeneral8,
+			MainCursor,
+			_MainCount,
+			_MainEquipmentBegin = MainCharm,
+			_MainEquipmentEnd = MainAmmo,
+			_MainEquipmentCount = (_MainEquipmentEnd - _MainEquipmentBegin + 1),
+			_MainGeneralBegin = MainGeneral1,
+			_MainGeneralEnd = MainGeneral8,
+			_MainGeneralCount = (_MainGeneralEnd - _MainGeneralBegin + 1)
+		} EquipmentSlots;
+	}
+
+	namespace consts {
+		static const uint16	MAP_POSSESSIONS_SIZE = slots::_MainCount;
+		static const uint16 MAP_BANK_SIZE = 16;
+		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; // 5 until verified otherwise
+		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 = slots::_MainCount;
+		static const uint16 MAP_BAZAAR_SIZE = 80;
+		static const uint16 MAP_INSPECT_SIZE = slots::_MainEquipmentCount;
+		static const uint16 MAP_REAL_ESTATE_SIZE = 0;
+		static const uint16 MAP_VIEW_MOD_PC_SIZE = MAP_POSSESSIONS_SIZE;
+		static const uint16 MAP_VIEW_MOD_BANK_SIZE = MAP_BANK_SIZE;
+		static const uint16 MAP_VIEW_MOD_SHARED_BANK_SIZE = MAP_SHARED_BANK_SIZE;
+		static const uint16 MAP_VIEW_MOD_LIMBO_SIZE = MAP_LIMBO_SIZE;
+		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 = NOT_USED;
+		static const uint16 MAP_OTHER_SIZE = 0;
+
+		static const int16 EQUIPMENT_BEGIN = slots::MainCharm;
+		static const int16 EQUIPMENT_END = slots::MainAmmo;
+		static const uint16 EQUIPMENT_SIZE = slots::_MainEquipmentCount;
+
+		static const int16 GENERAL_BEGIN = slots::MainGeneral1;
+		static const int16 GENERAL_END = slots::MainGeneral8;
+		static const uint16 GENERAL_SIZE = slots::_MainGeneralCount;
+		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 = slots::MainCursor;
+		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 = 2015;
+		static const int16 BANK_BAGS_BEGIN = 2031;
+		static const int16 BANK_BAGS_END_OFFSET = 159;
+		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_NPC_SIZE = 4;
+		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 TRIBUTE_BEGIN = 400;
+		static const int16 TRIBUTE_END = 404;
+
+		static const int16 CORPSE_BEGIN = slots::MainGeneral1;
+		static const int16 CORPSE_END = slots::MainGeneral1 + slots::MainCursor;
+
+		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;
+
+		static const uint16 ITEM_COMMON_SIZE = 5;
+		static const uint16 ITEM_CONTAINER_SIZE = 10;
+
+		static const uint32 BANDOLIERS_COUNT = 4;	// count = number of bandolier instances
+		static const uint32 BANDOLIER_SIZE = 4;		// size = number of equipment slots in bandolier instance
+		static const uint32 POTION_BELT_SIZE = 4;
+	}
+
+	namespace limits {
+		static const bool ALLOWS_EMPTY_BAG_IN_BAG = false;
+		static const bool ALLOWS_CLICK_CAST_FROM_BAG = false;
+		static const bool COIN_HAS_WEIGHT = true;
+	}
+
+};	//end namespace Client62
+
+#endif /*CLIENT62_CONSTANTS_H_*/
+
+/*
+Client62 Notes:
+	** Integer-based inventory **
+ok	Possessions: 0 - 30 (Corpse: 22 - 52 [Offset 22])
+ok		[Equipment: 0 - 21]
+ok		[General: 22 - 29]
+ok		[Cursor: 30]
+ok	General Bags: 251 - 330
+ok	Cursor Bags: 331 - 340
+
+ok	Bank: 2000 - 2015
+ok	Bank Bags: 2031 - 2190
+
+ok	Shared Bank: 2500 - 2501
+ok	Shared Bank Bags: 2531 - 2550
+
+	Trade: 3000 - 3007
+	(Trade Bags: 3031 - 3110 -- server values)
+
+	World: 4000 - 4009
+
+*/

common/patches/client62_ops.h

@@ -1,36 +1,54 @@
-
-//list of packets we need to encode on the way out:
+// out-going packets that require an ENCODE translation:
+E(OP_Action)
+E(OP_AdventureMerchantSell)
+E(OP_ApplyPoison)
+E(OP_BazaarSearch)
+E(OP_BecomeTrader)
+E(OP_CharInventory)
+E(OP_DeleteCharge)
+E(OP_DeleteItem)
+E(OP_DeleteSpawn)
+E(OP_GuildMemberLevelUpdate)
+E(OP_GuildMemberList)
+E(OP_Illusion)
+E(OP_ItemLinkResponse)
+E(OP_ItemPacket)
+E(OP_LeadershipExpUpdate)
+E(OP_LootItem)
+E(OP_MoveItem)
+E(OP_NewSpawn)
+E(OP_OnLevelMessage)
+E(OP_PetBuffWindow)
+E(OP_PlayerProfile)
+E(OP_ReadBook)
+E(OP_RespondAA)
 E(OP_SendAATable)
 E(OP_SendCharInfo)
-E(OP_LeadershipExpUpdate)
-E(OP_PlayerProfile)
-E(OP_NewSpawn)
-E(OP_ZoneSpawns)
-E(OP_ZoneEntry)
-E(OP_ItemPacket)
-E(OP_ItemLinkResponse)
-E(OP_CharInventory)
-E(OP_GuildMemberList)
-E(OP_ZoneServerReady)
-E(OP_GuildMemberLevelUpdate)
-E(OP_ReadBook)
-E(OP_Illusion)
+E(OP_ShopPlayerSell)
 E(OP_Track)
-E(OP_BazaarSearch)
-E(OP_RespondAA)
-E(OP_DeleteSpawn)
+E(OP_TributeItem)
 E(OP_WearChange)
-E(OP_Action)
-E(OP_BecomeTrader)
-E(OP_PetBuffWindow)
-E(OP_OnLevelMessage)
-//list of packets we need to decode on the way in:
-D(OP_SetServerFilter)
+E(OP_ZoneEntry)
+E(OP_ZoneServerReady)
+E(OP_ZoneSpawns)
+// incoming packets that require a DECODE translation:
+D(OP_AdventureMerchantSell)
+D(OP_ApplyPoison)
+D(OP_AugmentItem)
+D(OP_CastSpell)
 D(OP_CharacterCreate)
-D(OP_ItemLinkClick)
-D(OP_WhoAllRequest)
-D(OP_ReadBook)
+D(OP_Consume)
+D(OP_DeleteItem)
 D(OP_FaceChange)
+D(OP_ItemLinkClick)
+D(OP_LootItem)
+D(OP_MoveItem)
+D(OP_ReadBook)
+D(OP_SetServerFilter)
+D(OP_ShopPlayerSell)
+D(OP_TradeSkillCombine)
+D(OP_TributeItem)
 D(OP_WearChange)
+D(OP_WhoAllRequest)
 #undef E
 #undef D