Exports continue, mob and some constants

The server code is unsigned for bad reasons :P

.gitignore

@@ -23,24 +23,20 @@ CMakeFiles
 Makefile
 cmake_install.cmake
 install_manifest.txt
-[Bb]uild/
-[Bb]uild32/
-[Bb]uild64/
-[Bb]uild_32/
-[Bb]uild_64/
-deploy/server/
+Build/
+build/
+Build32/
+build32/
+Build64/
+build64/
+Build_32/
+build_32/
+Build_64/
+build_64/
 x64/
 x86/
 log/
 logs/
+vcpkg/
 
-docker/db
-
-# Protobuf generated files
-*.pb.cc
-*.pb.h
-protobuf/csharp/*
-protobuf/go/*
-protobuf/java/*
-protobuf/python/*
-.vscode
+.idea/*

.travis.yml

@@ -1,32 +1,27 @@
 language: cpp
 compiler: gcc
-sudo: false
-addons:
-  apt:
-    sources:
-    - ubuntu-toolchain-r-test
-    packages:
-    - gcc-4.8
-    - g++-4.8
-    - libmysqlclient-dev
-    - libperl-dev
-    - libboost-dev
-    - liblua5.1-0-dev
-    - zlib1g-dev
-    - uuid-dev
-    - libssl-dev
+dist: trusty
+
+before_install:
+  - sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test
+  - sudo apt-get update -qq
+  - mkdir $HOME/usr
+  - export PATH="$HOME/usr/bin:$PATH"
+  - wget https://cmake.org/files/v3.11/cmake-3.11.2-Linux-x86_64.sh
+  - chmod +x cmake-3.11.2-Linux-x86_64.sh
+  - ./cmake-3.11.2-Linux-x86_64.sh --prefix=$HOME/usr --exclude-subdir --skip-license
+
 install:
-  - if [ "$CXX" = "g++" ]; then export CXX="g++-4.8" CC="gcc-4.8"; fi
+  - sudo apt-get install -qq g++-7
+  - sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-7 90
+  - sudo apt-get install libmysqlclient-dev
+  - sudo apt-get install libperl-dev
+  - sudo apt-get install libboost-dev
+  - sudo apt-get install liblua5.1-0-dev
+  - sudo apt-get install zlib1g-dev
+  - sudo apt-get install uuid-dev
+  - sudo apt-get install libssl-dev  
 script:
   - cmake -G "Unix Makefiles" -DEQEMU_BUILD_TESTS=ON -DEQEMU_ENABLE_BOTS=ON -DEQEMU_BUILD_LOGIN=ON
   - make -j2
   - ./bin/tests
-branches:
-  only:
-    - master
-    - stable
-notifications:
-  email: false
-  irc:
-    channels: "irc.eqemulator.net#eqemucoders"
-os: linux

CMakeLists.txt

@@ -27,9 +27,7 @@
 #EQEMU_USE_MAP_MMFS
 #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!
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8.12)
+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})
@@ -42,6 +40,8 @@ IF(NOT CMAKE_BUILD_TYPE)
 	SET(CMAKE_BUILD_TYPE RelWithDebInfo CACHE STRING "Choose the type of build." FORCE)
 ENDIF(NOT CMAKE_BUILD_TYPE)
 
+SET(CMAKE_PREFIX_PATH "${CMAKE_CURRENT_SOURCE_DIR}/dependencies" "${CMAKE_PREFIX_PATH}")
+
 #Add our various windows definitions
 IF(MSVC OR MINGW)
 	ADD_DEFINITIONS(-D_WINDOWS)
@@ -52,75 +52,7 @@ IF(MSVC OR MINGW)
 	ENDIF(CMAKE_CL_64)
 ENDIF(MSVC OR MINGW)
 
-# include dirs are universal
-SET(NATS_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/nats")
-
-#Try to find protobuf automatically
-FIND_PACKAGE(Protobuf QUIET)
-#IF(NOT PROTOBUF_FOUND)
-	SET(Protobuf_DIR "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/protobuf" CACHE PATH "Root protobuf directory" FORCE)
-	SET(PROTOBUF_FOUND TRUE CACHE BOOL "" FORCE)
-	IF(MSVC)
-		IF(CMAKE_CL_64)		
-			SET(Protobuf_INCLUDE_DIR "${Protobuf_DIR}/windows/x64/include" CACHE PATH "Include dir" FORCE)
-			SET(Protobuf_SRC_ROOT_FOLDER "${Protobuf_DIR}/windows/x64/include" CACHE PATH "Include dir" FORCE)
-			SET(Protobuf_PROTOC_EXECUTABLE  "${Protobuf_DIR}/windows/x64/bin/protoc.exe" CACHE PATH "Executable path" FORCE)	
-			SET(Protobuf_LIBRARY_DEBUG "${Protobuf_DIR}/windows/x64/lib/libprotobufd.lib" CACHE PATH "Root protobuf directory" FORCE)
-			SET(Protobuf_LIBRARY_RELEASE "${Protobuf_DIR}/windows/x64/lib/libprotobufd.lib" CACHE PATH "Root protobuf directory" FORCE)		
-		ELSE(CMAKE_CL_64)			
-			SET(Protobuf_INCLUDE_DIR "${Protobuf_DIR}/windows/x86/include" CACHE PATH "Include dir" FORCE)
-			SET(Protobuf_SRC_ROOT_FOLDER "${Protobuf_DIR}/windows/x86/include" CACHE PATH "Include dir" FORCE)
-			SET(Protobuf_PROTOC_EXECUTABLE  "${Protobuf_DIR}/windows/x86/bin/protoc.exe" CACHE PATH "Executable path" FORCE)	
-			SET(Protobuf_LIBRARY_DEBUG "${Protobuf_DIR}/windows/x86/lib/libprotobufd.lib" CACHE PATH "Root protobuf directory" FORCE)
-			SET(Protobuf_LIBRARY_RELEASE "${Protobuf_DIR}/windows/x86/lib/libprotobufd.lib" CACHE PATH "Root protobuf directory" FORCE)		
-		ENDIF(CMAKE_CL_64)
-	ELSE(MSVC)
-		IF(CMAKE_CL_64)
-			SET(Protobuf_INCLUDE_DIR "${Protobuf_DIR}/linux/x86/include" CACHE PATH "Include dir" FORCE)
-			SET(Protobuf_SRC_ROOT_FOLDER "${Protobuf_DIR}/linux/x86/include" CACHE PATH "Include dir" FORCE)
-			SET(Protobuf_PROTOC_EXECUTABLE  "${Protobuf_DIR}/linux/x86/bin/protoc" CACHE PATH "Executable path" FORCE)	
-			SET(Protobuf_LIBRARY_DEBUG "${Protobuf_DIR}/linux/x86/lib/libprotobuf.so.16" CACHE PATH "Root protobuf directory" FORCE)
-			SET(Protobuf_LIBRARY_RELEASE "${Protobuf_DIR}/linux/x86/lib/libprotobuf.so.16" CACHE PATH "Root protobuf directory" FORCE)				
-		ELSE(CMAKE_CL_64)
-			SET(Protobuf_INCLUDE_DIR "${Protobuf_DIR}/linux/x64/include" CACHE PATH "Include dir" FORCE)
-			SET(Protobuf_SRC_ROOT_FOLDER "${Protobuf_DIR}/linux/x64/include" CACHE PATH "Include dir" FORCE)
-			SET(Protobuf_PROTOC_EXECUTABLE  "${Protobuf_DIR}/linux/x64/bin/protoc" CACHE PATH "Executable path" FORCE)	
-			SET(Protobuf_LIBRARY_DEBUG "${Protobuf_DIR}/linux/x64/lib/libprotobuf.so.16" CACHE PATH "Root protobuf directory" FORCE)
-			SET(Protobuf_LIBRARY_RELEASE "${Protobuf_DIR}/linux/x64/lib/libprotobuf.so.16" CACHE PATH "Root protobuf directory" FORCE)	
-		ENDIF(CMAKE_CL_64)	
-	ENDIF()
-	IF(NOT Protobuf_LIBRARY_DEBUG)
-		MESSAGE(ERROR "Protobuf library was not found in ${Protobuf_LIBRARY_DEBUG}. Please download the depenencies and extract them as noted.")
-	ENDIF()
-	FILE(COPY ${Protobuf_LIBRARY_DEBUG} DESTINATION ${CMAKE_HOME_DIRECTORY}/bin)	
-#ENDIF()
-
-INCLUDE_DIRECTORIES(SYSTEM "${Protobuf_INCLUDE_DIR}")
-
 IF(MSVC)
-	IF(CMAKE_CL_64)
-		SET(NATS_INCLUDE_DIR "${NATS_ROOT}/windows/x64/include")
-		SET(NATS_LIBRARY_DEBUG "${NATS_ROOT}/windows/x64/lib/nats.lib")
-	ELSE(CMAKE_CL_64)	
-		SET(NATS_INCLUDE_DIR "${NATS_ROOT}/windows/x86/include")
-		SET(NATS_LIBRARY_DEBUG "${NATS_ROOT}/windows/x86/lib/nats.lib")
-	ENDIF(CMAKE_CL_64)
-ELSE(MSVC)
-	IF(CMAKE_CL_64)
-		SET(NATS_INCLUDE_DIR "${NATS_ROOT}/linux/x86/include")
-		SET(NATS_LIBRARY_DEBUG "${NATS_ROOT}/linux/x86/lib/libnats.so")
-	ELSE(CMAKE_CL_64)			
-		SET(NATS_INCLUDE_DIR "${NATS_ROOT}/linux/x64/include")
-		SET(NATS_LIBRARY_DEBUG "${NATS_ROOT}/linux/x64/lib/libnats.so")
-	ENDIF(CMAKE_CL_64)
-ENDIF()
-IF(${NATS_LIBRARY_DEBUG})
-	MESSAGE(ERROR " NATS library was not found in ${NATS_LIBRARY_DEBUG}/libnats.so. Please download the depenencies and extract them as noted.")
-ENDIF()
-FILE(COPY ${NATS_LIBRARY_DEBUG} DESTINATION ${CMAKE_HOME_DIRECTORY}/bin)	
-
-IF(MSVC)
-	#Set our default locations for zlib/mysql based on x86/x64
 	IF(CMAKE_CL_64)
 		SET(ZLIB_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/zlib_x64")
 		SET(MYSQL_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/mysql_x64")
@@ -140,7 +72,6 @@ IF(MSVC)
 		SET(LUA_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/luaj_x86")
 		SET(SODIUM_INCLUDE_HINTS "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/libsodium/include")
 		SET(OPENSSL_ROOT_DIR "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/openssl_x86")
-		SET(NATS_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/nats_x86")
 		IF(MSVC_VERSION GREATER 1800)
 			SET(SODIUM_LIBRARY_HINTS "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/libsodium/Win32/Release/v140/dynamic")
 		ELSEIF(MSVC_VERSION EQUAL 1800)
@@ -168,23 +99,6 @@ IF(MSVC)
 		ADD_DEFINITIONS(-DCRASH_LOGGING)
 	ENDIF(EQEMU_ENABLE_CRASH_LOGGING)
 
-	#Disable safe SEH or not?
-	OPTION(EQEMU_DISABLE_SAFESEH "Disable Safe SEH (Needed for Strawberry Perl)" OFF)
-	IF(EQEMU_DISABLE_SAFESEH)
-		SET(CMAKE_EXE_LINKER_FLAGS_DEBUG "${CMAKE_EXE_LINKER_FLAGS_DEBUG} /SAFESEH:NO")
-		SET(CMAKE_EXE_LINKER_FLAGS_MINSIZEREL "${CMAKE_EXE_LINKER_FLAGS_MINSIZEREL} /SAFESEH:NO")
-		SET(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} /SAFESEH:NO")
-		SET(CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO "${CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO} /SAFESEH:NO")
-		SET(CMAKE_SHARED_LINKER_FLAGS_DEBUG "${CMAKE_SHARED_LINKER_FLAGS_DEBUG} /SAFESEH:NO")
-		SET(CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL "${CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL} /SAFESEH:NO")
-		SET(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} /SAFESEH:NO")
-		SET(CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO "${CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO} /SAFESEH:NO")
-		SET(CMAKE_MODULE_LINKER_FLAGS_DEBUG "${CMAKE_MODULE_LINKER_FLAGS_DEBUG} /SAFESEH:NO")
-		SET(CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL "${CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL} /SAFESEH:NO")
-		SET(CMAKE_MODULE_LINKER_FLAGS_RELEASE "${CMAKE_MODULE_LINKER_FLAGS_RELEASE} /SAFESEH:NO")
-		SET(CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO "${CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO} /SAFESEH:NO")
-	ENDIF(EQEMU_DISABLE_SAFESEH)
-
 	OPTION(EQEMU_BUILD_MSVC_MP "Enable build with multiple processes." ON)
 	IF(EQEMU_BUILD_MSVC_MP)
 		SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MP")
@@ -199,8 +113,6 @@ IF(MSVC)
 
 	ADD_DEFINITIONS(-DNOMINMAX)
 ELSE(MSVC)
-	
-
 	#Normally set by perl but we don't use the perl flags anymore so we set it.
 	ADD_DEFINITIONS(-DHAS_UNION_SEMUN)
 ENDIF(MSVC)
@@ -349,6 +261,9 @@ IF(EQEMU_BUILD_PERL)
 ENDIF(EQEMU_BUILD_PERL)
 IF(EQEMU_BUILD_LUA)
 	ADD_DEFINITIONS(-DLUA_EQEMU)
+	IF(MSVC) 
+		ADD_DEFINITIONS(/bigobj)
+	ENDIF()
 ENDIF(EQEMU_BUILD_LUA)
 
 OPTION(EQEMU_USE_MAP_MMFS "Create and use Zone Map MMF files." OFF)
@@ -379,7 +294,7 @@ IF(EQEMU_BUILD_PERL)
 	INCLUDE_DIRECTORIES(SYSTEM "${PERL_INCLUDE_PATH}")
 ENDIF(EQEMU_BUILD_PERL)
 
-SET(SERVER_LIBS common debug ${MySQL_LIBRARY_DEBUG} optimized ${MySQL_LIBRARY_RELEASE} ${ZLIB_LIBRARY} libuv fmt ${NATS_LIBRARY_DEBUG} ${PROTOBUF_LIBRARY_DEBUG})
+SET(SERVER_LIBS common debug ${MySQL_LIBRARY_DEBUG} optimized ${MySQL_LIBRARY_RELEASE} ${ZLIB_LIBRARY} libuv fmt recast_navigation)
 
 FIND_PACKAGE(Sodium REQUIRED)
 IF(SODIUM_FOUND)
@@ -412,7 +327,8 @@ IF(EQEMU_BUILD_LUA)
 
 	FIND_PACKAGE(Boost REQUIRED)
 	INCLUDE_DIRECTORIES(SYSTEM "${LUA_INCLUDE_DIR}" "${Boost_INCLUDE_DIRS}")
-	INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/luabind")
+	INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/libs/luabind")
+	INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/libs/sol")
 
 	OPTION(EQEMU_SANITIZE_LUA_LIBS "Sanitize Lua Libraries (Remove OS and IO standard libraries from being able to run)." ON)
 	IF(EQEMU_SANITIZE_LUA_LIBS)
@@ -422,14 +338,13 @@ ENDIF(EQEMU_BUILD_LUA)
 
 INCLUDE_DIRECTORIES(SYSTEM "${ZLIB_INCLUDE_DIRS}")
 INCLUDE_DIRECTORIES(SYSTEM "${MySQL_INCLUDE_DIR}")
-INCLUDE_DIRECTORIES(SYSTEM "${NATS_INCLUDE_DIR}")
-
 INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/common/glm")
 INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/libs/cereal")
 INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/libs/libuv/include" )
 INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/libs/libuv/src")
 INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/libs/format")
-
+INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/libs/recast/detour/include")
+INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/libs/recast/recast/include")
 
 IF(EQEMU_BUILD_SERVER OR EQEMU_BUILD_LOGIN OR EQEMU_BUILD_TESTS OR EQEMU_BUILD_HC)
 	ADD_SUBDIRECTORY(common)

LICENSE

@@ -1,165 +1,674 @@
-                   GNU LESSER GENERAL PUBLIC LICENSE
+                    GNU GENERAL PUBLIC LICENSE
                        Version 3, 29 June 2007
 
- Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
  Everyone is permitted to copy and distribute verbatim copies
  of this license document, but changing it is not allowed.
 
+                            Preamble
 
-  This version of the GNU Lesser General Public License incorporates
-the terms and conditions of version 3 of the GNU General Public
-License, supplemented by the additional permissions listed below.
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
 
-  0. Additional Definitions.
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
 
-  As used herein, "this License" refers to version 3 of the GNU Lesser
-General Public License, and the "GNU GPL" refers to version 3 of the GNU
-General Public License.
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
 
-  "The Library" refers to a covered work governed by this License,
-other than an Application or a Combined Work as defined below.
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
 
-  An "Application" is any work that makes use of an interface provided
-by the Library, but which is not otherwise based on the Library.
-Defining a subclass of a class defined by the Library is deemed a mode
-of using an interface provided by the Library.
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
 
-  A "Combined Work" is a work produced by combining or linking an
-Application with the Library.  The particular version of the Library
-with which the Combined Work was made is also called the "Linked
-Version".
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
 
-  The "Minimal Corresponding Source" for a Combined Work means the
-Corresponding Source for the Combined Work, excluding any source code
-for portions of the Combined Work that, considered in isolation, are
-based on the Application, and not on the Linked Version.
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
 
-  The "Corresponding Application Code" for a Combined Work means the
-object code and/or source code for the Application, including any data
-and utility programs needed for reproducing the Combined Work from the
-Application, but excluding the System Libraries of the Combined Work.
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
 
-  1. Exception to Section 3 of the GNU GPL.
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
 
-  You may convey a covered work under sections 3 and 4 of this License
-without being bound by section 3 of the GNU GPL.
+  The precise terms and conditions for copying, distribution and
+modification follow.
 
-  2. Conveying Modified Versions.
+                       TERMS AND CONDITIONS
 
-  If you modify a copy of the Library, and, in your modifications, a
-facility refers to a function or data to be supplied by an Application
-that uses the facility (other than as an argument passed when the
-facility is invoked), then you may convey a copy of the modified
-version:
+  0. Definitions.
 
-   a) under this License, provided that you make a good faith effort to
-   ensure that, in the event an Application does not supply the
-   function or data, the facility still operates, and performs
-   whatever part of its purpose remains meaningful, or
+  "This License" refers to version 3 of the GNU General Public License.
 
-   b) under the GNU GPL, with none of the additional permissions of
-   this License applicable to that copy.
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
 
-  3. Object Code Incorporating Material from Library Header Files.
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
 
-  The object code form of an Application may incorporate material from
-a header file that is part of the Library.  You may convey such object
-code under terms of your choice, provided that, if the incorporated
-material is not limited to numerical parameters, data structure
-layouts and accessors, or small macros, inline functions and templates
-(ten or fewer lines in length), you do both of the following:
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
 
-   a) Give prominent notice with each copy of the object code that the
-   Library is used in it and that the Library and its use are
-   covered by this License.
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
 
-   b) Accompany the object code with a copy of the GNU GPL and this license
-   document.
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
 
-  4. Combined Works.
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
 
-  You may convey a Combined Work under terms of your choice that,
-taken together, effectively do not restrict modification of the
-portions of the Library contained in the Combined Work and reverse
-engineering for debugging such modifications, if you also do each of
-the following:
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
 
-   a) Give prominent notice with each copy of the Combined Work that
-   the Library is used in it and that the Library and its use are
-   covered by this License.
+  1. Source Code.
 
-   b) Accompany the Combined Work with a copy of the GNU GPL and this license
-   document.
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
 
-   c) For a Combined Work that displays copyright notices during
-   execution, include the copyright notice for the Library among
-   these notices, as well as a reference directing the user to the
-   copies of the GNU GPL and this license document.
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
 
-   d) Do one of the following:
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
 
-       0) Convey the Minimal Corresponding Source under the terms of this
-       License, and the Corresponding Application Code in a form
-       suitable for, and under terms that permit, the user to
-       recombine or relink the Application with a modified version of
-       the Linked Version to produce a modified Combined Work, in the
-       manner specified by section 6 of the GNU GPL for conveying
-       Corresponding Source.
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
 
-       1) Use a suitable shared library mechanism for linking with the
-       Library.  A suitable mechanism is one that (a) uses at run time
-       a copy of the Library already present on the user's computer
-       system, and (b) will operate properly with a modified version
-       of the Library that is interface-compatible with the Linked
-       Version.
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
 
-   e) Provide Installation Information, but only if you would otherwise
-   be required to provide such information under section 6 of the
-   GNU GPL, and only to the extent that such information is
-   necessary to install and execute a modified version of the
-   Combined Work produced by recombining or relinking the
-   Application with a modified version of the Linked Version. (If
-   you use option 4d0, the Installation Information must accompany
-   the Minimal Corresponding Source and Corresponding Application
-   Code. If you use option 4d1, you must provide the Installation
-   Information in the manner specified by section 6 of the GNU GPL
-   for conveying Corresponding Source.)
+  The Corresponding Source for a work in source code form is that
+same work.
 
-  5. Combined Libraries.
+  2. Basic Permissions.
 
-  You may place library facilities that are a work based on the
-Library side by side in a single library together with other library
-facilities that are not Applications and are not covered by this
-License, and convey such a combined library under terms of your
-choice, if you do both of the following:
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
 
-   a) Accompany the combined library with a copy of the same work based
-   on the Library, uncombined with any other library facilities,
-   conveyed under the terms of this License.
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
 
-   b) Give prominent notice with the combined library that part of it
-   is a work based on the Library, and explaining where to find the
-   accompanying uncombined form of the same work.
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
 
-  6. Revised Versions of the GNU Lesser General Public License.
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
 
-  The Free Software Foundation may publish revised and/or new versions
-of the GNU Lesser General Public License from time to time. Such new
-versions will be similar in spirit to the present version, but may
-differ in detail to address new problems or concerns.
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
 
-  Each version is given a distinguishing version number. If the
-Library as you received it specifies that a certain numbered version
-of the GNU Lesser General Public License "or any later version"
-applies to it, you have the option of following the terms and
-conditions either of that published version or of any later version
-published by the Free Software Foundation. If the Library as you
-received it does not specify a version number of the GNU Lesser
-General Public License, you may choose any version of the GNU Lesser
-General Public License ever published by the Free Software Foundation.
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
 
-  If the Library as you received it specifies that a proxy can decide
-whether future versions of the GNU Lesser General Public License shall
-apply, that proxy's public statement of acceptance of any version is
-permanent authorization for you to choose that version for the
-Library.
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    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, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<https://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<https://www.gnu.org/licenses/why-not-lgpl.html>.

README.md

@@ -1,7 +1,7 @@
 # EQEmulator Core Server
-|Travis CI (Linux)|Appveyor (Windows)   |
-|:---:|:---:| 
-|[![Linux CI](https://travis-ci.org/EQEmu/Server.svg?branch=master)](https://travis-ci.org/EQEmu/Server)   |[![Windows CI](https://ci.appveyor.com/api/projects/status/d0cvokm7u732v8vl/branch/master?svg=true)](https://ci.appveyor.com/project/KimLS/server/branch/master)   |
+|Travis CI (Linux)|Appveyor w/ Bots (Windows)   |Appveyor w/o Bots (Windows)   |
+|:---:|:---:|:---:| 
+|[![Linux CI](https://travis-ci.org/EQEmu/Server.svg?branch=master)](https://travis-ci.org/EQEmu/Server)   |[![Build status](https://ci.appveyor.com/api/projects/status/scr25kmntx36c1ub/branch/master?svg=true)](https://ci.appveyor.com/project/KimLS/server-87crp/branch/master)   |[![Build status](https://ci.appveyor.com/api/projects/status/mdwbr4o9l6mxqofj/branch/master?svg=true)](https://ci.appveyor.com/project/KimLS/server-w0pq2/branch/master)   |
 
 ***
 

appveyor-bots.yml

@@ -0,0 +1,21 @@
+version: 1.0.{build}
+branches:
+  only:
+  - master
+image: Visual Studio 2017
+configuration: RelWithDebInfo
+clone_folder: c:\projects\eqemu
+init:
+- ps: git config --global core.autocrlf input
+cache: c:\tools\vcpkg\installed\
+before_build:
+- ps: "$wc = New-Object System.Net.WebClient\n$wc.DownloadFile(\"http://strawberryperl.com/download/5.26.2.1/strawberry-perl-5.26.2.1-64bit-portable.zip\", \"c:\\projects\\eqemu\\strawberry-perl-5.26.2.1-64bit-portable.zip\")\ncd c:\\projects\\eqemu\n7z x c:/projects/eqemu/strawberry-perl-5.26.2.1-64bit-portable.zip -oc:/projects/eqemu/strawberry-perl-portable -y\n(Get-Content C:/projects/eqemu/strawberry-perl-portable/perl/lib/CORE/config.h).replace('#define PERL_STATIC_INLINE static __inline__', '#define PERL_STATIC_INLINE static __inline') | Set-Content C:/projects/eqemu/strawberry-perl-portable/perl/lib/CORE/config.h\nvcpkg install boost-geometry:x64-windows boost-dynamic-bitset:x64-windows luajit:x64-windows libsodium:x64-windows libmysql:x64-windows openssl:x64-windows zlib:x64-windows \nmkdir build\ncd build\ncmake -G \"Visual Studio 15 2017 Win64\" -DEQEMU_BUILD_TESTS=ON -DEQEMU_BUILD_LOGIN=ON -EQEMU_ENABLE_BOTS=ON -DPERL_EXECUTABLE=\"C:/projects/eqemu/strawberry-perl-portable/perl/bin/perl.exe\" -DPERL_INCLUDE_PATH=\"C:/projects/eqemu/strawberry-perl-portable/perl/lib/CORE\" -DPERL_LIBRARY=\"C:/projects/eqemu/strawberry-perl-portable/perl/lib/CORE/libperl526.a\" -DCMAKE_TOOLCHAIN_FILE=\"c:/tools/vcpkg/scripts/buildsystems/vcpkg.cmake\" .."
+build:
+  project: C:\projects\eqemu\build\EQEmu.sln
+  parallel: true
+  verbosity: minimal
+after_build:
+- cmd: >-
+    7z a build_x64-bots.zip C:\projects\eqemu\build\bin\RelWithDebInfo\*.exe C:\projects\eqemu\build\bin\RelWithDebInfo\*.dll C:\projects\eqemu\build\bin\RelWithDebInfo\*.pdb
+
+    appveyor PushArtifact build_x64-bots.zip

appveyor-no-bots.yml

@@ -0,0 +1,21 @@
+version: 1.0.{build}
+branches:
+  only:
+  - master
+image: Visual Studio 2017
+configuration: RelWithDebInfo
+clone_folder: c:\projects\eqemu
+init:
+- ps: git config --global core.autocrlf input
+cache: c:\tools\vcpkg\installed\
+before_build:
+- ps: "$wc = New-Object System.Net.WebClient\n$wc.DownloadFile(\"http://strawberryperl.com/download/5.26.2.1/strawberry-perl-5.26.2.1-64bit-portable.zip\", \"c:\\projects\\eqemu\\strawberry-perl-5.26.2.1-64bit-portable.zip\")\ncd c:\\projects\\eqemu\n7z x c:/projects/eqemu/strawberry-perl-5.26.2.1-64bit-portable.zip -oc:/projects/eqemu/strawberry-perl-portable -y\n(Get-Content C:/projects/eqemu/strawberry-perl-portable/perl/lib/CORE/config.h).replace('#define PERL_STATIC_INLINE static __inline__', '#define PERL_STATIC_INLINE static __inline') | Set-Content C:/projects/eqemu/strawberry-perl-portable/perl/lib/CORE/config.h\nvcpkg install boost-geometry:x64-windows boost-dynamic-bitset:x64-windows luajit:x64-windows libsodium:x64-windows libmysql:x64-windows openssl:x64-windows zlib:x64-windows \nmkdir build\ncd build\ncmake -G \"Visual Studio 15 2017 Win64\" -DEQEMU_BUILD_TESTS=ON -DEQEMU_BUILD_LOGIN=ON -EQEMU_ENABLE_BOTS=OFF -DPERL_EXECUTABLE=\"C:/projects/eqemu/strawberry-perl-portable/perl/bin/perl.exe\" -DPERL_INCLUDE_PATH=\"C:/projects/eqemu/strawberry-perl-portable/perl/lib/CORE\" -DPERL_LIBRARY=\"C:/projects/eqemu/strawberry-perl-portable/perl/lib/CORE/libperl526.a\" -DCMAKE_TOOLCHAIN_FILE=\"c:/tools/vcpkg/scripts/buildsystems/vcpkg.cmake\" .."
+build:
+  project: C:\projects\eqemu\build\EQEmu.sln
+  parallel: true
+  verbosity: minimal
+after_build:
+- cmd: >-
+    7z a build_x64-no-bots.zip C:\projects\eqemu\build\bin\RelWithDebInfo\*.exe C:\projects\eqemu\build\bin\RelWithDebInfo\*.dll C:\projects\eqemu\build\bin\RelWithDebInfo\*.pdb
+
+    appveyor PushArtifact build_x64-no-bots.zip

changelog.txt

@@ -1,5 +1,61 @@
 EQEMu Changelog (Started on Sept 24, 2003 15:50)
 -------------------------------------------------------
+== 07/10/2018 ==
+Akkadius: Adjusted DataBuckets to use other acceptable time formats
+    Example: quest::set_data('key', 'value', '1d');
+        - Acceptable inputs:
+            - 15s = 15 seconds
+            - s15 = 15 seconds
+            - 60m = 60 minutes
+            - 7d  = 7 days
+            - 1y  = 1 year
+            - 600 = 600 seconds
+
+== 07/09/2018 ==
+mackal: Rework of Task System, Shared Tasks still unsupported
+	- The tables now have better named columns, which hopefully won't need to be explained
+	- Text1 is now target_name, Text2 is now item_list, Text3 is now description_override
+	- Tasks can now reward faction hits, this is just normal NPC Faction ID entries because I was lazy
+	- The "Task" type tasks are now supported, a player can only be doing one of these at a time
+	- Activity IDs for use spell on and use skill on have been identified but not implemented
+	- Identified "duration code" for unlimited duration tasks (None = 0, Short = 1, Medium = 2, Long = 3)
+	- Activities can now have multiple zones separated by ';'
+	- tasks.startzone removed since it actually just uses first activity
+	- skill_list and spell_list are both IDs that can be separated by ';' (still unimplemented though)
+
+== 07/07/2018 ==
+Akkadius: Implemented a much better replacement for qglobals called 'DataBuckets'
+    - A much more detailed example can be found at: https://github.com/EQEmu/Server/wiki/Data-Buckets
+
+== 07/05/2018 ==
+Uleat: Reintegration of inventory-based EQDictionary references
+	- Standardized 'CONSTANT_DECLARATION' and 'enumerationValue' tokens for most of the affected references
+	- Added 'BEGIN' and 'END' constants to many inventory-based ranges to help eliminate '< SIZE'-type comparisons
+	- Eliminated multiple, duplicated reference points of the same value context (bye, bye namespace legacy!)
+	- Most server values are now linked to the implementation client directly through a 'using ##' directive
+
+== 05/28/2018 ==
+Akkadius: Fixed an issue where size 0 NPC's hop in and out of the ground at idle
+Akkadius: NPC's now open doors within proximity given the door doesn't have locked requirements
+Akkadius: #reloadallrules will now display zones that have had their rules reloaded to GM's
+Akkadius: Zones should now respect "shutdowndelay" in the zones table at all times
+Akkadius: Fixed an issue where boats would snap to the bed of the body of water
+Akkadius: Added rule Aggro:NPCAggroMaxDistanceEnabled - defaults to true
+Akkadius: Changed map directory load structure
+    - maps/base/*.map
+    - maps/nav/*.nav
+    - maps/water/*.wtr
+    - maps/path/*.path
+
+KLS: Implemented navigation mesh
+    - All up to date maps and navs can be found https://github.com/Akkadius/EQEmuMaps
+    - To update maps either check out the maps found in the above repository or use the maintenance command:
+        perl eqemu_server.pl maps
+
+== 03/28/2018 ==
+Kayen: SE_CastOnFadeEffect, SE_CastOnFadeEffectNPC, SE_CastOnFadeEffectAlway triggered spell will now hit
+the correct targets.
+
 == 03/07/2018 ==
 Uleat: Added command '#ucs' to force a reconnect to UCS server.
 	- Works in place of client auto-reconnect packet in zones where feature is unsupported

cmake/FindPackageHandleStandardArgs.cmake

@@ -1,386 +0,0 @@
-# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
-# file Copyright.txt or https://cmake.org/licensing for details.
-
-#[=======================================================================[.rst:
-FindPackageHandleStandardArgs
------------------------------
-
-This module provides a function intended to be used in :ref:`Find Modules`
-implementing :command:`find_package(<PackageName>)` calls.  It handles the
-``REQUIRED``, ``QUIET`` and version-related arguments of ``find_package``.
-It also sets the ``<PackageName>_FOUND`` variable.  The package is
-considered found if all variables listed contain valid results, e.g.
-valid filepaths.
-
-.. command:: find_package_handle_standard_args
-
-  There are two signatures::
-
-    find_package_handle_standard_args(<PackageName>
-      (DEFAULT_MSG|<custom-failure-message>)
-      <required-var>...
-      )
-
-    find_package_handle_standard_args(<PackageName>
-      [FOUND_VAR <result-var>]
-      [REQUIRED_VARS <required-var>...]
-      [VERSION_VAR <version-var>]
-      [HANDLE_COMPONENTS]
-      [CONFIG_MODE]
-      [FAIL_MESSAGE <custom-failure-message>]
-      )
-
-  The ``<PackageName>_FOUND`` variable will be set to ``TRUE`` if all
-  the variables ``<required-var>...`` are valid and any optional
-  constraints are satisfied, and ``FALSE`` otherwise.  A success or
-  failure message may be displayed based on the results and on
-  whether the ``REQUIRED`` and/or ``QUIET`` option was given to
-  the :command:`find_package` call.
-
-  The options are:
-
-  ``(DEFAULT_MSG|<custom-failure-message>)``
-    In the simple signature this specifies the failure message.
-    Use ``DEFAULT_MSG`` to ask for a default message to be computed
-    (recommended).  Not valid in the full signature.
-
-  ``FOUND_VAR <result-var>``
-    Obsolete.  Specifies either ``<PackageName>_FOUND`` or
-    ``<PACKAGENAME>_FOUND`` as the result variable.  This exists only
-    for compatibility with older versions of CMake and is now ignored.
-    Result variables of both names are always set for compatibility.
-
-  ``REQUIRED_VARS <required-var>...``
-    Specify the variables which are required for this package.
-    These may be named in the generated failure message asking the
-    user to set the missing variable values.  Therefore these should
-    typically be cache entries such as ``FOO_LIBRARY`` and not output
-    variables like ``FOO_LIBRARIES``.
-
-  ``VERSION_VAR <version-var>``
-    Specify the name of a variable that holds the version of the package
-    that has been found.  This version will be checked against the
-    (potentially) specified required version given to the
-    :command:`find_package` call, including its ``EXACT`` option.
-    The default messages include information about the required
-    version and the version which has been actually found, both
-    if the version is ok or not.
-
-  ``HANDLE_COMPONENTS``
-    Enable handling of package components.  In this case, the command
-    will report which components have been found and which are missing,
-    and the ``<PackageName>_FOUND`` variable will be set to ``FALSE``
-    if any of the required components (i.e. not the ones listed after
-    the ``OPTIONAL_COMPONENTS`` option of :command:`find_package`) are
-    missing.
-
-  ``CONFIG_MODE``
-    Specify that the calling find module is a wrapper around a
-    call to ``find_package(<PackageName> NO_MODULE)``.  This implies
-    a ``VERSION_VAR`` value of ``<PackageName>_VERSION``.  The command
-    will automatically check whether the package configuration file
-    was found.
-
-  ``FAIL_MESSAGE <custom-failure-message>``
-    Specify a custom failure message instead of using the default
-    generated message.  Not recommended.
-
-Example for the simple signature:
-
-.. code-block:: cmake
-
-  find_package_handle_standard_args(LibXml2 DEFAULT_MSG
-    LIBXML2_LIBRARY LIBXML2_INCLUDE_DIR)
-
-The ``LibXml2`` package is considered to be found if both
-``LIBXML2_LIBRARY`` and ``LIBXML2_INCLUDE_DIR`` are valid.
-Then also ``LibXml2_FOUND`` is set to ``TRUE``.  If it is not found
-and ``REQUIRED`` was used, it fails with a
-:command:`message(FATAL_ERROR)`, independent whether ``QUIET`` was
-used or not.  If it is found, success will be reported, including
-the content of the first ``<required-var>``.  On repeated CMake runs,
-the same message will not be printed again.
-
-Example for the full signature:
-
-.. code-block:: cmake
-
-  find_package_handle_standard_args(LibArchive
-    REQUIRED_VARS LibArchive_LIBRARY LibArchive_INCLUDE_DIR
-    VERSION_VAR LibArchive_VERSION)
-
-In this case, the ``LibArchive`` package is considered to be found if
-both ``LibArchive_LIBRARY`` and ``LibArchive_INCLUDE_DIR`` are valid.
-Also the version of ``LibArchive`` will be checked by using the version
-contained in ``LibArchive_VERSION``.  Since no ``FAIL_MESSAGE`` is given,
-the default messages will be printed.
-
-Another example for the full signature:
-
-.. code-block:: cmake
-
-  find_package(Automoc4 QUIET NO_MODULE HINTS /opt/automoc4)
-  find_package_handle_standard_args(Automoc4  CONFIG_MODE)
-
-In this case, a ``FindAutmoc4.cmake`` module wraps a call to
-``find_package(Automoc4 NO_MODULE)`` and adds an additional search
-directory for ``automoc4``.  Then the call to
-``find_package_handle_standard_args`` produces a proper success/failure
-message.
-#]=======================================================================]
-
-include(${CMAKE_CURRENT_LIST_DIR}/FindPackageMessage.cmake)
-
-# internal helper macro
-macro(_FPHSA_FAILURE_MESSAGE _msg)
-  if (${_NAME}_FIND_REQUIRED)
-    message(FATAL_ERROR "${_msg}")
-  else ()
-    if (NOT ${_NAME}_FIND_QUIETLY)
-      message(STATUS "${_msg}")
-    endif ()
-  endif ()
-endmacro()
-
-
-# internal helper macro to generate the failure message when used in CONFIG_MODE:
-macro(_FPHSA_HANDLE_FAILURE_CONFIG_MODE)
-  # <name>_CONFIG is set, but FOUND is false, this means that some other of the REQUIRED_VARS was not found:
-  if(${_NAME}_CONFIG)
-    _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE}: missing:${MISSING_VARS} (found ${${_NAME}_CONFIG} ${VERSION_MSG})")
-  else()
-    # If _CONSIDERED_CONFIGS is set, the config-file has been found, but no suitable version.
-    # List them all in the error message:
-    if(${_NAME}_CONSIDERED_CONFIGS)
-      set(configsText "")
-      list(LENGTH ${_NAME}_CONSIDERED_CONFIGS configsCount)
-      math(EXPR configsCount "${configsCount} - 1")
-      foreach(currentConfigIndex RANGE ${configsCount})
-        list(GET ${_NAME}_CONSIDERED_CONFIGS ${currentConfigIndex} filename)
-        list(GET ${_NAME}_CONSIDERED_VERSIONS ${currentConfigIndex} version)
-        string(APPEND configsText "    ${filename} (version ${version})\n")
-      endforeach()
-      if (${_NAME}_NOT_FOUND_MESSAGE)
-        string(APPEND configsText "    Reason given by package: ${${_NAME}_NOT_FOUND_MESSAGE}\n")
-      endif()
-      _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE} ${VERSION_MSG}, checked the following files:\n${configsText}")
-
-    else()
-      # Simple case: No Config-file was found at all:
-      _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE}: found neither ${_NAME}Config.cmake nor ${_NAME_LOWER}-config.cmake ${VERSION_MSG}")
-    endif()
-  endif()
-endmacro()
-
-
-function(FIND_PACKAGE_HANDLE_STANDARD_ARGS _NAME _FIRST_ARG)
-
-# Set up the arguments for `cmake_parse_arguments`.
-  set(options  CONFIG_MODE  HANDLE_COMPONENTS)
-  set(oneValueArgs  FAIL_MESSAGE  VERSION_VAR  FOUND_VAR)
-  set(multiValueArgs REQUIRED_VARS)
-
-# Check whether we are in 'simple' or 'extended' mode:
-  set(_KEYWORDS_FOR_EXTENDED_MODE  ${options} ${oneValueArgs} ${multiValueArgs} )
-  list(FIND _KEYWORDS_FOR_EXTENDED_MODE "${_FIRST_ARG}" INDEX)
-
-  if(${INDEX} EQUAL -1)
-    set(FPHSA_FAIL_MESSAGE ${_FIRST_ARG})
-    set(FPHSA_REQUIRED_VARS ${ARGN})
-    set(FPHSA_VERSION_VAR)
-  else()
-    cmake_parse_arguments(FPHSA "${options}" "${oneValueArgs}" "${multiValueArgs}"  ${_FIRST_ARG} ${ARGN})
-
-    if(FPHSA_UNPARSED_ARGUMENTS)
-      message(FATAL_ERROR "Unknown keywords given to FIND_PACKAGE_HANDLE_STANDARD_ARGS(): \"${FPHSA_UNPARSED_ARGUMENTS}\"")
-    endif()
-
-    if(NOT FPHSA_FAIL_MESSAGE)
-      set(FPHSA_FAIL_MESSAGE  "DEFAULT_MSG")
-    endif()
-
-    # In config-mode, we rely on the variable <package>_CONFIG, which is set by find_package()
-    # when it successfully found the config-file, including version checking:
-    if(FPHSA_CONFIG_MODE)
-      list(INSERT FPHSA_REQUIRED_VARS 0 ${_NAME}_CONFIG)
-      list(REMOVE_DUPLICATES FPHSA_REQUIRED_VARS)
-      set(FPHSA_VERSION_VAR ${_NAME}_VERSION)
-    endif()
-
-    if(NOT FPHSA_REQUIRED_VARS)
-      message(FATAL_ERROR "No REQUIRED_VARS specified for FIND_PACKAGE_HANDLE_STANDARD_ARGS()")
-    endif()
-  endif()
-
-# now that we collected all arguments, process them
-
-  if("x${FPHSA_FAIL_MESSAGE}" STREQUAL "xDEFAULT_MSG")
-    set(FPHSA_FAIL_MESSAGE "Could NOT find ${_NAME}")
-  endif()
-
-  list(GET FPHSA_REQUIRED_VARS 0 _FIRST_REQUIRED_VAR)
-
-  string(TOUPPER ${_NAME} _NAME_UPPER)
-  string(TOLOWER ${_NAME} _NAME_LOWER)
-
-  if(FPHSA_FOUND_VAR)
-    if(FPHSA_FOUND_VAR MATCHES "^${_NAME}_FOUND$"  OR  FPHSA_FOUND_VAR MATCHES "^${_NAME_UPPER}_FOUND$")
-      set(_FOUND_VAR ${FPHSA_FOUND_VAR})
-    else()
-      message(FATAL_ERROR "The argument for FOUND_VAR is \"${FPHSA_FOUND_VAR}\", but only \"${_NAME}_FOUND\" and \"${_NAME_UPPER}_FOUND\" are valid names.")
-    endif()
-  else()
-    set(_FOUND_VAR ${_NAME_UPPER}_FOUND)
-  endif()
-
-  # collect all variables which were not found, so they can be printed, so the
-  # user knows better what went wrong (#6375)
-  set(MISSING_VARS "")
-  set(DETAILS "")
-  # check if all passed variables are valid
-  set(FPHSA_FOUND_${_NAME} TRUE)
-  foreach(_CURRENT_VAR ${FPHSA_REQUIRED_VARS})
-    if(NOT ${_CURRENT_VAR})
-      set(FPHSA_FOUND_${_NAME} FALSE)
-      string(APPEND MISSING_VARS " ${_CURRENT_VAR}")
-    else()
-      string(APPEND DETAILS "[${${_CURRENT_VAR}}]")
-    endif()
-  endforeach()
-  if(FPHSA_FOUND_${_NAME})
-    set(${_NAME}_FOUND TRUE)
-    set(${_NAME_UPPER}_FOUND TRUE)
-  else()
-    set(${_NAME}_FOUND FALSE)
-    set(${_NAME_UPPER}_FOUND FALSE)
-  endif()
-
-  # component handling
-  unset(FOUND_COMPONENTS_MSG)
-  unset(MISSING_COMPONENTS_MSG)
-
-  if(FPHSA_HANDLE_COMPONENTS)
-    foreach(comp ${${_NAME}_FIND_COMPONENTS})
-      if(${_NAME}_${comp}_FOUND)
-
-        if(NOT DEFINED FOUND_COMPONENTS_MSG)
-          set(FOUND_COMPONENTS_MSG "found components: ")
-        endif()
-        string(APPEND FOUND_COMPONENTS_MSG " ${comp}")
-
-      else()
-
-        if(NOT DEFINED MISSING_COMPONENTS_MSG)
-          set(MISSING_COMPONENTS_MSG "missing components: ")
-        endif()
-        string(APPEND MISSING_COMPONENTS_MSG " ${comp}")
-
-        if(${_NAME}_FIND_REQUIRED_${comp})
-          set(${_NAME}_FOUND FALSE)
-          string(APPEND MISSING_VARS " ${comp}")
-        endif()
-
-      endif()
-    endforeach()
-    set(COMPONENT_MSG "${FOUND_COMPONENTS_MSG} ${MISSING_COMPONENTS_MSG}")
-    string(APPEND DETAILS "[c${COMPONENT_MSG}]")
-  endif()
-
-  # version handling:
-  set(VERSION_MSG "")
-  set(VERSION_OK TRUE)
-
-  # check with DEFINED here as the requested or found version may be "0"
-  if (DEFINED ${_NAME}_FIND_VERSION)
-    if(DEFINED ${FPHSA_VERSION_VAR})
-      set(_FOUND_VERSION ${${FPHSA_VERSION_VAR}})
-
-      if(${_NAME}_FIND_VERSION_EXACT)       # exact version required
-        # count the dots in the version string
-        string(REGEX REPLACE "[^.]" "" _VERSION_DOTS "${_FOUND_VERSION}")
-        # add one dot because there is one dot more than there are components
-        string(LENGTH "${_VERSION_DOTS}." _VERSION_DOTS)
-        if (_VERSION_DOTS GREATER ${_NAME}_FIND_VERSION_COUNT)
-          # Because of the C++ implementation of find_package() ${_NAME}_FIND_VERSION_COUNT
-          # is at most 4 here. Therefore a simple lookup table is used.
-          if (${_NAME}_FIND_VERSION_COUNT EQUAL 1)
-            set(_VERSION_REGEX "[^.]*")
-          elseif (${_NAME}_FIND_VERSION_COUNT EQUAL 2)
-            set(_VERSION_REGEX "[^.]*\\.[^.]*")
-          elseif (${_NAME}_FIND_VERSION_COUNT EQUAL 3)
-            set(_VERSION_REGEX "[^.]*\\.[^.]*\\.[^.]*")
-          else ()
-            set(_VERSION_REGEX "[^.]*\\.[^.]*\\.[^.]*\\.[^.]*")
-          endif ()
-          string(REGEX REPLACE "^(${_VERSION_REGEX})\\..*" "\\1" _VERSION_HEAD "${_FOUND_VERSION}")
-          unset(_VERSION_REGEX)
-          if (NOT ${_NAME}_FIND_VERSION VERSION_EQUAL _VERSION_HEAD)
-            set(VERSION_MSG "Found unsuitable version \"${_FOUND_VERSION}\", but required is exact version \"${${_NAME}_FIND_VERSION}\"")
-            set(VERSION_OK FALSE)
-          else ()
-            set(VERSION_MSG "(found suitable exact version \"${_FOUND_VERSION}\")")
-          endif ()
-          unset(_VERSION_HEAD)
-        else ()
-          if (NOT ${_NAME}_FIND_VERSION VERSION_EQUAL _FOUND_VERSION)
-            set(VERSION_MSG "Found unsuitable version \"${_FOUND_VERSION}\", but required is exact version \"${${_NAME}_FIND_VERSION}\"")
-            set(VERSION_OK FALSE)
-          else ()
-            set(VERSION_MSG "(found suitable exact version \"${_FOUND_VERSION}\")")
-          endif ()
-        endif ()
-        unset(_VERSION_DOTS)
-
-      else()     # minimum version specified:
-        if (${_NAME}_FIND_VERSION VERSION_GREATER _FOUND_VERSION)
-          set(VERSION_MSG "Found unsuitable version \"${_FOUND_VERSION}\", but required is at least \"${${_NAME}_FIND_VERSION}\"")
-          set(VERSION_OK FALSE)
-        else ()
-          set(VERSION_MSG "(found suitable version \"${_FOUND_VERSION}\", minimum required is \"${${_NAME}_FIND_VERSION}\")")
-        endif ()
-      endif()
-
-    else()
-
-      # if the package was not found, but a version was given, add that to the output:
-      if(${_NAME}_FIND_VERSION_EXACT)
-         set(VERSION_MSG "(Required is exact version \"${${_NAME}_FIND_VERSION}\")")
-      else()
-         set(VERSION_MSG "(Required is at least version \"${${_NAME}_FIND_VERSION}\")")
-      endif()
-
-    endif()
-  else ()
-    # Check with DEFINED as the found version may be 0.
-    if(DEFINED ${FPHSA_VERSION_VAR})
-      set(VERSION_MSG "(found version \"${${FPHSA_VERSION_VAR}}\")")
-    endif()
-  endif ()
-
-  if(VERSION_OK)
-    string(APPEND DETAILS "[v${${FPHSA_VERSION_VAR}}(${${_NAME}_FIND_VERSION})]")
-  else()
-    set(${_NAME}_FOUND FALSE)
-  endif()
-
-
-  # print the result:
-  if (${_NAME}_FOUND)
-    FIND_PACKAGE_MESSAGE(${_NAME} "Found ${_NAME}: ${${_FIRST_REQUIRED_VAR}} ${VERSION_MSG} ${COMPONENT_MSG}" "${DETAILS}")
-  else ()
-
-    if(FPHSA_CONFIG_MODE)
-      _FPHSA_HANDLE_FAILURE_CONFIG_MODE()
-    else()
-      if(NOT VERSION_OK)
-        _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE}: ${VERSION_MSG} (found ${${_FIRST_REQUIRED_VAR}})")
-      else()
-        _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE} (missing:${MISSING_VARS}) ${VERSION_MSG}")
-      endif()
-    endif()
-
-  endif ()
-
-  set(${_NAME}_FOUND ${${_NAME}_FOUND} PARENT_SCOPE)
-  set(${_NAME_UPPER}_FOUND ${${_NAME}_FOUND} PARENT_SCOPE)
-endfunction()

cmake/FindPackageMessage.cmake

@@ -1,47 +0,0 @@
-# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
-# file Copyright.txt or https://cmake.org/licensing for details.
-
-#.rst:
-# FindPackageMessage
-# ------------------
-#
-#
-#
-# FIND_PACKAGE_MESSAGE(<name> "message for user" "find result details")
-#
-# This macro is intended to be used in FindXXX.cmake modules files.  It
-# will print a message once for each unique find result.  This is useful
-# for telling the user where a package was found.  The first argument
-# specifies the name (XXX) of the package.  The second argument
-# specifies the message to display.  The third argument lists details
-# about the find result so that if they change the message will be
-# displayed again.  The macro also obeys the QUIET argument to the
-# find_package command.
-#
-# Example:
-#
-# ::
-#
-#   if(X11_FOUND)
-#     FIND_PACKAGE_MESSAGE(X11 "Found X11: ${X11_X11_LIB}"
-#       "[${X11_X11_LIB}][${X11_INCLUDE_DIR}]")
-#   else()
-#    ...
-#   endif()
-
-function(FIND_PACKAGE_MESSAGE pkg msg details)
-  # Avoid printing a message repeatedly for the same find result.
-  if(NOT ${pkg}_FIND_QUIETLY)
-    string(REPLACE "\n" "" details "${details}")
-    set(DETAILS_VAR FIND_PACKAGE_MESSAGE_DETAILS_${pkg})
-    if(NOT "${details}" STREQUAL "${${DETAILS_VAR}}")
-      # The message has not yet been printed.
-      message(STATUS "${msg}")
-
-      # Save the find details in the cache to avoid printing the same
-      # message again.
-      set("${DETAILS_VAR}" "${details}"
-        CACHE INTERNAL "Details about finding ${pkg}")
-    endif()
-  endif()
-endfunction()

cmake/FindProtobuf.cmake

@@ -1,579 +0,0 @@
-# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
-# file Copyright.txt or https://cmake.org/licensing for details.
-
-#.rst:
-# FindProtobuf
-# ------------
-#
-# Locate and configure the Google Protocol Buffers library.
-#
-# The following variables can be set and are optional:
-#
-# ``Protobuf_SRC_ROOT_FOLDER``
-#   When compiling with MSVC, if this cache variable is set
-#   the protobuf-default VS project build locations
-#   (vsprojects/Debug and vsprojects/Release
-#   or vsprojects/x64/Debug and vsprojects/x64/Release)
-#   will be searched for libraries and binaries.
-# ``Protobuf_IMPORT_DIRS``
-#   List of additional directories to be searched for
-#   imported .proto files.
-# ``Protobuf_DEBUG``
-#   Show debug messages.
-# ``Protobuf_USE_STATIC_LIBS``
-#   Set to ON to force the use of the static libraries.
-#   Default is OFF.
-#
-# Defines the following variables:
-#
-# ``Protobuf_FOUND``
-#   Found the Google Protocol Buffers library
-#   (libprotobuf & header files)
-# ``Protobuf_VERSION``
-#   Version of package found.
-# ``Protobuf_INCLUDE_DIRS``
-#   Include directories for Google Protocol Buffers
-# ``Protobuf_LIBRARIES``
-#   The protobuf libraries
-# ``Protobuf_PROTOC_LIBRARIES``
-#   The protoc libraries
-# ``Protobuf_LITE_LIBRARIES``
-#   The protobuf-lite libraries
-#
-# The following :prop_tgt:`IMPORTED` targets are also defined:
-#
-# ``protobuf::libprotobuf``
-#   The protobuf library.
-# ``protobuf::libprotobuf-lite``
-#   The protobuf lite library.
-# ``protobuf::libprotoc``
-#   The protoc library.
-# ``protobuf::protoc``
-#   The protoc compiler.
-#
-# The following cache variables are also available to set or use:
-#
-# ``Protobuf_LIBRARY``
-#   The protobuf library
-# ``Protobuf_PROTOC_LIBRARY``
-#   The protoc library
-# ``Protobuf_INCLUDE_DIR``
-#   The include directory for protocol buffers
-# ``Protobuf_PROTOC_EXECUTABLE``
-#   The protoc compiler
-# ``Protobuf_LIBRARY_DEBUG``
-#   The protobuf library (debug)
-# ``Protobuf_PROTOC_LIBRARY_DEBUG``
-#   The protoc library (debug)
-# ``Protobuf_LITE_LIBRARY``
-#   The protobuf lite library
-# ``Protobuf_LITE_LIBRARY_DEBUG``
-#   The protobuf lite library (debug)
-#
-# Example:
-#
-# .. code-block:: cmake
-#
-#   find_package(Protobuf REQUIRED)
-#   include_directories(${Protobuf_INCLUDE_DIRS})
-#   include_directories(${CMAKE_CURRENT_BINARY_DIR})
-#   protobuf_generate_cpp(PROTO_SRCS PROTO_HDRS foo.proto)
-#   protobuf_generate_cpp(PROTO_SRCS PROTO_HDRS EXPORT_MACRO DLL_EXPORT foo.proto)
-#   protobuf_generate_cpp(PROTO_SRCS PROTO_HDRS DESCRIPTORS PROTO_DESCS foo.proto)
-#   protobuf_generate_python(PROTO_PY foo.proto)
-#   add_executable(bar bar.cc ${PROTO_SRCS} ${PROTO_HDRS})
-#   target_link_libraries(bar ${Protobuf_LIBRARIES})
-#
-# .. note::
-#   The ``protobuf_generate_cpp`` and ``protobuf_generate_python``
-#   functions and :command:`add_executable` or :command:`add_library`
-#   calls only work properly within the same directory.
-#
-# .. command:: protobuf_generate_cpp
-#
-#   Add custom commands to process ``.proto`` files to C++::
-#
-#     protobuf_generate_cpp (<SRCS> <HDRS>
-#         [DESCRIPTORS <DESC>] [EXPORT_MACRO <MACRO>] [<ARGN>...])
-#
-#   ``SRCS``
-#     Variable to define with autogenerated source files
-#   ``HDRS``
-#     Variable to define with autogenerated header files
-#   ``DESCRIPTORS``
-#     Variable to define with autogenerated descriptor files, if requested.
-#   ``EXPORT_MACRO``
-#     is a macro which should expand to ``__declspec(dllexport)`` or
-#     ``__declspec(dllimport)`` depending on what is being compiled.
-#   ``ARGN``
-#     ``.proto`` files
-#
-# .. command:: protobuf_generate_python
-#
-#   Add custom commands to process ``.proto`` files to Python::
-#
-#     protobuf_generate_python (<PY> [<ARGN>...])
-#
-#   ``PY``
-#     Variable to define with autogenerated Python files
-#   ``ARGN``
-#     ``.proto`` filess
-
-function(PROTOBUF_GENERATE_CPP SRCS HDRS)
-  cmake_parse_arguments(protobuf "" "EXPORT_MACRO;DESCRIPTORS" "" ${ARGN})
-
-  set(PROTO_FILES "${protobuf_UNPARSED_ARGUMENTS}")
-  if(NOT PROTO_FILES)
-    message(SEND_ERROR "Error: PROTOBUF_GENERATE_CPP() called without any proto files")
-    return()
-  endif()
-
-  if(protobuf_EXPORT_MACRO)
-    set(DLL_EXPORT_DECL "dllexport_decl=${protobuf_EXPORT_MACRO}:")
-  endif()
-
-  if(PROTOBUF_GENERATE_CPP_APPEND_PATH)
-    # Create an include path for each file specified
-    foreach(FIL ${PROTO_FILES})
-      get_filename_component(ABS_FIL ${FIL} ABSOLUTE)
-      get_filename_component(ABS_PATH ${ABS_FIL} PATH)
-      list(FIND _protobuf_include_path ${ABS_PATH} _contains_already)
-      if(${_contains_already} EQUAL -1)
-          list(APPEND _protobuf_include_path -I ${ABS_PATH})
-      endif()
-    endforeach()
-  else()
-    set(_protobuf_include_path -I ${CMAKE_CURRENT_SOURCE_DIR})
-  endif()
-
-  if(DEFINED PROTOBUF_IMPORT_DIRS AND NOT DEFINED Protobuf_IMPORT_DIRS)
-    set(Protobuf_IMPORT_DIRS "${PROTOBUF_IMPORT_DIRS}")
-  endif()
-
-  if(DEFINED Protobuf_IMPORT_DIRS)
-    foreach(DIR ${Protobuf_IMPORT_DIRS})
-      get_filename_component(ABS_PATH ${DIR} ABSOLUTE)
-      list(FIND _protobuf_include_path ${ABS_PATH} _contains_already)
-      if(${_contains_already} EQUAL -1)
-          list(APPEND _protobuf_include_path -I ${ABS_PATH})
-      endif()
-    endforeach()
-  endif()
-
-  set(${SRCS})
-  set(${HDRS})
-  if (protobuf_DESCRIPTORS)
-    set(${protobuf_DESCRIPTORS})
-  endif()
-
-  foreach(FIL ${PROTO_FILES})
-    get_filename_component(ABS_FIL ${FIL} ABSOLUTE)
-    get_filename_component(FIL_WE ${FIL} NAME_WE)
-    if(NOT PROTOBUF_GENERATE_CPP_APPEND_PATH)
-      get_filename_component(FIL_DIR ${FIL} DIRECTORY)
-      if(FIL_DIR)
-        set(FIL_WE "${FIL_DIR}/${FIL_WE}")
-      endif()
-    endif()
-    
-    set(_protobuf_protoc_src "${CMAKE_CURRENT_SOURCE_DIR}/${FIL_WE}.pb.cc")
-    set(_protobuf_protoc_hdr "${CMAKE_CURRENT_SOURCE_DIR}/${FIL_WE}.pb.h")
-    list(APPEND ${SRCS} "${_protobuf_protoc_src}")
-    list(APPEND ${HDRS} "${_protobuf_protoc_hdr}")
-
-    if(protobuf_DESCRIPTORS)
-      set(_protobuf_protoc_desc "${CMAKE_CURRENT_SOURCE_DIR}/${FIL_WE}.desc")
-      set(_protobuf_protoc_flags "--descriptor_set_out=${_protobuf_protoc_desc}")
-      list(APPEND ${protobuf_DESCRIPTORS} "${_protobuf_protoc_desc}")
-    else()
-      set(_protobuf_protoc_desc "")
-      set(_protobuf_protoc_flags "")
-    endif()
-  
-    add_custom_command(
-      OUTPUT "${_protobuf_protoc_src}"
-             "${_protobuf_protoc_hdr}"
-             ${_protobuf_protoc_desc}
-      COMMAND  protobuf::protoc
-               "--cpp_out=${DLL_EXPORT_DECL}${CMAKE_CURRENT_SOURCE_DIR}"
-               ${_protobuf_protoc_flags}
-               ${_protobuf_include_path} ${ABS_FIL}
-      DEPENDS ${ABS_FIL} protobuf::protoc
-      COMMENT "Running C++ protocol buffer compiler on ${FIL}"
-      VERBATIM )
-  endforeach()
-
-  set(${SRCS} "${${SRCS}}" PARENT_SCOPE)
-  set(${HDRS} "${${HDRS}}" PARENT_SCOPE)
-  if(protobuf_DESCRIPTORS)
-    set(${protobuf_DESCRIPTORS} "${${protobuf_DESCRIPTORS}}" PARENT_SCOPE)
-  endif()
-  
-endfunction()
-
-function(PROTOBUF_GENERATE_PYTHON SRCS)
-  if(NOT ARGN)
-    message(SEND_ERROR "Error: PROTOBUF_GENERATE_PYTHON() called without any proto files")
-    return()
-  endif()
-
-  if(PROTOBUF_GENERATE_CPP_APPEND_PATH)
-    # Create an include path for each file specified
-    foreach(FIL ${ARGN})
-      get_filename_component(ABS_FIL ${FIL} ABSOLUTE)
-      get_filename_component(ABS_PATH ${ABS_FIL} PATH)
-      list(FIND _protobuf_include_path ${ABS_PATH} _contains_already)
-      if(${_contains_already} EQUAL -1)
-          list(APPEND _protobuf_include_path -I ${ABS_PATH})
-      endif()
-    endforeach()
-  else()
-    set(_protobuf_include_path -I ${CMAKE_CURRENT_SOURCE_DIR})
-  endif()
-
-  if(DEFINED PROTOBUF_IMPORT_DIRS AND NOT DEFINED Protobuf_IMPORT_DIRS)
-    set(Protobuf_IMPORT_DIRS "${PROTOBUF_IMPORT_DIRS}")
-  endif()
-
-  if(DEFINED Protobuf_IMPORT_DIRS)
-    foreach(DIR ${Protobuf_IMPORT_DIRS})
-      get_filename_component(ABS_PATH ${DIR} ABSOLUTE)
-      list(FIND _protobuf_include_path ${ABS_PATH} _contains_already)
-      if(${_contains_already} EQUAL -1)
-          list(APPEND _protobuf_include_path -I ${ABS_PATH})
-      endif()
-    endforeach()
-  endif()
-
-  set(${SRCS})
-  foreach(FIL ${ARGN})
-    get_filename_component(ABS_FIL ${FIL} ABSOLUTE)
-    get_filename_component(FIL_WE ${FIL} NAME_WE)
-    if(NOT PROTOBUF_GENERATE_CPP_APPEND_PATH)
-      get_filename_component(FIL_DIR ${FIL} DIRECTORY)
-      if(FIL_DIR)
-        set(FIL_WE "${FIL_DIR}/${FIL_WE}")
-      endif()
-    endif()
-
-    list(APPEND ${SRCS} "${CMAKE_CURRENT_BINARY_DIR}/${FIL_WE}_pb2.py")
-    add_custom_command(
-      OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${FIL_WE}_pb2.py"
-      COMMAND  protobuf::protoc --python_out ${CMAKE_CURRENT_BINARY_DIR} ${_protobuf_include_path} ${ABS_FIL}
-      DEPENDS ${ABS_FIL} protobuf::protoc
-      COMMENT "Running Python protocol buffer compiler on ${FIL}"
-      VERBATIM )
-  endforeach()
-
-  set(${SRCS} ${${SRCS}} PARENT_SCOPE)
-endfunction()
-
-
-if(Protobuf_DEBUG)
-  # Output some of their choices
-  message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] "
-                 "Protobuf_USE_STATIC_LIBS = ${Protobuf_USE_STATIC_LIBS}")
-endif()
-
-
-# Backwards compatibility
-# Define camel case versions of input variables
-foreach(UPPER
-    PROTOBUF_SRC_ROOT_FOLDER
-    PROTOBUF_IMPORT_DIRS
-    PROTOBUF_DEBUG
-    PROTOBUF_LIBRARY
-    PROTOBUF_PROTOC_LIBRARY
-    PROTOBUF_INCLUDE_DIR
-    PROTOBUF_PROTOC_EXECUTABLE
-    PROTOBUF_LIBRARY_DEBUG
-    PROTOBUF_PROTOC_LIBRARY_DEBUG
-    PROTOBUF_LITE_LIBRARY
-    PROTOBUF_LITE_LIBRARY_DEBUG
-    )
-    if (DEFINED ${UPPER})
-        string(REPLACE "PROTOBUF_" "Protobuf_" Camel ${UPPER})
-        if (NOT DEFINED ${Camel})
-            set(${Camel} ${${UPPER}})
-        endif()
-    endif()
-endforeach()
-
-if(CMAKE_SIZEOF_VOID_P EQUAL 8)
-  set(_PROTOBUF_ARCH_DIR x64/)
-endif()
-
-
-# Support preference of static libs by adjusting CMAKE_FIND_LIBRARY_SUFFIXES
-if( Protobuf_USE_STATIC_LIBS )
-  set( _protobuf_ORIG_CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES})
-  if(WIN32)
-    set(CMAKE_FIND_LIBRARY_SUFFIXES .lib .a ${CMAKE_FIND_LIBRARY_SUFFIXES})
-  else()
-    set(CMAKE_FIND_LIBRARY_SUFFIXES .a )
-  endif()
-endif()
-
-include(${CMAKE_CURRENT_LIST_DIR}/SelectLibraryConfigurations.cmake)
-
-# Internal function: search for normal library as well as a debug one
-#    if the debug one is specified also include debug/optimized keywords
-#    in *_LIBRARIES variable
-function(_protobuf_find_libraries name filename)
-  if(${name}_LIBRARIES)
-    # Use result recorded by a previous call.
-    return()
-  elseif(${name}_LIBRARY)
-    # Honor cache entry used by CMake 3.5 and lower.
-    set(${name}_LIBRARIES "${${name}_LIBRARY}" PARENT_SCOPE)
-  else()
-    find_library(${name}_LIBRARY_RELEASE
-      NAMES ${filename}
-      PATHS ${Protobuf_SRC_ROOT_FOLDER}/vsprojects/${_PROTOBUF_ARCH_DIR}Release)
-    mark_as_advanced(${name}_LIBRARY_RELEASE)
-
-    find_library(${name}_LIBRARY_DEBUG
-      NAMES ${filename}d ${filename}
-      PATHS ${Protobuf_SRC_ROOT_FOLDER}/vsprojects/${_PROTOBUF_ARCH_DIR}Debug)
-    mark_as_advanced(${name}_LIBRARY_DEBUG)
-
-    select_library_configurations(${name})
-    set(${name}_LIBRARY "${${name}_LIBRARY}" PARENT_SCOPE)
-    set(${name}_LIBRARIES "${${name}_LIBRARIES}" PARENT_SCOPE)
-  endif()
-endfunction()
-
-# Internal function: find threads library
-function(_protobuf_find_threads)
-    set(CMAKE_THREAD_PREFER_PTHREAD TRUE)
-    find_package(Threads)
-    if(Threads_FOUND)
-        list(APPEND Protobuf_LIBRARIES ${CMAKE_THREAD_LIBS_INIT})
-        set(Protobuf_LIBRARIES "${Protobuf_LIBRARIES}" PARENT_SCOPE)
-    endif()
-endfunction()
-
-#
-# Main.
-#
-
-# By default have PROTOBUF_GENERATE_CPP macro pass -I to protoc
-# for each directory where a proto file is referenced.
-if(NOT DEFINED PROTOBUF_GENERATE_CPP_APPEND_PATH)
-  set(PROTOBUF_GENERATE_CPP_APPEND_PATH TRUE)
-endif()
-
-
-# Google's provided vcproj files generate libraries with a "lib"
-# prefix on Windows
-if(MSVC)
-    set(Protobuf_ORIG_FIND_LIBRARY_PREFIXES "${CMAKE_FIND_LIBRARY_PREFIXES}")
-    set(CMAKE_FIND_LIBRARY_PREFIXES "lib" "")
-
-    find_path(Protobuf_SRC_ROOT_FOLDER protobuf.pc.in)
-endif()
-
-# The Protobuf library
-_protobuf_find_libraries(Protobuf protobuf)
-#DOC "The Google Protocol Buffers RELEASE Library"
-
-_protobuf_find_libraries(Protobuf_LITE protobuf-lite)
-
-# The Protobuf Protoc Library
-_protobuf_find_libraries(Protobuf_PROTOC protoc)
-
-# Restore original find library prefixes
-if(MSVC)
-    set(CMAKE_FIND_LIBRARY_PREFIXES "${Protobuf_ORIG_FIND_LIBRARY_PREFIXES}")
-endif()
-
-if(UNIX)
-    _protobuf_find_threads()
-endif()
-
-# Find the include directory
-find_path(Protobuf_INCLUDE_DIR
-    google/protobuf/service.h
-    PATHS ${Protobuf_SRC_ROOT_FOLDER}/src
-)
-mark_as_advanced(Protobuf_INCLUDE_DIR)
-
-# Find the protoc Executable
-find_program(Protobuf_PROTOC_EXECUTABLE
-    NAMES protoc
-    DOC "The Google Protocol Buffers Compiler"
-    PATHS /usr/bin    
-    ${Protobuf_SRC_ROOT_FOLDER}/vsprojects/${_PROTOBUF_ARCH_DIR}Release
-    ${Protobuf_SRC_ROOT_FOLDER}/vsprojects/${_PROTOBUF_ARCH_DIR}Debug
-)
-mark_as_advanced(Protobuf_PROTOC_EXECUTABLE)
-
-if(Protobuf_DEBUG)
-    message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] "
-        "requested version of Google Protobuf is ${Protobuf_FIND_VERSION}")
-endif()
-
-if(Protobuf_INCLUDE_DIR)
-  set(_PROTOBUF_COMMON_HEADER ${Protobuf_INCLUDE_DIR}/google/protobuf/stubs/common.h)
-
-  if(Protobuf_DEBUG)
-    message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] "
-                   "location of common.h: ${_PROTOBUF_COMMON_HEADER}")
-  endif()
-
-  set(Protobuf_VERSION "")
-  set(Protobuf_LIB_VERSION "")
-  file(STRINGS ${_PROTOBUF_COMMON_HEADER} _PROTOBUF_COMMON_H_CONTENTS REGEX "#define[ \t]+GOOGLE_PROTOBUF_VERSION[ \t]+")
-  if(_PROTOBUF_COMMON_H_CONTENTS MATCHES "#define[ \t]+GOOGLE_PROTOBUF_VERSION[ \t]+([0-9]+)")
-      set(Protobuf_LIB_VERSION "${CMAKE_MATCH_1}")
-  endif()
-  unset(_PROTOBUF_COMMON_H_CONTENTS)
-
-  math(EXPR _PROTOBUF_MAJOR_VERSION "${Protobuf_LIB_VERSION} / 1000000")
-  math(EXPR _PROTOBUF_MINOR_VERSION "${Protobuf_LIB_VERSION} / 1000 % 1000")
-  math(EXPR _PROTOBUF_SUBMINOR_VERSION "${Protobuf_LIB_VERSION} % 1000")
-  set(Protobuf_VERSION "${_PROTOBUF_MAJOR_VERSION}.${_PROTOBUF_MINOR_VERSION}.${_PROTOBUF_SUBMINOR_VERSION}")
-
-  if(Protobuf_DEBUG)
-    message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] "
-        "${_PROTOBUF_COMMON_HEADER} reveals protobuf ${Protobuf_VERSION}")
-  endif()
-
-  # Check Protobuf compiler version to be aligned with libraries version
-  execute_process(COMMAND ${Protobuf_PROTOC_EXECUTABLE} --version
-                  OUTPUT_VARIABLE _PROTOBUF_PROTOC_EXECUTABLE_VERSION)
-
-  if("${_PROTOBUF_PROTOC_EXECUTABLE_VERSION}" MATCHES "libprotoc ([0-9.]+)")
-    set(_PROTOBUF_PROTOC_EXECUTABLE_VERSION "${CMAKE_MATCH_1}")
-  endif()
-
-  if(Protobuf_DEBUG)
-    message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] "
-        "${Protobuf_PROTOC_EXECUTABLE} reveals version ${_PROTOBUF_PROTOC_EXECUTABLE_VERSION}")
-  endif()
-
-  if(NOT "${_PROTOBUF_PROTOC_EXECUTABLE_VERSION}" VERSION_EQUAL "${Protobuf_VERSION}")
-      message(WARNING "Protobuf compiler version ${_PROTOBUF_PROTOC_EXECUTABLE_VERSION}"
-          " doesn't match library version ${Protobuf_VERSION}")
-  endif()
-
-  if(Protobuf_LIBRARY)
-      if(NOT TARGET protobuf::libprotobuf)
-          add_library(protobuf::libprotobuf UNKNOWN IMPORTED)
-          set_target_properties(protobuf::libprotobuf PROPERTIES
-            INTERFACE_INCLUDE_DIRECTORIES "${Protobuf_INCLUDE_DIR}")
-          if(EXISTS "${Protobuf_LIBRARY}")
-            set_target_properties(protobuf::libprotobuf PROPERTIES
-              IMPORTED_LOCATION "${Protobuf_LIBRARY}")
-          endif()
-          if(EXISTS "${Protobuf_LIBRARY_RELEASE}")
-            set_property(TARGET protobuf::libprotobuf APPEND PROPERTY
-              IMPORTED_CONFIGURATIONS RELEASE)
-            set_target_properties(protobuf::libprotobuf PROPERTIES
-              IMPORTED_LOCATION_RELEASE "${Protobuf_LIBRARY_RELEASE}")
-          endif()
-          if(EXISTS "${Protobuf_LIBRARY_DEBUG}")
-            set_property(TARGET protobuf::libprotobuf APPEND PROPERTY
-              IMPORTED_CONFIGURATIONS DEBUG)
-            set_target_properties(protobuf::libprotobuf PROPERTIES
-              IMPORTED_LOCATION_DEBUG "${Protobuf_LIBRARY_DEBUG}")
-          endif()
-      endif()
-  endif()
-
-  if(Protobuf_LITE_LIBRARY)
-      if(NOT TARGET protobuf::libprotobuf-lite)
-          add_library(protobuf::libprotobuf-lite UNKNOWN IMPORTED)
-          set_target_properties(protobuf::libprotobuf-lite PROPERTIES
-            INTERFACE_INCLUDE_DIRECTORIES "${Protobuf_INCLUDE_DIR}")
-          if(EXISTS "${Protobuf_LITE_LIBRARY}")
-            set_target_properties(protobuf::libprotobuf-lite PROPERTIES
-              IMPORTED_LOCATION "${Protobuf_LITE_LIBRARY}")
-          endif()
-          if(EXISTS "${Protobuf_LITE_LIBRARY_RELEASE}")
-            set_property(TARGET protobuf::libprotobuf-lite APPEND PROPERTY
-              IMPORTED_CONFIGURATIONS RELEASE)
-            set_target_properties(protobuf::libprotobuf-lite PROPERTIES
-              IMPORTED_LOCATION_RELEASE "${Protobuf_LITE_LIBRARY_RELEASE}")
-          endif()
-          if(EXISTS "${Protobuf_LITE_LIBRARY_DEBUG}")
-            set_property(TARGET protobuf::libprotobuf-lite APPEND PROPERTY
-              IMPORTED_CONFIGURATIONS DEBUG)
-            set_target_properties(protobuf::libprotobuf-lite PROPERTIES
-              IMPORTED_LOCATION_DEBUG "${Protobuf_LITE_LIBRARY_DEBUG}")
-          endif()
-      endif()
-  endif()
-
-  if(Protobuf_PROTOC_LIBRARY)
-      if(NOT TARGET protobuf::libprotoc)
-          add_library(protobuf::libprotoc UNKNOWN IMPORTED)
-          set_target_properties(protobuf::libprotoc PROPERTIES
-            INTERFACE_INCLUDE_DIRECTORIES "${Protobuf_INCLUDE_DIR}")
-          if(EXISTS "${Protobuf_PROTOC_LIBRARY}")
-            set_target_properties(protobuf::libprotoc PROPERTIES
-              IMPORTED_LOCATION "${Protobuf_PROTOC_LIBRARY}")
-          endif()
-          if(EXISTS "${Protobuf_PROTOC_LIBRARY_RELEASE}")
-            set_property(TARGET protobuf::libprotoc APPEND PROPERTY
-              IMPORTED_CONFIGURATIONS RELEASE)
-            set_target_properties(protobuf::libprotoc PROPERTIES
-              IMPORTED_LOCATION_RELEASE "${Protobuf_PROTOC_LIBRARY_RELEASE}")
-          endif()
-          if(EXISTS "${Protobuf_PROTOC_LIBRARY_DEBUG}")
-            set_property(TARGET protobuf::libprotoc APPEND PROPERTY
-              IMPORTED_CONFIGURATIONS DEBUG)
-            set_target_properties(protobuf::libprotoc PROPERTIES
-              IMPORTED_LOCATION_DEBUG "${Protobuf_PROTOC_LIBRARY_DEBUG}")
-          endif()
-      endif()
-  endif()
-
-  if(Protobuf_PROTOC_EXECUTABLE)
-      if(NOT TARGET protobuf::protoc)
-          add_executable(protobuf::protoc IMPORTED)
-          if(EXISTS "${Protobuf_PROTOC_EXECUTABLE}")
-            set_target_properties(protobuf::protoc PROPERTIES
-              IMPORTED_LOCATION "${Protobuf_PROTOC_EXECUTABLE}")
-          endif()
-      endif()
-  endif()
-endif()
-
-include(${CMAKE_CURRENT_LIST_DIR}/FindPackageHandleStandardArgs.cmake)
-FIND_PACKAGE_HANDLE_STANDARD_ARGS(Protobuf
-    REQUIRED_VARS Protobuf_LIBRARIES Protobuf_INCLUDE_DIR
-    VERSION_VAR Protobuf_VERSION
-)
-
-if(Protobuf_FOUND)
-    set(Protobuf_INCLUDE_DIRS ${Protobuf_INCLUDE_DIR})
-endif()
-
-# Restore the original find library ordering
-if( Protobuf_USE_STATIC_LIBS )
-  set(CMAKE_FIND_LIBRARY_SUFFIXES ${_protobuf_ORIG_CMAKE_FIND_LIBRARY_SUFFIXES})
-endif()
-
-# Backwards compatibility
-# Define upper case versions of output variables
-foreach(Camel
-    Protobuf_SRC_ROOT_FOLDER
-    Protobuf_IMPORT_DIRS
-    Protobuf_DEBUG
-    Protobuf_INCLUDE_DIRS
-    Protobuf_LIBRARIES
-    Protobuf_PROTOC_LIBRARIES
-    Protobuf_LITE_LIBRARIES
-    Protobuf_LIBRARY
-    Protobuf_PROTOC_LIBRARY
-    Protobuf_INCLUDE_DIR
-    Protobuf_PROTOC_EXECUTABLE
-    Protobuf_LIBRARY_DEBUG
-    Protobuf_PROTOC_LIBRARY_DEBUG
-    Protobuf_LITE_LIBRARY
-    Protobuf_LITE_LIBRARY_DEBUG
-    )
-    string(TOUPPER ${Camel} UPPER)
-    set(${UPPER} ${${Camel}})
-endforeach()

cmake/SelectLibraryConfigurations.cmake

@@ -1,71 +0,0 @@
-# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
-# file Copyright.txt or https://cmake.org/licensing for details.
-
-#.rst:
-# SelectLibraryConfigurations
-# ---------------------------
-#
-#
-#
-# select_library_configurations( basename )
-#
-# This macro takes a library base name as an argument, and will choose
-# good values for basename_LIBRARY, basename_LIBRARIES,
-# basename_LIBRARY_DEBUG, and basename_LIBRARY_RELEASE depending on what
-# has been found and set.  If only basename_LIBRARY_RELEASE is defined,
-# basename_LIBRARY will be set to the release value, and
-# basename_LIBRARY_DEBUG will be set to basename_LIBRARY_DEBUG-NOTFOUND.
-# If only basename_LIBRARY_DEBUG is defined, then basename_LIBRARY will
-# take the debug value, and basename_LIBRARY_RELEASE will be set to
-# basename_LIBRARY_RELEASE-NOTFOUND.
-#
-# If the generator supports configuration types, then basename_LIBRARY
-# and basename_LIBRARIES will be set with debug and optimized flags
-# specifying the library to be used for the given configuration.  If no
-# build type has been set or the generator in use does not support
-# configuration types, then basename_LIBRARY and basename_LIBRARIES will
-# take only the release value, or the debug value if the release one is
-# not set.
-
-# This macro was adapted from the FindQt4 CMake module and is maintained by Will
-# Dicharry <wdicharry@stellarscience.com>.
-
-macro( select_library_configurations basename )
-    if(NOT ${basename}_LIBRARY_RELEASE)
-        set(${basename}_LIBRARY_RELEASE "${basename}_LIBRARY_RELEASE-NOTFOUND" CACHE FILEPATH "Path to a library.")
-    endif()
-    if(NOT ${basename}_LIBRARY_DEBUG)
-        set(${basename}_LIBRARY_DEBUG "${basename}_LIBRARY_DEBUG-NOTFOUND" CACHE FILEPATH "Path to a library.")
-    endif()
-
-    get_property(_isMultiConfig GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
-    if( ${basename}_LIBRARY_DEBUG AND ${basename}_LIBRARY_RELEASE AND
-           NOT ${basename}_LIBRARY_DEBUG STREQUAL ${basename}_LIBRARY_RELEASE AND
-           ( _isMultiConfig OR CMAKE_BUILD_TYPE ) )
-        # if the generator is multi-config or if CMAKE_BUILD_TYPE is set for
-        # single-config generators, set optimized and debug libraries
-        set( ${basename}_LIBRARY "" )
-        foreach( _libname IN LISTS ${basename}_LIBRARY_RELEASE )
-            list( APPEND ${basename}_LIBRARY optimized "${_libname}" )
-        endforeach()
-        foreach( _libname IN LISTS ${basename}_LIBRARY_DEBUG )
-            list( APPEND ${basename}_LIBRARY debug "${_libname}" )
-        endforeach()
-    elseif( ${basename}_LIBRARY_RELEASE )
-        set( ${basename}_LIBRARY ${${basename}_LIBRARY_RELEASE} )
-    elseif( ${basename}_LIBRARY_DEBUG )
-        set( ${basename}_LIBRARY ${${basename}_LIBRARY_DEBUG} )
-    else()
-        set( ${basename}_LIBRARY "${basename}_LIBRARY-NOTFOUND")
-    endif()
-
-    set( ${basename}_LIBRARIES "${${basename}_LIBRARY}" )
-
-    if( ${basename}_LIBRARY )
-        set( ${basename}_FOUND TRUE )
-    endif()
-
-    mark_as_advanced( ${basename}_LIBRARY_RELEASE
-        ${basename}_LIBRARY_DEBUG
-    )
-endmacro()

common/CMakeLists.txt

@@ -1,11 +1,9 @@
 CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
-SET(PROTOBUF_GENERATE_CPP_APPEND_PATH "../../")
-
-PROTOBUF_GENERATE_CPP(PROTO_SRCS PROTO_HEADERS message.proto)
 
 SET(common_sources
 	base_packet.cpp
 	classes.cpp
+	compression.cpp
 	condition.cpp
 	crash.cpp
 	crc16.cpp
@@ -16,7 +14,6 @@ SET(common_sources
 	dbcore.cpp
 	deity.cpp
 	emu_constants.cpp
-	emu_legacy.cpp
 	emu_limits.cpp
 	emu_opcodes.cpp
 	emu_versions.cpp
@@ -42,10 +39,9 @@ SET(common_sources
 	item_instance.cpp
 	json_config.cpp
 	light_source.cpp
-	md5.cpp	
+	md5.cpp
 	memory_buffer.cpp
 	memory_mapped_file.cpp
-	message.pb.cc
 	misc.cpp
 	misc_functions.cpp
 	mutex.cpp
@@ -64,6 +60,7 @@ SET(common_sources
 	rdtsc.cpp
 	rulesys.cpp
 	say_link.cpp
+	serialize_buffer.cpp
 	serverinfo.cpp
 	shareddb.cpp
 	skills.cpp
@@ -101,7 +98,7 @@ SET(common_sources
 	patches/titanium.cpp
 	patches/titanium_limits.cpp
 	patches/uf.cpp
-	patches/uf_limits.cpp	
+	patches/uf_limits.cpp
 	StackWalker/StackWalker.cpp
 	tinyxml/tinystr.cpp
 	tinyxml/tinyxml.cpp
@@ -117,6 +114,7 @@ SET(common_headers
 	base_data.h
 	bodytypes.h
 	classes.h
+	compression.h
 	condition.h
 	crash.h
 	crc16.h
@@ -126,7 +124,6 @@ SET(common_headers
 	dbcore.h
 	deity.h
 	emu_constants.h
-	emu_legacy.h
 	emu_limits.h
 	emu_opcodes.h
 	emu_oplist.h
@@ -171,7 +168,6 @@ SET(common_headers
 	md5.h
 	memory_buffer.h
 	memory_mapped_file.h
-	message.pb.h
 	misc.h
 	misc_functions.h
 	mutex.h
@@ -195,6 +191,7 @@ SET(common_headers
 	ruletypes.h
 	say_link.h
 	seperator.h
+	serialize_buffer.h
 	serverinfo.h
 	servertalk.h
 	shareddb.h

common/base_packet.cpp

@@ -39,6 +39,18 @@ BasePacket::BasePacket(const unsigned char *buf, uint32 len)
 	}
 }
 
+BasePacket::BasePacket(SerializeBuffer &buf)
+{
+	pBuffer = buf.m_buffer;
+	buf.m_buffer = nullptr;
+	size = buf.m_pos;
+	buf.m_pos = 0;
+	buf.m_capacity = 0;
+	_wpos = 0;
+	_rpos = 0;
+	timestamp.tv_sec = 0;
+}
+
 BasePacket::~BasePacket()
 {
 	if (pBuffer)

common/base_packet.h

@@ -19,6 +19,7 @@
 #define BASEPACKET_H_
 
 #include "types.h"
+#include "serialize_buffer.h"
 #include <stdio.h>
 #include <string.h>
 
@@ -63,6 +64,8 @@ public:
 	void WriteFloat(float value) { *(float *)(pBuffer + _wpos) = value; _wpos += sizeof(float); }
 	void WriteDouble(double value) { *(double *)(pBuffer + _wpos) = value; _wpos += sizeof(double); }
 	void WriteString(const char * str) { uint32 len = static_cast<uint32>(strlen(str)) + 1; memcpy(pBuffer + _wpos, str, len); _wpos += len; }
+	// this is used in task system a lot, it is NOT null-termed
+	void WriteLengthString(uint32 len, const char *str) { *(uint32 *)(pBuffer + _wpos) = len; _wpos += sizeof(uint32); memcpy(pBuffer + _wpos, str, len); _wpos += len; }
 	void WriteData(const void *ptr, size_t n) { memcpy(pBuffer + _wpos, ptr, n); _wpos += n; }
 
 	uint8 ReadUInt8() { uint8 value = *(uint8 *)(pBuffer + _rpos); _rpos += sizeof(uint8); return value; }
@@ -83,6 +86,7 @@ protected:
 	virtual ~BasePacket();
 	BasePacket() { pBuffer=nullptr; size=0; _wpos = 0; _rpos = 0; }
 	BasePacket(const unsigned char *buf, const uint32 len);
+	BasePacket(SerializeBuffer &buf);
 };
 
 extern void DumpPacketHex(const BasePacket* app);

common/compression.cpp

@@ -0,0 +1,82 @@
+#include "global_define.h"
+#include "types.h"
+#include <string.h>
+#include <zlib.h>
+
+namespace EQEmu
+{
+	uint32 EstimateDeflateBuffer(uint32 len) {
+		z_stream zstream;
+		memset(&zstream, 0, sizeof(zstream));
+
+		zstream.zalloc = Z_NULL;
+		zstream.zfree = Z_NULL;
+		zstream.opaque = Z_NULL;
+		if (deflateInit(&zstream, Z_FINISH) != Z_OK)
+			return 0;
+
+		return deflateBound(&zstream, len);
+	}
+
+	uint32 DeflateData(const char *buffer, uint32 len, char *out_buffer, uint32 out_len_max) {
+		z_stream zstream;
+		memset(&zstream, 0, sizeof(zstream));
+		int zerror;
+
+		zstream.next_in = const_cast<unsigned char*>(reinterpret_cast<const unsigned char*>(buffer));
+		zstream.avail_in = len;
+		zstream.zalloc = Z_NULL;
+		zstream.zfree = Z_NULL;
+		zstream.opaque = Z_NULL;
+		deflateInit(&zstream, Z_FINISH);
+
+		zstream.next_out = reinterpret_cast<unsigned char*>(out_buffer);
+		zstream.avail_out = out_len_max;
+		zerror = deflate(&zstream, Z_FINISH);
+
+		if (zerror == Z_STREAM_END)
+		{
+			deflateEnd(&zstream);
+			return (uint32)zstream.total_out;
+		}
+		else
+		{
+			zerror = deflateEnd(&zstream);
+			return 0;
+		}
+	}
+
+	uint32 InflateData(const char* buffer, uint32 len, char* out_buffer, uint32 out_len_max) {
+		z_stream zstream;
+		int zerror = 0;
+		int i;
+
+		zstream.next_in = const_cast<unsigned char*>(reinterpret_cast<const unsigned char*>(buffer));
+		zstream.avail_in = len;
+		zstream.next_out = reinterpret_cast<unsigned char*>(out_buffer);;
+		zstream.avail_out = out_len_max;
+		zstream.zalloc = Z_NULL;
+		zstream.zfree = Z_NULL;
+		zstream.opaque = Z_NULL;
+
+		i = inflateInit2(&zstream, 15);
+		if (i != Z_OK) {
+			return 0;
+		}
+
+		zerror = inflate(&zstream, Z_FINISH);
+		if (zerror == Z_STREAM_END) {
+			inflateEnd(&zstream);
+			return zstream.total_out;
+		}
+		else {
+			if (zerror == -4 && zstream.msg == 0)
+			{
+				return 0;
+			}
+
+			zerror = inflateEnd(&zstream);
+			return 0;
+		}
+	}
+}

common/compression.h

@@ -0,0 +1,8 @@
+#pragma once
+
+namespace EQEmu
+{
+	uint32 EstimateDeflateBuffer(uint32 len);
+	uint32 DeflateData(const char *buffer, uint32 len, char *out_buffer, uint32 out_len_max);
+	uint32 InflateData(const char* buffer, uint32 len, char* out_buffer, uint32 out_len_max);
+}

common/database.cpp

@@ -708,7 +708,7 @@ bool Database::StoreCharacter(uint32 account_id, PlayerProfile_Struct* pp, EQEmu
 
 	/* Insert starting inventory... */
 	std::string invquery;
-	for (int16 i = EQEmu::legacy::EQUIPMENT_BEGIN; i <= EQEmu::legacy::BANK_BAGS_END;) {
+	for (int16 i = EQEmu::invslot::EQUIPMENT_BEGIN; i <= EQEmu::invbag::BANK_BAGS_END;) {
 		const EQEmu::ItemInstance* newinv = inv->GetItem(i);
 		if (newinv) {
 			invquery = StringFormat("INSERT INTO `inventory` (charid, slotid, itemid, charges, color) VALUES (%u, %i, %u, %i, %u)",
@@ -717,16 +717,16 @@ bool Database::StoreCharacter(uint32 account_id, PlayerProfile_Struct* pp, EQEmu
 			auto results = QueryDatabase(invquery); 
 		}
 
-		if (i == EQEmu::inventory::slotCursor) {
-			i = EQEmu::legacy::GENERAL_BAGS_BEGIN; 
+		if (i == EQEmu::invslot::slotCursor) {
+			i = EQEmu::invbag::GENERAL_BAGS_BEGIN; 
 			continue;
 		}
-		else if (i == EQEmu::legacy::CURSOR_BAG_END) { 
-			i = EQEmu::legacy::BANK_BEGIN; 
+		else if (i == EQEmu::invbag::CURSOR_BAG_END) { 
+			i = EQEmu::invslot::BANK_BEGIN; 
 			continue; 
 		}
-		else if (i == EQEmu::legacy::BANK_END) { 
-			i = EQEmu::legacy::BANK_BAGS_BEGIN; 
+		else if (i == EQEmu::invslot::BANK_END) { 
+			i = EQEmu::invbag::BANK_BAGS_BEGIN; 
 			continue; 
 		} 
 		i++;
@@ -1752,6 +1752,15 @@ void Database::ClearRaidDetails(uint32 rid) {
 		std::cout << "Unable to clear raid details: " << results.ErrorMessage() << std::endl;
 }
 
+void Database::PurgeAllDeletedDataBuckets() {
+	std::string query = StringFormat(
+			"DELETE FROM `data_buckets` WHERE (`expires` < %lld AND `expires` > 0)",
+			(long long) std::time(nullptr)
+	);
+
+	QueryDatabase(query);
+}
+
 // returns 0 on error or no raid for that character, or
 // the raid id that the character is a member of.
 uint32 Database::GetRaidID(const char* name)

common/database.h

@@ -221,6 +221,8 @@ public:
 	void	GetRaidLeadershipInfo(uint32 rid, char* maintank = nullptr, char* assist = nullptr, char* puller = nullptr, char *marknpc = nullptr, RaidLeadershipAA_Struct* RLAA = nullptr);
 	void	SetRaidGroupLeaderInfo(uint32 gid, uint32 rid);
 
+	void    PurgeAllDeletedDataBuckets();
+
 	/* Database Conversions 'database_conversions.cpp' */
 
 	bool	CheckDatabaseConversions();

common/database_conversions.cpp

@@ -41,6 +41,9 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 
 #pragma pack(1)
 
+// all const/macro reference values should really be converted to a magic number for this
+// process to ensure that the struct sizes and offsets match up to the corresponding blob
+
 /* Conversion Structs */
 
 namespace Convert {
@@ -330,7 +333,7 @@ namespace Convert {
 		/*7212*/	uint32							tribute_points;
 		/*7216*/	uint32							unknown7252;
 		/*7220*/	uint32							tribute_active;		//1=active
-		/*7224*/	Convert::Tribute_Struct			tributes[EQEmu::legacy::TRIBUTE_SIZE];
+		/*7224*/	Convert::Tribute_Struct			tributes[5];
 		/*7264*/	Convert::Disciplines_Struct		disciplines;
 		/*7664*/	uint32							recastTimers[MAX_RECAST_TYPES];	// Timers (GMT of last use)
 		/*7744*/	char							unknown7780[160];
@@ -1405,7 +1408,7 @@ bool Database::CheckDatabaseConvertPPDeblob(){
 				if (rquery != ""){ results = QueryDatabase(rquery); }
 				/* Run Tribute Convert */
 				first_entry = 0; rquery = "";
-				for (i = 0; i < EQEmu::legacy::TRIBUTE_SIZE; i++){
+				for (i = 0; i < 5; i++){
 					if (pp->tributes[i].tribute > 0 && pp->tributes[i].tribute != 4294967295){
 						if (first_entry != 1){
 							rquery = StringFormat("REPLACE INTO `character_tribute` (id, tier, tribute) VALUES (%u, %u, %u)", character_id, pp->tributes[i].tier, pp->tributes[i].tribute);

common/emu_constants.cpp

@@ -20,6 +20,41 @@
 #include "emu_constants.h"
 
 
+int16 EQEmu::invtype::GetInvTypeSize(int16 inv_type) {
+	static const int16 local_array[] = {
+		POSSESSIONS_SIZE,
+		BANK_SIZE,
+		SHARED_BANK_SIZE,
+		TRADE_SIZE,
+		WORLD_SIZE,
+		LIMBO_SIZE,
+		TRIBUTE_SIZE,
+		TROPHY_TRIBUTE_SIZE,
+		GUILD_TRIBUTE_SIZE,
+		MERCHANT_SIZE,
+		DELETED_SIZE,
+		CORPSE_SIZE,
+		BAZAAR_SIZE,
+		INSPECT_SIZE,
+		REAL_ESTATE_SIZE,
+		VIEW_MOD_PC_SIZE,
+		VIEW_MOD_BANK_SIZE,
+		VIEW_MOD_SHARED_BANK_SIZE,
+		VIEW_MOD_LIMBO_SIZE,
+		ALT_STORAGE_SIZE,
+		ARCHIVED_SIZE,
+		MAIL_SIZE,
+		GUILD_TROPHY_TRIBUTE_SIZE,
+		KRONO_SIZE,
+		OTHER_SIZE,
+	};
+
+	if (inv_type < TYPE_BEGIN || inv_type > TYPE_END)
+		return INULL;
+
+	return local_array[inv_type];
+}
+
 const char* EQEmu::bug::CategoryIDToCategoryName(CategoryID category_id) {
 	switch (category_id) {
 	case catVideo:

common/emu_constants.h

@@ -21,104 +21,173 @@
 #define COMMON_EMU_CONSTANTS_H
 
 #include "eq_limits.h"
-#include "emu_legacy.h"
 #include "emu_versions.h"
 
 #include <string.h>
 
 
+// local definitions are the result of using hybrid-client or server-only values and methods
 namespace EQEmu
 {
+	using RoF2::IINVALID;
+	using RoF2::INULL;
+	
 	namespace inventory {
-		//using namespace RoF2::invtype;
-		//using namespace RoF2::invslot;
-		//using namespace RoF2::invbag;
-		//using namespace RoF2::invaug;
-
-		enum : int16 { typeInvalid = -1, slotInvalid = -1, containerInvalid = -1, socketInvalid = -1 }; // temporary
-		enum : int16 { typeBegin = 0, slotBegin = 0, containerBegin = 0, socketBegin = 0 }; // temporary
-
-		enum PossessionsSlots : int16 { // temporary
-			slotCharm = 0,
-			slotEar1,
-			slotHead,
-			slotFace,
-			slotEar2,
-			slotNeck, // 5
-			slotShoulders,
-			slotArms,
-			slotBack,
-			slotWrist1,
-			slotWrist2, // 10
-			slotRange,
-			slotHands,
-			slotPrimary,
-			slotSecondary,
-			slotFinger1, // 15
-			slotFinger2,
-			slotChest,
-			slotLegs,
-			slotFeet,
-			slotWaist, // 20
-			slotPowerSource = 9999,
-			slotAmmo = 21,
-			slotGeneral1,
-			slotGeneral2,
-			slotGeneral3,
-			slotGeneral4, // 25
-			slotGeneral5,
-			slotGeneral6,
-			slotGeneral7,
-			slotGeneral8,
-			slotCursor, // 30
-			slotCount
-		};
-
-		enum InventoryTypes : int16 { // temporary
-			typePossessions = 0,
-			typeBank,
-			typeSharedBank,
-			typeTrade,
-			typeWorld,
-			typeLimbo, // 5
-			typeTribute,
-			typeTrophyTribute,
-			typeGuildTribute,
-			typeMerchant,
-			typeDeleted, // 10
-			typeCorpse,
-			typeBazaar,
-			typeInspect,
-			typeRealEstate,
-			typeViewMODPC, // 15
-			typeViewMODBank,
-			typeViewMODSharedBank,
-			typeViewMODLimbo,
-			typeAltStorage,
-			typeArchived, // 20
-			typeMail,
-			typeGuildTrophyTribute,
-			typeKrono,
-			typeOther,
-			typeCount
-		};
-
-		static int16 SlotCount(int16 type_index) { return 0; } // temporary
-
-		const int16 ContainerCount = 10; // temporary
-		const int16 SocketCount = 6; // temporary
-
+		
 	} /*inventory*/
 
-	namespace constants {
-		const EQEmu::versions::ClientVersion CharacterCreationClient = EQEmu::versions::ClientVersion::RoF2;
-		const size_t CharacterCreationMax = RoF2::constants::CharacterCreationLimit;
+	namespace invtype {
+		using namespace RoF2::invtype::enum_;
 
-		const size_t SayLinkOpenerSize = 1;
-		const size_t SayLinkBodySize = RoF2::constants::SayLinkBodySize;
-		const size_t SayLinkTextSize = 256; // this may be varied until it breaks something (tested:374) - the others are constant
-		const size_t SayLinkCloserSize = 1;
-		const size_t SayLinkMaximumSize = (SayLinkOpenerSize + SayLinkBodySize + SayLinkTextSize + SayLinkCloserSize);
+		using RoF2::invtype::POSSESSIONS_SIZE;
+		using RoF2::invtype::BANK_SIZE;
+		using RoF2::invtype::SHARED_BANK_SIZE;
+		using RoF2::invtype::TRADE_SIZE;
+		using RoF2::invtype::WORLD_SIZE;
+		using RoF2::invtype::LIMBO_SIZE;
+		using RoF2::invtype::TRIBUTE_SIZE;
+		using RoF2::invtype::TROPHY_TRIBUTE_SIZE;
+		using RoF2::invtype::GUILD_TRIBUTE_SIZE;
+		using RoF2::invtype::MERCHANT_SIZE;
+		using RoF2::invtype::DELETED_SIZE;
+		using RoF2::invtype::CORPSE_SIZE;
+		using RoF2::invtype::BAZAAR_SIZE;
+		using RoF2::invtype::INSPECT_SIZE;
+		using RoF2::invtype::REAL_ESTATE_SIZE;
+		using RoF2::invtype::VIEW_MOD_PC_SIZE;
+		using RoF2::invtype::VIEW_MOD_BANK_SIZE;
+		using RoF2::invtype::VIEW_MOD_SHARED_BANK_SIZE;
+		using RoF2::invtype::VIEW_MOD_LIMBO_SIZE;
+		using RoF2::invtype::ALT_STORAGE_SIZE;
+		using RoF2::invtype::ARCHIVED_SIZE;
+		using RoF2::invtype::MAIL_SIZE;
+		using RoF2::invtype::GUILD_TROPHY_TRIBUTE_SIZE;
+		using RoF2::invtype::KRONO_SIZE;
+		using RoF2::invtype::OTHER_SIZE;
+
+		using Titanium::invtype::TRADE_NPC_SIZE;
+
+		using RoF2::invtype::TYPE_INVALID;
+		using RoF2::invtype::TYPE_BEGIN;
+		using RoF2::invtype::TYPE_END;
+		using RoF2::invtype::TYPE_COUNT;
+
+		int16 GetInvTypeSize(int16 inv_type);
+		using RoF2::invtype::GetInvTypeName;
+
+	} // namespace invtype
+
+	namespace invslot {
+		using namespace Titanium::invslot::enum_;
+
+		const int16 SLOT_POWER_SOURCE = 9999;
+
+		using RoF2::invslot::SLOT_INVALID;
+		using RoF2::invslot::SLOT_BEGIN;
+
+		using Titanium::invslot::POSSESSIONS_BEGIN;
+		using Titanium::invslot::POSSESSIONS_END;
+		using SoF::invslot::POSSESSIONS_COUNT;
+
+		using Titanium::invslot::EQUIPMENT_BEGIN;
+		using Titanium::invslot::EQUIPMENT_END;
+		using Titanium::invslot::EQUIPMENT_COUNT;
+
+		using Titanium::invslot::GENERAL_BEGIN;
+		using Titanium::invslot::GENERAL_END;
+		using Titanium::invslot::GENERAL_COUNT;
+
+		using Titanium::invslot::BONUS_BEGIN;
+		using Titanium::invslot::BONUS_STAT_END;
+		using Titanium::invslot::BONUS_SKILL_END;
+
+		using Titanium::invslot::BANK_BEGIN;
+		using SoF::invslot::BANK_END;
+
+		using Titanium::invslot::SHARED_BANK_BEGIN;
+		using Titanium::invslot::SHARED_BANK_END;
+
+		using Titanium::invslot::TRADE_BEGIN;
+		using Titanium::invslot::TRADE_END;
+
+		using Titanium::invslot::TRADE_NPC_END;
+
+		using Titanium::invslot::WORLD_BEGIN;
+		using Titanium::invslot::WORLD_END;
+
+		using Titanium::invslot::TRIBUTE_BEGIN;
+		using Titanium::invslot::TRIBUTE_END;
+
+		using Titanium::invslot::GUILD_TRIBUTE_BEGIN;
+		using Titanium::invslot::GUILD_TRIBUTE_END;
+
+		const int16 CORPSE_BEGIN = invslot::slotGeneral1;
+		const int16 CORPSE_END = CORPSE_BEGIN + invslot::slotCursor;
+
+		using RoF2::invslot::POSSESSIONS_BITMASK;
+		using RoF2::invslot::CORPSE_BITMASK;
+
+		using RoF2::invslot::GetInvPossessionsSlotName;
+		using RoF2::invslot::GetInvSlotName;
+
+	} // namespace invslot
+
+	namespace invbag {
+		using Titanium::invbag::SLOT_INVALID;
+		using Titanium::invbag::SLOT_BEGIN;
+		using Titanium::invbag::SLOT_END;
+		using Titanium::invbag::SLOT_COUNT;
+
+		using Titanium::invbag::GENERAL_BAGS_BEGIN;
+		const int16 GENERAL_BAGS_COUNT = invslot::GENERAL_COUNT * SLOT_COUNT;
+		const int16 GENERAL_BAGS_END = (GENERAL_BAGS_BEGIN + GENERAL_BAGS_COUNT) - 1;
+
+		const int16 GENERAL_BAGS_8_COUNT = 8 * SLOT_COUNT;
+		const int16 GENERAL_BAGS_8_END = (GENERAL_BAGS_BEGIN + GENERAL_BAGS_8_COUNT) - 1;
+
+		const int16 CURSOR_BAG_BEGIN = 331;
+		const int16 CURSOR_BAG_COUNT = SLOT_COUNT;
+		const int16 CURSOR_BAG_END = (CURSOR_BAG_BEGIN + CURSOR_BAG_COUNT) - 1;
+
+		using Titanium::invbag::BANK_BAGS_BEGIN;
+		const int16 BANK_BAGS_COUNT = (invtype::BANK_SIZE * SLOT_COUNT);
+		const int16 BANK_BAGS_END = (BANK_BAGS_BEGIN + BANK_BAGS_COUNT) - 1;
+
+		const int16 BANK_BAGS_16_COUNT = 16 * SLOT_COUNT;
+		const int16 BANK_BAGS_16_END = (BANK_BAGS_BEGIN + BANK_BAGS_16_COUNT) - 1;
+
+		using Titanium::invbag::SHARED_BANK_BAGS_BEGIN;
+		const int16 SHARED_BANK_BAGS_COUNT = invtype::SHARED_BANK_SIZE * SLOT_COUNT;
+		const int16 SHARED_BANK_BAGS_END = (SHARED_BANK_BAGS_BEGIN + SHARED_BANK_BAGS_COUNT) - 1;
+
+		using Titanium::invbag::TRADE_BAGS_BEGIN;
+		const int16 TRADE_BAGS_COUNT = invtype::TRADE_SIZE * SLOT_COUNT;
+		const int16 TRADE_BAGS_END = (TRADE_BAGS_BEGIN + TRADE_BAGS_COUNT) - 1;
+
+		using Titanium::invbag::GetInvBagIndexName;
+
+	} // namespace invbag
+
+	namespace invaug {
+		using RoF2::invaug::SOCKET_INVALID;
+		using RoF2::invaug::SOCKET_BEGIN;
+		using RoF2::invaug::SOCKET_END;
+		using RoF2::invaug::SOCKET_COUNT;
+
+		using RoF2::invaug::GetInvAugIndexName;
+
+	} // namespace invaug
+
+	namespace constants {
+		const EQEmu::versions::ClientVersion CHARACTER_CREATION_CLIENT = EQEmu::versions::ClientVersion::Titanium;
+
+		using RoF2::constants::CHARACTER_CREATION_LIMIT;
+		
+		const size_t SAY_LINK_OPENER_SIZE = 1;
+		using RoF2::constants::SAY_LINK_BODY_SIZE;
+		const size_t SAY_LINK_TEXT_SIZE = 256; // this may be varied until it breaks something (tested:374) - the others are constant
+		const size_t SAY_LINK_CLOSER_SIZE = 1;
+		const size_t SAY_LINK_MAXIMUM_SIZE = (SAY_LINK_OPENER_SIZE + SAY_LINK_BODY_SIZE + SAY_LINK_TEXT_SIZE + SAY_LINK_CLOSER_SIZE);
 
 		const int LongBuffs = RoF2::constants::LongBuffs;
 		const int ShortBuffs = RoF2::constants::ShortBuffs;
@@ -130,6 +199,21 @@ namespace EQEmu
 
 	} /*constants*/
 
+	namespace profile {
+		using RoF2::profile::BANDOLIERS_SIZE;
+		using RoF2::profile::BANDOLIER_ITEM_COUNT;
+		
+		using RoF2::profile::POTION_BELT_SIZE;
+
+		using RoF2::profile::SKILL_ARRAY_SIZE;
+
+	} // namespace profile
+
+	namespace behavior {
+		using RoF2::behavior::CoinHasWeight;
+
+	} // namespace behavior
+
 	namespace bug {
 		enum CategoryID : uint32 {
 			catOther = 0,

common/emu_legacy.cpp

@@ -1,20 +0,0 @@
-/*	EQEMu:  Everquest Server Emulator
-	
-	Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
-
-	This program is free software; you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation; version 2 of the License.
-
-	This program is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY except by those people which sell it, which
-	are required to give you total support for your newly bought product;
-	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-	A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
-	
-	You should have received a copy of the GNU General Public License
-	along with this program; if not, write to the Free Software
-	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-*/
-
-#include "emu_legacy.h"

common/emu_legacy.h

@@ -1,182 +0,0 @@
-/*	EQEMu:  Everquest Server Emulator
-	
-	Copyright (C) 2001-2016 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_EMU_LEGACY_H
-#define COMMON_EMU_LEGACY_H
-
-#include "types.h"
-
-#include <stdlib.h>
-
-
-namespace EQEmu
-{
-	// this is for perl and other legacy systems
-	namespace legacy {
-		enum InventorySlot {
-			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_CURSOR = 30,
-			SLOT_CURSOR_END = (int16)0xFFFE, // I hope no one is using this...
-			SLOT_TRADESKILL = 1000,
-			SLOT_AUGMENT = 1001,
-			SLOT_INVALID = (int16)0xFFFF,
-			SLOT_POSSESSIONS_BEGIN = 0,
-			SLOT_POSSESSIONS_END = 30,
-			SLOT_EQUIPMENT_BEGIN = 0,
-			SLOT_EQUIPMENT_END = 21,
-			SLOT_PERSONAL_BEGIN = 22,
-			SLOT_PERSONAL_END = 29,
-			SLOT_PERSONAL_BAGS_BEGIN = 251,
-			SLOT_PERSONAL_BAGS_END = 330,
-			SLOT_CURSOR_BAG_BEGIN = 331,
-			SLOT_CURSOR_BAG_END = 340,
-			SLOT_TRIBUTE_BEGIN = 400,
-			SLOT_TRIBUTE_END = 404,
-			SLOT_GUILD_TRIBUTE_BEGIN = 450,
-			SLOT_GUILD_TRIBUTE_END = 451,
-			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
-		};
-
-		// these are currently hard-coded for existing inventory system..do not use in place of special client version handlers until ready
-		static const uint16	TYPE_POSSESSIONS_SIZE = 31;
-		static const uint16 TYPE_BANK_SIZE = 24;
-		static const uint16 TYPE_SHARED_BANK_SIZE = 2;
-		static const uint16 TYPE_TRADE_SIZE = 8;
-		static const uint16 TYPE_WORLD_SIZE = 10;
-		static const uint16 TYPE_LIMBO_SIZE = 36;
-		static const uint16 TYPE_TRIBUTE_SIZE = 5; // (need client values)
-		static const uint16 TYPE_TROPHY_TRIBUTE_SIZE = 0;
-		static const uint16 TYPE_GUILD_TRIBUTE_SIZE = 0;
-		static const uint16 TYPE_MERCHANT_SIZE = 0;
-		static const uint16 TYPE_DELETED_SIZE = 0;
-		static const uint16 TYPE_CORPSE_SIZE = 31; // no bitmask use..limits to size of client corpse window (see EQLimits::InventoryMapSize(MapCorpse, <EQClientVersion))
-		static const uint16 TYPE_BAZAAR_SIZE = 80;
-		static const uint16 TYPE_INSPECT_SIZE = 22;
-		static const uint16 TYPE_REAL_ESTATE_SIZE = 0;
-		static const uint16 TYPE_VIEW_MOD_PC_SIZE = 0;
-		static const uint16 TYPE_VIEW_MOD_BANK_SIZE = 0;
-		static const uint16 TYPE_VIEW_MOD_SHARED_BANK_SIZE = 0;
-		static const uint16 TYPE_VIEW_MOD_LIMBO_SIZE = 0;
-		static const uint16 TYPE_ALT_STORAGE_SIZE = 0;
-		static const uint16 TYPE_ARCHIVED_SIZE = 0;
-		static const uint16 TYPE_MAIL_SIZE = 0;
-		static const uint16 TYPE_GUILD_TROPHY_TRIBUTE_SIZE = 0;
-		static const uint16 TYPE_KRONO_SIZE = 0;
-		static const uint16 TYPE_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 = 0;
-		static const int16 EQUIPMENT_END = 21;
-		static const uint16 EQUIPMENT_SIZE = 22; // does not account for 'Power Source' - used mainly for npc equipment arrays
-
-		static const int16 GENERAL_BEGIN = 22;
-		static const int16 GENERAL_END = 29;
-		static const uint16 GENERAL_SIZE = 8;
-		static const int16 GENERAL_BAGS_BEGIN = 251;
-		static const int16 GENERAL_BAGS_END_OFFSET = 79;
-		static const int16 GENERAL_BAGS_END = GENERAL_BAGS_BEGIN + GENERAL_BAGS_END_OFFSET;
-
-		static const int16 CURSOR_BAG_BEGIN = 331;
-		static const int16 CURSOR_BAG_END_OFFSET = 9;
-		static const int16 CURSOR_BAG_END = CURSOR_BAG_BEGIN + CURSOR_BAG_END_OFFSET;
-
-		static const int16 BANK_BEGIN = 2000;
-		static const int16 BANK_END = 2023;
-		static const int16 BANK_BAGS_BEGIN = 2031;
-		static const int16 BANK_BAGS_END_OFFSET = 239;
-		static const int16 BANK_BAGS_END = BANK_BAGS_BEGIN + BANK_BAGS_END_OFFSET;
-
-		static const int16 SHARED_BANK_BEGIN = 2500;
-		static const int16 SHARED_BANK_END = 2501;
-		static const int16 SHARED_BANK_BAGS_BEGIN = 2531;
-		static const int16 SHARED_BANK_BAGS_END_OFFSET = 19;
-		static const int16 SHARED_BANK_BAGS_END = SHARED_BANK_BAGS_BEGIN + SHARED_BANK_BAGS_END_OFFSET;
-
-		static const int16 TRADE_BEGIN = 3000;
-		static const int16 TRADE_END = 3007;
-		static const int16 TRADE_NPC_END = 3003;
-		static const int16 TRADE_BAGS_BEGIN = 3031;
-		static const int16 TRADE_BAGS_END_OFFSET = 79;
-		static const int16 TRADE_BAGS_END = TRADE_BAGS_BEGIN + TRADE_BAGS_END_OFFSET;
-
-		static const int16 WORLD_BEGIN = 4000;
-		static const int16 WORLD_END = 4009;
-		static const int16 WORLD_SIZE = TYPE_WORLD_SIZE;
-
-		static const int16 TRIBUTE_BEGIN = 400;
-		static const int16 TRIBUTE_END = 404;
-		static const int16 TRIBUTE_SIZE = TYPE_TRIBUTE_SIZE;
-
-		static const int16 CORPSE_BEGIN = 22;
-
-		// BANDOLIERS_SIZE sets maximum limit..active limit will need to be handled by the appropriate AA or spell (or item?)
-		static const size_t BANDOLIERS_SIZE = 20;		// number of bandolier instances
-		static const size_t BANDOLIER_ITEM_COUNT = 4;	// number of equipment slots in bandolier instance
-
-		// POTION_BELT_SIZE sets maximum limit..active limit will need to be handled by the appropriate AA or spell (or item?)
-		static const size_t POTION_BELT_ITEM_COUNT = 5;
-	}
-
-}
-
-#endif /* COMMON_EMU_LEGACY_H */

common/emu_limits.h

@@ -28,74 +28,95 @@
 namespace EntityLimits
 {
 	namespace NPC {
-		enum : int { Invalid = -1, Null, Safety };
+		const int16 IINVALID = -1;
+		const int16 INULL = 0;
 
-		enum : bool { False = false, True = true };
+		namespace invtype {
+			const int16 TRADE_SIZE = 4;
 
-		const size_t InvTypeTradeSize = 4;
+		} // namespace invtype
 
 	} /*NPC*/
 
 	namespace NPCMerchant {
-		enum : int { Invalid = -1, Null, Safety };
+		const int16 IINVALID = -1;
+		const int16 INULL = 0;
 
-		enum : bool { False = false, True = true };
+		namespace invtype {
+			const int16 TRADE_SIZE = 4;
 
-		const size_t InvTypeTradeSize = 4;
+		} // namespace invtype
 
 	} /*NPCMerchant*/
 
 	namespace Merc {
-		enum : int { Invalid = -1, Null, Safety };
+		const int16 IINVALID = -1;
+		const int16 INULL = 0;
 
-		enum : bool { False = false, True = true };
+		namespace invtype {
+			const int16 TRADE_SIZE = 4;
 
-		const size_t InvTypeTradeSize = 4;
+		} // namespace invtype
 
 	} /*Merc*/
 
 	namespace Bot {
-		enum : int { Invalid = -1, Null, Safety };
+		const int16 IINVALID = -1;
+		const int16 INULL = 0;
 
-		enum : bool { False = false, True = true };
+		namespace invtype {
+			const int16 TRADE_SIZE = 8;
 
-		const size_t InvTypeTradeSize = 8;
+		} // namespace invtype
+
+		namespace invslot {
+			const uint64 POSSESSIONS_BITMASK = 0x00000000007FFFFF; // based on 34-slot count (RoF+)
+
+		} // namespace invslot
 
 	} /*Bot*/
 
 	namespace ClientPet {
-		enum : int { Invalid = -1, Null, Safety };
+		const int16 IINVALID = -1;
+		const int16 INULL = 0;
 
-		enum : bool { False = false, True = true };
+		namespace invtype {
+			const int16 TRADE_SIZE = 4;
 
-		const size_t InvTypeTradeSize = 4;
+		} // namespace invtype
 
 	} /*Pet*/
 
 	namespace NPCPet {
-		enum : int { Invalid = -1, Null, Safety };
+		const int16 IINVALID = -1;
+		const int16 INULL = 0;
 
-		enum : bool { False = false, True = true };
+		namespace invtype {
+			const int16 TRADE_SIZE = 4;
 
-		const size_t InvTypeTradeSize = 4;
+		} // namespace invtype
 
 	} /*Pet*/
 
 	namespace MercPet {
-		enum : int { Invalid = -1, Null, Safety };
+		const int16 IINVALID = -1;
+		const int16 INULL = 0;
 
-		enum : bool { False = false, True = true };
+		namespace invtype {
+			const int16 TRADE_SIZE = 4;
 
-		const size_t InvTypeTradeSize = 4;
+		} // namespace invtype
 
 	} /*Pet*/
 
 	namespace BotPet {
-		enum : int { Invalid = -1, Null, Safety };
+		const int16 IINVALID = -1;
+		const int16 INULL = 0;
 
-		enum : bool { False = false, True = true };
+		namespace invtype {
+			const int16 TRADE_SIZE = 4;
 
-		const size_t InvTypeTradeSize = 4;
+		} // namespace invtype
 
 	} /*Pet*/
 

common/eq_constants.h

@@ -523,4 +523,18 @@ static const uint8 SkillDamageTypes[EQEmu::skills::HIGHEST_SKILL + 1] = // chang
 
 static const uint32 MAX_SPELL_DB_ID_VAL = 65535;
 
+namespace EQEmu
+{
+	namespace legacy {
+		enum InventorySlot {
+			SLOT_CURSOR_END = (int16)0xFFFE, // I hope no one is using this...
+			SLOT_TRADESKILL = 1000,
+			SLOT_AUGMENT = 1001,
+			//SLOT_INVALID = (int16)0xFFFF,
+		};
+
+	} // namespace legacy
+
+}
+
 #endif /*COMMON_EQ_CONSTANTS_H*/

common/eq_limits.h

@@ -20,7 +20,6 @@
 #ifndef COMMON_EQ_LIMITS_H
 #define COMMON_EQ_LIMITS_H
 
-#include "emu_legacy.h"
 #include "types.h"
 #include "eq_constants.h"
 #include "emu_versions.h"
@@ -37,7 +36,7 @@ namespace EQEmu
 	namespace constants {
 		class LookupEntry {
 		public:
-			size_t CharacterCreationLimit;
+			int16 CharacterCreationLimit;
 			int LongBuffs;
 			int ShortBuffs;
 			int DiscBuffs;
@@ -54,11 +53,17 @@ namespace EQEmu
 	namespace inventory {
 		class LookupEntry {
 		public:
-			size_t InventoryTypeSize[25]; // should reflect EQEmu::inventory::typeCount referenced in emu_constants.h
+			// note: 'PossessionsBitmask' needs to be attuned to the client version with the highest number
+			// of possessions slots and 'InventoryTypeSize[typePossessions]' should reflect the same count
+			// with translators adjusting for valid slot indices. Server-side validations will be performed
+			// against 'PossessionsBitmask' (note: the same applies to Corpse type size and bitmask)
+
+			int16 InventoryTypeSize[25]; // should reflect EQEmu::invtype::TYPE_COUNT referenced in emu_constants.h
 
 			uint64 PossessionsBitmask;
-			size_t ItemBagSize;
-			size_t ItemAugSize;
+			uint64 CorpseBitmask;
+			int16 BagSlotCount;
+			int16 AugSocketCount;
 
 			bool AllowEmptyBagInBag;
 			bool AllowClickCastFromBag;
@@ -84,17 +89,15 @@ namespace EQEmu
 
 namespace ClientUnknown
 {
-	enum : int { Invalid = -1, Null, Safety };
-
-	enum : bool { False = false, True = true };
+	const int16 IINVALID = -1;
+	const int16 INULL = 0;
 
 } /*ClientUnknown*/
 
 namespace Client62
 {
-	enum : int { Invalid = -1, Null, Safety };
-
-	enum : bool { False = false, True = true };
+	const int16 IINVALID = -1;
+	const int16 INULL = 0;
 
 } /*Client62*/
 

common/eq_packet.h

@@ -51,6 +51,7 @@ protected:
 	EmuOpcode emu_opcode;
 
 	EQPacket(EmuOpcode opcode, const unsigned char *buf, const uint32 len);
+	EQPacket(EmuOpcode opcode, SerializeBuffer &buf) : BasePacket(buf), emu_opcode(opcode) { };
 //	EQPacket(const EQPacket &p) { }
 	EQPacket() { emu_opcode=OP_Unknown; pBuffer=nullptr; size=0; }
 
@@ -104,6 +105,8 @@ public:
 		{ app_opcode_size = GetExecutablePlatform() == ExePlatformUCS ? 1 : 2; }
 	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; }
+	EQApplicationPacket(const EmuOpcode op, SerializeBuffer &buf) : EQPacket(op, buf), opcode_bypass(0)
+		{ app_opcode_size = GetExecutablePlatform() == ExePlatformUCS ? 1 : 2; }
 	bool combine(const EQApplicationPacket *rhs);
 	uint32 serialize (uint16 opcode, unsigned char *dest) const;
 	uint32 Size() const { return size+app_opcode_size; }

common/eq_packet_structs.h

@@ -731,7 +731,7 @@ struct BandolierItem_Struct
 struct Bandolier_Struct
 {
 	char Name[32];
-	BandolierItem_Struct Items[EQEmu::legacy::BANDOLIER_ITEM_COUNT];
+	BandolierItem_Struct Items[EQEmu::profile::BANDOLIER_ITEM_COUNT];
 };
 
 //len = 72
@@ -745,7 +745,7 @@ struct PotionBeltItem_Struct
 //len = 288
 struct PotionBelt_Struct
 {
-	PotionBeltItem_Struct Items[EQEmu::legacy::POTION_BELT_ITEM_COUNT];
+	PotionBeltItem_Struct Items[EQEmu::profile::POTION_BELT_SIZE];
 };
 
 struct MovePotionToBelt_Struct
@@ -1049,7 +1049,7 @@ struct PlayerProfile_Struct
 /*7212*/	uint32				tribute_points;
 /*7216*/	uint32				unknown7252;
 /*7220*/	uint32				tribute_active;		//1=active
-/*7224*/	Tribute_Struct		tributes[EQEmu::legacy::TRIBUTE_SIZE];
+/*7224*/	Tribute_Struct		tributes[EQEmu::invtype::TRIBUTE_SIZE];
 /*7264*/	Disciplines_Struct	disciplines;
 /*7664*/	uint32				recastTimers[MAX_RECAST_TYPES];	// Timers (GMT of last use)
 /*7744*/	char				unknown7780[160];
@@ -1076,7 +1076,7 @@ struct PlayerProfile_Struct
 /*12800*/	uint32				expAA;
 /*12804*/	uint32				aapoints;			//avaliable, unspent
 /*12808*/	uint8				unknown12844[36];
-/*12844*/	Bandolier_Struct	bandoliers[EQEmu::legacy::BANDOLIERS_SIZE];
+/*12844*/	Bandolier_Struct	bandoliers[EQEmu::profile::BANDOLIERS_SIZE];
 /*14124*/	uint8				unknown14160[4506];
 /*18630*/	SuspendedMinion_Struct	SuspendedMinion; // No longer in use
 /*19240*/	uint32				timeentitledonaccount;
@@ -1783,6 +1783,15 @@ struct CombatAbility_Struct {
 	uint32 m_skill;
 };
 
+// Disarm Struct incoming from Client [Size: 16]
+struct Disarm_Struct
+{
+	uint32 source;
+	uint32 target;
+	uint32 skill;
+	uint32 unknown;
+};
+
 //Instill Doubt
 struct Instill_Doubt_Struct {
 	uint8 i_id;
@@ -3449,8 +3458,8 @@ struct SelectTributeReply_Struct {
 
 struct TributeInfo_Struct {
 	uint32	active;		//0 == inactive, 1 == active
-	uint32	tributes[EQEmu::legacy::TRIBUTE_SIZE];	//-1 == NONE
-	uint32	tiers[EQEmu::legacy::TRIBUTE_SIZE];		//all 00's
+	uint32	tributes[EQEmu::invtype::TRIBUTE_SIZE];	//-1 == NONE
+	uint32	tiers[EQEmu::invtype::TRIBUTE_SIZE];		//all 00's
 	uint32	tribute_master_id;
 };
 
@@ -3782,7 +3791,7 @@ struct AcceptNewTask_Struct {
 //was all 0's from client, server replied with same op, all 0's
 struct CancelTask_Struct {
 	uint32 SequenceNumber;
-	uint32 unknown4; // Only seen 0x00000002
+	uint32 type; // Only seen 0x00000002
 };
 
 #if 0
@@ -3836,28 +3845,28 @@ struct AvailableTaskTrailer_Struct {
 struct TaskDescriptionHeader_Struct {
 	uint32	SequenceNumber; // The order the tasks appear in the journal. 0 for first task, 1 for second, etc.
 	uint32	TaskID;
-	uint32	unknown2;
-	uint32	unknown3;
-	uint8	unknown4;
+	uint8	open_window;
+	uint32	task_type;
+	uint32	reward_type; // if this != 4 says Ebon Crystals else Radiant Crystals
 };
 
 struct TaskDescriptionData1_Struct {
 	uint32	Duration;
-	uint32	unknown2;
+	uint32	dur_code; // if Duration == 0
 	uint32	StartTime;
 };
 
 struct TaskDescriptionData2_Struct {
-	uint32	RewardCount; // ??
-	uint32	unknown1;
-	uint32	unknown2;
-	uint16	unknown3;
-	//uint8	unknown4;
+	uint8 	has_rewards;
+	uint32	coin_reward;
+	uint32	xp_reward;
+	uint32	faction_reward;
 };
 
 struct TaskDescriptionTrailer_Struct {
 	//uint16	unknown1; // 0x0012
 	uint32	Points;
+	uint8	has_reward_selection; // uses newer reward selection window, not in all clients
 };
 
 struct TaskActivityHeader_Struct {
@@ -3897,11 +3906,11 @@ struct TaskActivityShort_Struct {
 
 struct TaskActivityComplete_Struct {
 	uint32	TaskIndex;
-	uint32	unknown2; // 0x00000002
-	uint32	unknown3;
+	uint32	TaskType; // task, shared task, quest
+	uint32	TaskID;		// must match
 	uint32	ActivityID;
-	uint32	unknown4; // 0x00000001
-	uint32	unknown5; // 0x00000001
+	uint32	task_completed; // Broadcasts "Task '%1' Completed" it not 0 and "Task '%1' Failed." if 0
+	uint32	stage_complete; // Broadcasts "Task Stage Completed"
 };
 
 #if 0
@@ -5302,7 +5311,7 @@ struct MercenaryMerchantResponse_Struct {
 struct ServerLootItem_Struct {
 	uint32	item_id;	  // uint32	item_id;
 	int16	equip_slot;	  // int16	equip_slot;
-	uint16	charges;	  // uint8	charges; 
+	uint16	charges;	  // uint8	charges;
 	uint16	lootslot;	  // uint16	lootslot;
 	uint32	aug_1;		  // uint32	aug_1;
 	uint32	aug_2;		  // uint32	aug_2;
@@ -5330,7 +5339,7 @@ struct ClientMarqueeMessage_Struct {
 	uint32 fade_out_time; //The fade out time, in ms
 	uint32 duration; //in ms
 	char msg[1]; //message plus null terminator
-	
+
 };
 
 typedef std::list<ServerLootItem_Struct*> ItemList;

common/eqemu_config.h

@@ -81,10 +81,6 @@ class EQEmuConfig
 		std::string QSDatabaseDB;
 		uint16 QSDatabasePort;
 
-		// From <nats/>
-		std::string NATSHost;
-		uint16 NATSPort;
-
 		// From <files/>
 		std::string SpellsFile;
 		std::string OpCodesFile;

common/eqemu_logsys.cpp

@@ -104,7 +104,6 @@ void EQEmuLogSys::LoadLogSettingsDefaults()
 	log_settings[Logs::MySQLError].log_to_console = Logs::General;
 	log_settings[Logs::Login_Server].log_to_console = Logs::General;
 	log_settings[Logs::Headless_Client].log_to_console = Logs::General;
-	log_settings[Logs::NATS].log_to_console = Logs::General;
 
 	/* Set Category enabled status on defaults */
 	log_settings[Logs::World_Server].is_category_enabled = 1;
@@ -114,7 +113,6 @@ void EQEmuLogSys::LoadLogSettingsDefaults()
 	log_settings[Logs::Crash].is_category_enabled = 1;
 	log_settings[Logs::MySQLError].is_category_enabled = 1;
 	log_settings[Logs::Login_Server].is_category_enabled = 1;
-	log_settings[Logs::NATS].is_category_enabled = 1;
 
 	/*	Declare process file names for log writing
 		If there is no process_file_name declared, no log file will be written, simply

common/eqemu_logsys.h

@@ -90,7 +90,7 @@ enum LogCategory {
 	FixZ,
 	Food,
 	Traps,
-	NATS,
+	NPCRoamBox,
 	MaxCategoryID	/* Don't Remove this*/
 };
 
@@ -146,7 +146,7 @@ static const char* LogCategoryName[LogCategory::MaxCategoryID] = {
 	"FixZ",
 	"Food",
 	"Traps",
-	"NATS"
+	"NPC Roam Box"
 };
 }
 

common/event/background_task.h

@@ -1,32 +1,35 @@
 #pragma once
 #include <functional>
+#include "../any.h"
 #include "event_loop.h"
 
 namespace EQ {
 	class BackgroundTask
 	{
 	public:
-		typedef std::function<void(void)> BackgroundTaskFunction;
+		typedef std::function<void(EQEmu::Any&)> BackgroundTaskFunction;
 		struct BackgroundTaskBaton
 		{
 			BackgroundTaskFunction fn;
 			BackgroundTaskFunction on_finish;
+			EQEmu::Any data;
 		};
 
-		BackgroundTask(BackgroundTaskFunction fn, BackgroundTaskFunction on_finish) {
+		BackgroundTask(BackgroundTaskFunction fn, BackgroundTaskFunction on_finish, EQEmu::Any data) {
 			uv_work_t *m_work = new uv_work_t;
 			memset(m_work, 0, sizeof(uv_work_t));
 			BackgroundTaskBaton *baton = new BackgroundTaskBaton();
 			baton->fn = fn;
 			baton->on_finish = on_finish;
+			baton->data = data;
 		
 			m_work->data = baton;
 			uv_queue_work(EventLoop::Get().Handle(), m_work, [](uv_work_t* req) {
 				BackgroundTaskBaton *baton = (BackgroundTaskBaton*)req->data;
-				baton->fn();
+				baton->fn(baton->data);
 			}, [](uv_work_t* req, int status) {
 				BackgroundTaskBaton *baton = (BackgroundTaskBaton*)req->data;
-				baton->on_finish();
+				baton->on_finish(baton->data);
 				delete baton;
 				delete req;
 			});

common/event_sub.cpp

@@ -1,5 +1,4 @@
 #include "event_sub.h"
-#include <string.h>
 
 void EventSubscriptionWatcher::Subscribe(const std::string &event_name)
 {

common/event_sub.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <unordered_map>
+#include <string>
 
 class EventSubscriptionWatcher
 {

common/features.h

@@ -154,6 +154,7 @@ enum {	//timer settings, all in milliseconds
 	AIscanarea_delay = 6000,
 	AIfeignremember_delay = 500,
 	AItarget_check_duration = 500,
+	AI_scan_door_open_interval = 1000,
 	// AIClientScanarea_delay = 750,	//used in REVERSE_AGGRO
 	AIassistcheck_delay = 3000,		//now often a fighting NPC will yell for help
 	AI_check_signal_timer_delay = 500, // How often EVENT_SIGNAL checks are processed

common/inventory_profile.cpp

@@ -119,6 +119,21 @@ EQEmu::InventoryProfile::~InventoryProfile()
 	m_trade.clear();
 }
 
+bool EQEmu::InventoryProfile::SetInventoryVersion(versions::MobVersion inventory_version) {
+	if (!m_mob_version_set) {
+		m_mob_version = versions::ValidateMobVersion(inventory_version);
+		m_lookup = inventory::Lookup(m_mob_version);
+		m_mob_version_set = true;
+		return true;
+	}
+	else {
+		m_lookup = inventory::Lookup(versions::MobVersion::Unknown);
+		Log(Logs::General, Logs::Error, "InventoryVersion set request after initial set (old: %u, new: %u)",
+			static_cast<uint32>(m_mob_version), static_cast<uint32>(inventory_version));
+		return false;
+	}
+}
+
 void EQEmu::InventoryProfile::CleanDirty() {
 	auto iter = dirty_inst.begin();
 	while (iter != dirty_inst.end()) {
@@ -140,63 +155,63 @@ EQEmu::ItemInstance* EQEmu::InventoryProfile::GetItem(int16 slot_id) const
 	ItemInstance* result = nullptr;
 
 	// Cursor
-	if (slot_id == inventory::slotCursor) {
+	if (slot_id == invslot::slotCursor) {
 		// Cursor slot
 		result = m_cursor.peek_front();
 	}
 
 	// Non bag slots
-	else if (slot_id >= legacy::TRADE_BEGIN && slot_id <= legacy::TRADE_END) {
+	else if (slot_id >= invslot::TRADE_BEGIN && slot_id <= invslot::TRADE_END) {
 		result = _GetItem(m_trade, slot_id);
 	}
-	else if (slot_id >= legacy::SHARED_BANK_BEGIN && slot_id <= legacy::SHARED_BANK_END) {
+	else if (slot_id >= invslot::SHARED_BANK_BEGIN && slot_id <= invslot::SHARED_BANK_END) {
 		// Shared Bank slots
 		result = _GetItem(m_shbank, slot_id);
 	}
-	else if (slot_id >= legacy::BANK_BEGIN && slot_id <= legacy::BANK_END) {
+	else if (slot_id >= invslot::BANK_BEGIN && slot_id <= invslot::BANK_END) {
 		// Bank slots
 		result = _GetItem(m_bank, slot_id);
 	}
-	else if ((slot_id >= legacy::GENERAL_BEGIN && slot_id <= legacy::GENERAL_END)) {
+	else if ((slot_id >= invslot::GENERAL_BEGIN && slot_id <= invslot::GENERAL_END)) {
 		// Personal inventory slots
 		result = _GetItem(m_inv, slot_id);
 	}
-	else if ((slot_id >= legacy::EQUIPMENT_BEGIN && slot_id <= legacy::EQUIPMENT_END) ||
-		(slot_id >= legacy::TRIBUTE_BEGIN && slot_id <= legacy::TRIBUTE_END) || (slot_id == inventory::slotPowerSource)) {
+	else if ((slot_id >= invslot::EQUIPMENT_BEGIN && slot_id <= invslot::EQUIPMENT_END) ||
+		(slot_id >= invslot::TRIBUTE_BEGIN && slot_id <= invslot::TRIBUTE_END) || (slot_id == invslot::SLOT_POWER_SOURCE)) {
 		// Equippable slots (on body)
 		result = _GetItem(m_worn, slot_id);
 	}
 
 	// Inner bag slots
-	else if (slot_id >= legacy::TRADE_BAGS_BEGIN && slot_id <= legacy::TRADE_BAGS_END) {
+	else if (slot_id >= invbag::TRADE_BAGS_BEGIN && slot_id <= invbag::TRADE_BAGS_END) {
 		// Trade bag slots
 		ItemInstance* inst = _GetItem(m_trade, InventoryProfile::CalcSlotId(slot_id));
 		if (inst && inst->IsClassBag()) {
 			result = inst->GetItem(InventoryProfile::CalcBagIdx(slot_id));
 		}
 	}
-	else if (slot_id >= legacy::SHARED_BANK_BAGS_BEGIN && slot_id <= legacy::SHARED_BANK_BAGS_END) {
+	else if (slot_id >= invbag::SHARED_BANK_BAGS_BEGIN && slot_id <= invbag::SHARED_BANK_BAGS_END) {
 		// Shared Bank bag slots
 		ItemInstance* inst = _GetItem(m_shbank, InventoryProfile::CalcSlotId(slot_id));
 		if (inst && inst->IsClassBag()) {
 			result = inst->GetItem(InventoryProfile::CalcBagIdx(slot_id));
 		}
 	}
-	else if (slot_id >= legacy::BANK_BAGS_BEGIN && slot_id <= legacy::BANK_BAGS_END) {
+	else if (slot_id >= invbag::BANK_BAGS_BEGIN && slot_id <= invbag::BANK_BAGS_END) {
 		// Bank bag slots
 		ItemInstance* inst = _GetItem(m_bank, InventoryProfile::CalcSlotId(slot_id));
 		if (inst && inst->IsClassBag()) {
 			result = inst->GetItem(InventoryProfile::CalcBagIdx(slot_id));
 		}
 	}
-	else if (slot_id >= legacy::CURSOR_BAG_BEGIN && slot_id <= legacy::CURSOR_BAG_END) {
+	else if (slot_id >= invbag::CURSOR_BAG_BEGIN && slot_id <= invbag::CURSOR_BAG_END) {
 		// Cursor bag slots
 		ItemInstance* inst = m_cursor.peek_front();
 		if (inst && inst->IsClassBag()) {
 			result = inst->GetItem(InventoryProfile::CalcBagIdx(slot_id));
 		}
 	}
-	else if (slot_id >= legacy::GENERAL_BAGS_BEGIN && slot_id <= legacy::GENERAL_BAGS_END) {
+	else if (slot_id >= invbag::GENERAL_BAGS_BEGIN && slot_id <= invbag::GENERAL_BAGS_END) {
 		// Personal inventory bag slots
 		ItemInstance* inst = _GetItem(m_inv, InventoryProfile::CalcSlotId(slot_id));
 		if (inst && inst->IsClassBag()) {
@@ -232,7 +247,7 @@ int16 EQEmu::InventoryProfile::PutItem(int16 slot_id, const ItemInstance& inst)
 int16 EQEmu::InventoryProfile::PushCursor(const ItemInstance& inst)
 {
 	m_cursor.push(inst.Clone());
-	return inventory::slotCursor;
+	return invslot::slotCursor;
 }
 
 EQEmu::ItemInstance* EQEmu::InventoryProfile::GetCursorItem()
@@ -254,7 +269,7 @@ bool EQEmu::InventoryProfile::SwapItem(int16 slot_a, int16 slot_b, SwapItemFailS
 			fail_state = swapNotAllowed;
 			return false;
 		}
-		if ((slot_b >= legacy::EQUIPMENT_BEGIN && slot_b <= legacy::EQUIPMENT_END) || slot_b == inventory::slotPowerSource) {
+		if ((slot_b >= invslot::EQUIPMENT_BEGIN && slot_b <= invslot::EQUIPMENT_END) || slot_b == invslot::SLOT_POWER_SOURCE) {
 			auto item_a = inst_a->GetItem();
 			if (!item_a) {
 				fail_state = swapNullData;
@@ -280,7 +295,7 @@ bool EQEmu::InventoryProfile::SwapItem(int16 slot_a, int16 slot_b, SwapItemFailS
 			fail_state = swapNotAllowed;
 			return false;
 		}
-		if ((slot_a >= legacy::EQUIPMENT_BEGIN && slot_a <= legacy::EQUIPMENT_END) || slot_a == inventory::slotPowerSource) {
+		if ((slot_a >= invslot::EQUIPMENT_BEGIN && slot_a <= invslot::EQUIPMENT_END) || slot_a == invslot::SLOT_POWER_SOURCE) {
 			auto item_b = inst_b->GetItem();
 			if (!item_b) {
 				fail_state = swapNullData;
@@ -361,30 +376,30 @@ EQEmu::ItemInstance* EQEmu::InventoryProfile::PopItem(int16 slot_id)
 {
 	ItemInstance* p = nullptr;
 
-	if (slot_id == inventory::slotCursor) {
+	if (slot_id == invslot::slotCursor) {
 		p = m_cursor.pop();
 	}
-	else if ((slot_id >= legacy::EQUIPMENT_BEGIN && slot_id <= legacy::EQUIPMENT_END) || (slot_id == inventory::slotPowerSource)) {
+	else if ((slot_id >= invslot::EQUIPMENT_BEGIN && slot_id <= invslot::EQUIPMENT_END) || (slot_id == invslot::SLOT_POWER_SOURCE)) {
 		p = m_worn[slot_id];
 		m_worn.erase(slot_id);
 	}
-	else if ((slot_id >= legacy::GENERAL_BEGIN && slot_id <= legacy::GENERAL_END)) {
+	else if ((slot_id >= invslot::GENERAL_BEGIN && slot_id <= invslot::GENERAL_END)) {
 		p = m_inv[slot_id];
 		m_inv.erase(slot_id);
 	}
-	else if (slot_id >= legacy::TRIBUTE_BEGIN && slot_id <= legacy::TRIBUTE_END) {
+	else if (slot_id >= invslot::TRIBUTE_BEGIN && slot_id <= invslot::TRIBUTE_END) {
 		p = m_worn[slot_id];
 		m_worn.erase(slot_id);
 	}
-	else if (slot_id >= legacy::BANK_BEGIN && slot_id <= legacy::BANK_END) {
+	else if (slot_id >= invslot::BANK_BEGIN && slot_id <= invslot::BANK_END) {
 		p = m_bank[slot_id];
 		m_bank.erase(slot_id);
 	}
-	else if (slot_id >= legacy::SHARED_BANK_BEGIN && slot_id <= legacy::SHARED_BANK_END) {
+	else if (slot_id >= invslot::SHARED_BANK_BEGIN && slot_id <= invslot::SHARED_BANK_END) {
 		p = m_shbank[slot_id];
 		m_shbank.erase(slot_id);
 	}
-	else if (slot_id >= legacy::TRADE_BEGIN && slot_id <= legacy::TRADE_END) {
+	else if (slot_id >= invslot::TRADE_BEGIN && slot_id <= invslot::TRADE_END) {
 		p = m_trade[slot_id];
 		m_trade.erase(slot_id);
 	}
@@ -404,7 +419,7 @@ bool EQEmu::InventoryProfile::HasSpaceForItem(const ItemData *ItemToTry, int16 Q
 
 	if (ItemToTry->Stackable) {
 
-		for (int16 i = legacy::GENERAL_BEGIN; i <= legacy::GENERAL_END; i++) {
+		for (int16 i = invslot::GENERAL_BEGIN; i <= invslot::GENERAL_END; i++) {
 
 			ItemInstance* InvItem = GetItem(i);
 
@@ -420,9 +435,9 @@ bool EQEmu::InventoryProfile::HasSpaceForItem(const ItemData *ItemToTry, int16 Q
 			}
 			if (InvItem && InvItem->IsClassBag()) {
 
-				int16 BaseSlotID = InventoryProfile::CalcSlotId(i, inventory::containerBegin);
+				int16 BaseSlotID = InventoryProfile::CalcSlotId(i, invbag::SLOT_BEGIN);
 				uint8 BagSize = InvItem->GetItem()->BagSlots;
-				for (uint8 BagSlot = inventory::containerBegin; BagSlot < BagSize; BagSlot++) {
+				for (uint8 BagSlot = invbag::SLOT_BEGIN; BagSlot < BagSize; BagSlot++) {
 
 					InvItem = GetItem(BaseSlotID + BagSlot);
 
@@ -441,7 +456,7 @@ bool EQEmu::InventoryProfile::HasSpaceForItem(const ItemData *ItemToTry, int16 Q
 		}
 	}
 
-	for (int16 i = legacy::GENERAL_BEGIN; i <= legacy::GENERAL_END; i++) {
+	for (int16 i = invslot::GENERAL_BEGIN; i <= invslot::GENERAL_END; i++) {
 
 		ItemInstance* InvItem = GetItem(i);
 
@@ -464,11 +479,11 @@ bool EQEmu::InventoryProfile::HasSpaceForItem(const ItemData *ItemToTry, int16 Q
 		}
 		else if (InvItem->IsClassBag() && CanItemFitInContainer(ItemToTry, InvItem->GetItem())) {
 
-			int16 BaseSlotID = InventoryProfile::CalcSlotId(i, inventory::containerBegin);
+			int16 BaseSlotID = InventoryProfile::CalcSlotId(i, invbag::SLOT_BEGIN);
 
 			uint8 BagSize = InvItem->GetItem()->BagSlots;
 
-			for (uint8 BagSlot = inventory::containerBegin; BagSlot<BagSize; BagSlot++) {
+			for (uint8 BagSlot = invbag::SLOT_BEGIN; BagSlot<BagSize; BagSlot++) {
 
 				InvItem = GetItem(BaseSlotID + BagSlot);
 
@@ -647,14 +662,14 @@ int16 EQEmu::InventoryProfile::HasItemByLoreGroup(uint32 loregroup, uint8 where)
 int16 EQEmu::InventoryProfile::FindFreeSlot(bool for_bag, bool try_cursor, uint8 min_size, bool is_arrow)
 {
 	// Check basic inventory
-	for (int16 i = legacy::GENERAL_BEGIN; i <= legacy::GENERAL_END; i++) {
+	for (int16 i = invslot::GENERAL_BEGIN; i <= invslot::GENERAL_END; i++) {
 		if (!GetItem(i))
 			// Found available slot in personal inventory
 			return i;
 	}
 
 	if (!for_bag) {
-		for (int16 i = legacy::GENERAL_BEGIN; i <= legacy::GENERAL_END; i++) {
+		for (int16 i = invslot::GENERAL_BEGIN; i <= invslot::GENERAL_END; i++) {
 			const ItemInstance* inst = GetItem(i);
 			if (inst && inst->IsClassBag() && inst->GetItem()->BagSize >= min_size)
 			{
@@ -663,11 +678,11 @@ int16 EQEmu::InventoryProfile::FindFreeSlot(bool for_bag, bool try_cursor, uint8
 					continue;
 				}
 
-				int16 base_slot_id = InventoryProfile::CalcSlotId(i, inventory::containerBegin);
+				int16 base_slot_id = InventoryProfile::CalcSlotId(i, invbag::SLOT_BEGIN);
 
 				uint8 slots = inst->GetItem()->BagSlots;
 				uint8 j;
-				for (j = inventory::containerBegin; j<slots; j++) {
+				for (j = invbag::SLOT_BEGIN; j<slots; j++) {
 					if (!GetItem(base_slot_id + j)) {
 						// Found available slot within bag
 						return (base_slot_id + j);
@@ -680,7 +695,7 @@ int16 EQEmu::InventoryProfile::FindFreeSlot(bool for_bag, bool try_cursor, uint8
 	if (try_cursor) {
 		// Always room on cursor (it's a queue)
 		// (we may wish to cap this in the future)
-		return inventory::slotCursor;
+		return invslot::slotCursor;
 	}
 
 	// No available slots
@@ -694,9 +709,9 @@ int16 EQEmu::InventoryProfile::FindFreeSlotForTradeItem(const ItemInstance* inst
 	//
 	// I'll probably implement a bitmask in the new inventory system to avoid having to adjust stack bias
 
-	if ((general_start < legacy::GENERAL_BEGIN) || (general_start > legacy::GENERAL_END))
+	if ((general_start < invslot::GENERAL_BEGIN) || (general_start > invslot::GENERAL_END))
 		return INVALID_INDEX;
-	if (bag_start >= inventory::ContainerCount)
+	if (bag_start > invbag::SLOT_END)
 		return INVALID_INDEX;
 
 	if (!inst || !inst->GetID())
@@ -704,17 +719,17 @@ int16 EQEmu::InventoryProfile::FindFreeSlotForTradeItem(const ItemInstance* inst
 
 	// step 1: find room for bags (caller should really ask for slots for bags first to avoid sending them to cursor..and bag item loss)
 	if (inst->IsClassBag()) {
-		for (int16 free_slot = general_start; free_slot <= legacy::GENERAL_END; ++free_slot) {
+		for (int16 free_slot = general_start; free_slot <= invslot::GENERAL_END; ++free_slot) {
 			if (!m_inv[free_slot])
 				return free_slot;
 		}
 
-		return inventory::slotCursor; // return cursor since bags do not stack and will not fit inside other bags..yet...)
+		return invslot::slotCursor; // return cursor since bags do not stack and will not fit inside other bags..yet...)
 	}
 
 	// step 2: find partial room for stackables
 	if (inst->IsStackable()) {
-		for (int16 free_slot = general_start; free_slot <= legacy::GENERAL_END; ++free_slot) {
+		for (int16 free_slot = general_start; free_slot <= invslot::GENERAL_END; ++free_slot) {
 			const ItemInstance* main_inst = m_inv[free_slot];
 
 			if (!main_inst)
@@ -724,15 +739,15 @@ int16 EQEmu::InventoryProfile::FindFreeSlotForTradeItem(const ItemInstance* inst
 				return free_slot;
 		}
 
-		for (int16 free_slot = general_start; free_slot <= legacy::GENERAL_END; ++free_slot) {
+		for (int16 free_slot = general_start; free_slot <= invslot::GENERAL_END; ++free_slot) {
 			const ItemInstance* main_inst = m_inv[free_slot];
 
 			if (!main_inst)
 				continue;
 
 			if (main_inst->IsClassBag()) { // if item-specific containers already have bad items, we won't fix it here...
-				uint8 _bag_start = (free_slot > general_start) ? inventory::containerBegin : bag_start;
-				for (uint8 free_bag_slot = _bag_start; (free_bag_slot < main_inst->GetItem()->BagSlots) && (free_bag_slot < inventory::ContainerCount); ++free_bag_slot) {
+				uint8 _bag_start = (free_slot > general_start) ? invbag::SLOT_BEGIN : bag_start;
+				for (uint8 free_bag_slot = _bag_start; (free_bag_slot < main_inst->GetItem()->BagSlots) && (free_bag_slot <= invbag::SLOT_END); ++free_bag_slot) {
 					const ItemInstance* sub_inst = main_inst->GetItem(free_bag_slot);
 
 					if (!sub_inst)
@@ -747,14 +762,14 @@ int16 EQEmu::InventoryProfile::FindFreeSlotForTradeItem(const ItemInstance* inst
 
 	// step 3a: find room for container-specific items (ItemClassArrow)
 	if (inst->GetItem()->ItemType == item::ItemTypeArrow) {
-		for (int16 free_slot = general_start; free_slot <= legacy::GENERAL_END; ++free_slot) {
+		for (int16 free_slot = general_start; free_slot <= invslot::GENERAL_END; ++free_slot) {
 			const ItemInstance* main_inst = m_inv[free_slot];
 
 			if (!main_inst || (main_inst->GetItem()->BagType != item::BagTypeQuiver) || !main_inst->IsClassBag())
 				continue;
 
-			uint8 _bag_start = (free_slot > general_start) ? inventory::containerBegin : bag_start;
-			for (uint8 free_bag_slot = _bag_start; (free_bag_slot < main_inst->GetItem()->BagSlots) && (free_bag_slot < inventory::ContainerCount); ++free_bag_slot) {
+			uint8 _bag_start = (free_slot > general_start) ? invbag::SLOT_BEGIN : bag_start;
+			for (uint8 free_bag_slot = _bag_start; (free_bag_slot < main_inst->GetItem()->BagSlots) && (free_bag_slot <= invbag::SLOT_END); ++free_bag_slot) {
 				if (!main_inst->GetItem(free_bag_slot))
 					return InventoryProfile::CalcSlotId(free_slot, free_bag_slot);
 			}
@@ -763,14 +778,14 @@ int16 EQEmu::InventoryProfile::FindFreeSlotForTradeItem(const ItemInstance* inst
 
 	// step 3b: find room for container-specific items (ItemClassSmallThrowing)
 	if (inst->GetItem()->ItemType == item::ItemTypeSmallThrowing) {
-		for (int16 free_slot = general_start; free_slot <= legacy::GENERAL_END; ++free_slot) {
+		for (int16 free_slot = general_start; free_slot <= invslot::GENERAL_END; ++free_slot) {
 			const ItemInstance* main_inst = m_inv[free_slot];
 
 			if (!main_inst || (main_inst->GetItem()->BagType != item::BagTypeBandolier) || !main_inst->IsClassBag())
 				continue;
 
-			uint8 _bag_start = (free_slot > general_start) ? inventory::containerBegin : bag_start;
-			for (uint8 free_bag_slot = _bag_start; (free_bag_slot < main_inst->GetItem()->BagSlots) && (free_bag_slot < inventory::ContainerCount); ++free_bag_slot) {
+			uint8 _bag_start = (free_slot > general_start) ? invbag::SLOT_BEGIN : bag_start;
+			for (uint8 free_bag_slot = _bag_start; (free_bag_slot < main_inst->GetItem()->BagSlots) && (free_bag_slot <= invbag::SLOT_END); ++free_bag_slot) {
 				if (!main_inst->GetItem(free_bag_slot))
 					return InventoryProfile::CalcSlotId(free_slot, free_bag_slot);
 			}
@@ -778,22 +793,22 @@ int16 EQEmu::InventoryProfile::FindFreeSlotForTradeItem(const ItemInstance* inst
 	}
 
 	// step 4: just find an empty slot
-	for (int16 free_slot = general_start; free_slot <= legacy::GENERAL_END; ++free_slot) {
+	for (int16 free_slot = general_start; free_slot <= invslot::GENERAL_END; ++free_slot) {
 		const ItemInstance* main_inst = m_inv[free_slot];
 
 		if (!main_inst)
 			return free_slot;
 	}
 
-	for (int16 free_slot = general_start; free_slot <= legacy::GENERAL_END; ++free_slot) {
+	for (int16 free_slot = general_start; free_slot <= invslot::GENERAL_END; ++free_slot) {
 		const ItemInstance* main_inst = m_inv[free_slot];
 
 		if (main_inst && main_inst->IsClassBag()) {
 			if ((main_inst->GetItem()->BagSize < inst->GetItem()->Size) || (main_inst->GetItem()->BagType == item::BagTypeBandolier) || (main_inst->GetItem()->BagType == item::BagTypeQuiver))
 				continue;
 
-			uint8 _bag_start = (free_slot > general_start) ? inventory::containerBegin : bag_start;
-			for (uint8 free_bag_slot = _bag_start; (free_bag_slot < main_inst->GetItem()->BagSlots) && (free_bag_slot < inventory::ContainerCount); ++free_bag_slot) {
+			uint8 _bag_start = (free_slot > general_start) ? invbag::SLOT_BEGIN : bag_start;
+			for (uint8 free_bag_slot = _bag_start; (free_bag_slot < main_inst->GetItem()->BagSlots) && (free_bag_slot <= invbag::SLOT_END); ++free_bag_slot) {
 				if (!main_inst->GetItem(free_bag_slot))
 					return InventoryProfile::CalcSlotId(free_slot, free_bag_slot);
 			}
@@ -801,7 +816,7 @@ int16 EQEmu::InventoryProfile::FindFreeSlotForTradeItem(const ItemInstance* inst
 	}
 
 	//return INVALID_INDEX; // everything else pushes to the cursor
-	return inventory::slotCursor;
+	return invslot::slotCursor;
 }
 
 // Opposite of below: Get parent bag slot_id from a slot inside of bag
@@ -813,20 +828,20 @@ int16 EQEmu::InventoryProfile::CalcSlotId(int16 slot_id) {
 	//	parent_slot_id = EmuConstants::BANK_BEGIN + (slot_id - EmuConstants::BANK_BEGIN) / EmuConstants::ITEM_CONTAINER_SIZE;
 	//else if (slot_id >= 3100 && slot_id <= 3179) should be {3031..3110}..where did this range come from!!? (verified db save range)
 	
-	if (slot_id >= legacy::GENERAL_BAGS_BEGIN && slot_id <= legacy::GENERAL_BAGS_END) {
-		parent_slot_id = legacy::GENERAL_BEGIN + (slot_id - legacy::GENERAL_BAGS_BEGIN) / inventory::ContainerCount;
+	if (slot_id >= invbag::GENERAL_BAGS_BEGIN && slot_id <= invbag::GENERAL_BAGS_END) {
+		parent_slot_id = invslot::GENERAL_BEGIN + (slot_id - invbag::GENERAL_BAGS_BEGIN) / invbag::SLOT_COUNT;
 	}
-	else if (slot_id >= legacy::CURSOR_BAG_BEGIN && slot_id <= legacy::CURSOR_BAG_END) {
-		parent_slot_id = inventory::slotCursor;
+	else if (slot_id >= invbag::CURSOR_BAG_BEGIN && slot_id <= invbag::CURSOR_BAG_END) {
+		parent_slot_id = invslot::slotCursor;
 	}
-	else if (slot_id >= legacy::BANK_BAGS_BEGIN && slot_id <= legacy::BANK_BAGS_END) {
-		parent_slot_id = legacy::BANK_BEGIN + (slot_id - legacy::BANK_BAGS_BEGIN) / inventory::ContainerCount;
+	else if (slot_id >= invbag::BANK_BAGS_BEGIN && slot_id <= invbag::BANK_BAGS_END) {
+		parent_slot_id = invslot::BANK_BEGIN + (slot_id - invbag::BANK_BAGS_BEGIN) / invbag::SLOT_COUNT;
 	}
-	else if (slot_id >= legacy::SHARED_BANK_BAGS_BEGIN && slot_id <= legacy::SHARED_BANK_BAGS_END) {
-		parent_slot_id = legacy::SHARED_BANK_BEGIN + (slot_id - legacy::SHARED_BANK_BAGS_BEGIN) / inventory::ContainerCount;
+	else if (slot_id >= invbag::SHARED_BANK_BAGS_BEGIN && slot_id <= invbag::SHARED_BANK_BAGS_END) {
+		parent_slot_id = invslot::SHARED_BANK_BEGIN + (slot_id - invbag::SHARED_BANK_BAGS_BEGIN) / invbag::SLOT_COUNT;
 	}
-	else if (slot_id >= legacy::TRADE_BAGS_BEGIN && slot_id <= legacy::TRADE_BAGS_END) {
-		parent_slot_id = legacy::TRADE_BEGIN + (slot_id - legacy::TRADE_BAGS_BEGIN) / inventory::ContainerCount;
+	else if (slot_id >= invbag::TRADE_BAGS_BEGIN && slot_id <= invbag::TRADE_BAGS_END) {
+		parent_slot_id = invslot::TRADE_BEGIN + (slot_id - invbag::TRADE_BAGS_BEGIN) / invbag::SLOT_COUNT;
 	}
 
 	return parent_slot_id;
@@ -839,20 +854,20 @@ int16 EQEmu::InventoryProfile::CalcSlotId(int16 bagslot_id, uint8 bagidx) {
 
 	int16 slot_id = INVALID_INDEX;
 
-	if (bagslot_id == inventory::slotCursor || bagslot_id == 8000) {
-		slot_id = legacy::CURSOR_BAG_BEGIN + bagidx;
+	if (bagslot_id == invslot::slotCursor || bagslot_id == 8000) {
+		slot_id = invbag::CURSOR_BAG_BEGIN + bagidx;
 	}
-	else if (bagslot_id >= legacy::GENERAL_BEGIN && bagslot_id <= legacy::GENERAL_END) {
-		slot_id = legacy::GENERAL_BAGS_BEGIN + (bagslot_id - legacy::GENERAL_BEGIN) * inventory::ContainerCount + bagidx;
+	else if (bagslot_id >= invslot::GENERAL_BEGIN && bagslot_id <= invslot::GENERAL_END) {
+		slot_id = invbag::GENERAL_BAGS_BEGIN + (bagslot_id - invslot::GENERAL_BEGIN) * invbag::SLOT_COUNT + bagidx;
 	}
-	else if (bagslot_id >= legacy::BANK_BEGIN && bagslot_id <= legacy::BANK_END) {
-		slot_id = legacy::BANK_BAGS_BEGIN + (bagslot_id - legacy::BANK_BEGIN) * inventory::ContainerCount + bagidx;
+	else if (bagslot_id >= invslot::BANK_BEGIN && bagslot_id <= invslot::BANK_END) {
+		slot_id = invbag::BANK_BAGS_BEGIN + (bagslot_id - invslot::BANK_BEGIN) * invbag::SLOT_COUNT + bagidx;
 	}
-	else if (bagslot_id >= legacy::SHARED_BANK_BEGIN && bagslot_id <= legacy::SHARED_BANK_END) {
-		slot_id = legacy::SHARED_BANK_BAGS_BEGIN + (bagslot_id - legacy::SHARED_BANK_BEGIN) * inventory::ContainerCount + bagidx;
+	else if (bagslot_id >= invslot::SHARED_BANK_BEGIN && bagslot_id <= invslot::SHARED_BANK_END) {
+		slot_id = invbag::SHARED_BANK_BAGS_BEGIN + (bagslot_id - invslot::SHARED_BANK_BEGIN) * invbag::SLOT_COUNT + bagidx;
 	}
-	else if (bagslot_id >= legacy::TRADE_BEGIN && bagslot_id <= legacy::TRADE_END) {
-		slot_id = legacy::TRADE_BAGS_BEGIN + (bagslot_id - legacy::TRADE_BEGIN) * inventory::ContainerCount + bagidx;
+	else if (bagslot_id >= invslot::TRADE_BEGIN && bagslot_id <= invslot::TRADE_END) {
+		slot_id = invbag::TRADE_BAGS_BEGIN + (bagslot_id - invslot::TRADE_BEGIN) * invbag::SLOT_COUNT + bagidx;
 	}
 
 	return slot_id;
@@ -865,23 +880,23 @@ uint8 EQEmu::InventoryProfile::CalcBagIdx(int16 slot_id) {
 	//else if (slot_id >= EmuConstants::BANK_BEGIN && slot_id <= EmuConstants::BANK_END)
 	//	index = (slot_id - EmuConstants::BANK_BEGIN) % EmuConstants::ITEM_CONTAINER_SIZE;
 
-	if (slot_id >= legacy::GENERAL_BAGS_BEGIN && slot_id <= legacy::GENERAL_BAGS_END) {
-		index = (slot_id - legacy::GENERAL_BAGS_BEGIN) % inventory::ContainerCount;
+	if (slot_id >= invbag::GENERAL_BAGS_BEGIN && slot_id <= invbag::GENERAL_BAGS_END) {
+		index = (slot_id - invbag::GENERAL_BAGS_BEGIN) % invbag::SLOT_COUNT;
 	}
-	else if (slot_id >= legacy::CURSOR_BAG_BEGIN && slot_id <= legacy::CURSOR_BAG_END) {
-		index = (slot_id - legacy::CURSOR_BAG_BEGIN); // % inventory::ContainerCount; - not needed since range is 10 slots
+	else if (slot_id >= invbag::CURSOR_BAG_BEGIN && slot_id <= invbag::CURSOR_BAG_END) {
+		index = (slot_id - invbag::CURSOR_BAG_BEGIN); // % invbag::SLOT_COUNT; - not needed since range is 10 slots
 	}
-	else if (slot_id >= legacy::BANK_BAGS_BEGIN && slot_id <= legacy::BANK_BAGS_END) {
-		index = (slot_id - legacy::BANK_BAGS_BEGIN) % inventory::ContainerCount;
+	else if (slot_id >= invbag::BANK_BAGS_BEGIN && slot_id <= invbag::BANK_BAGS_END) {
+		index = (slot_id - invbag::BANK_BAGS_BEGIN) % invbag::SLOT_COUNT;
 	}
-	else if (slot_id >= legacy::SHARED_BANK_BAGS_BEGIN && slot_id <= legacy::SHARED_BANK_BAGS_END) {
-		index = (slot_id - legacy::SHARED_BANK_BAGS_BEGIN) % inventory::ContainerCount;
+	else if (slot_id >= invbag::SHARED_BANK_BAGS_BEGIN && slot_id <= invbag::SHARED_BANK_BAGS_END) {
+		index = (slot_id - invbag::SHARED_BANK_BAGS_BEGIN) % invbag::SLOT_COUNT;
 	}
-	else if (slot_id >= legacy::TRADE_BAGS_BEGIN && slot_id <= legacy::TRADE_BAGS_END) {
-		index = (slot_id - legacy::TRADE_BAGS_BEGIN) % inventory::ContainerCount;
+	else if (slot_id >= invbag::TRADE_BAGS_BEGIN && slot_id <= invbag::TRADE_BAGS_END) {
+		index = (slot_id - invbag::TRADE_BAGS_BEGIN) % invbag::SLOT_COUNT;
 	}
-	else if (slot_id >= legacy::WORLD_BEGIN && slot_id <= legacy::WORLD_END) {
-		index = (slot_id - legacy::WORLD_BEGIN); // % inventory::ContainerCount; - not needed since range is 10 slots
+	else if (slot_id >= invslot::WORLD_BEGIN && slot_id <= invslot::WORLD_END) {
+		index = (slot_id - invslot::WORLD_BEGIN); // % invbag::SLOT_COUNT; - not needed since range is 10 slots
 	}
 
 	return index;
@@ -892,23 +907,23 @@ int16 EQEmu::InventoryProfile::CalcSlotFromMaterial(uint8 material)
 	switch (material)
 	{
 	case textures::armorHead:
-		return inventory::slotHead;
+		return invslot::slotHead;
 	case textures::armorChest:
-		return inventory::slotChest;
+		return invslot::slotChest;
 	case textures::armorArms:
-		return inventory::slotArms;
+		return invslot::slotArms;
 	case textures::armorWrist:
-		return inventory::slotWrist1;	// there's 2 bracers, only one bracer material
+		return invslot::slotWrist1;	// there's 2 bracers, only one bracer material
 	case textures::armorHands:
-		return inventory::slotHands;
+		return invslot::slotHands;
 	case textures::armorLegs:
-		return inventory::slotLegs;
+		return invslot::slotLegs;
 	case textures::armorFeet:
-		return inventory::slotFeet;
+		return invslot::slotFeet;
 	case textures::weaponPrimary:
-		return inventory::slotPrimary;
+		return invslot::slotPrimary;
 	case textures::weaponSecondary:
-		return inventory::slotSecondary;
+		return invslot::slotSecondary;
 	default:
 		return INVALID_INDEX;
 	}
@@ -918,24 +933,24 @@ uint8 EQEmu::InventoryProfile::CalcMaterialFromSlot(int16 equipslot)
 {
 	switch (equipslot)
 	{
-	case inventory::slotHead:
+	case invslot::slotHead:
 		return textures::armorHead;
-	case inventory::slotChest:
+	case invslot::slotChest:
 		return textures::armorChest;
-	case inventory::slotArms:
+	case invslot::slotArms:
 		return textures::armorArms;
-	case inventory::slotWrist1:
+	case invslot::slotWrist1:
 	//case SLOT_BRACER02: // non-live behavior
 		return textures::armorWrist;
-	case inventory::slotHands:
+	case invslot::slotHands:
 		return textures::armorHands;
-	case inventory::slotLegs:
+	case invslot::slotLegs:
 		return textures::armorLegs;
-	case inventory::slotFeet:
+	case invslot::slotFeet:
 		return textures::armorFeet;
-	case inventory::slotPrimary:
+	case invslot::slotPrimary:
 		return textures::weaponPrimary;
-	case inventory::slotSecondary:
+	case invslot::slotSecondary:
 		return textures::weaponSecondary;
 	default:
 		return textures::materialInvalid;
@@ -962,11 +977,11 @@ bool EQEmu::InventoryProfile::CanItemFitInContainer(const ItemData *ItemToTry, c
 bool EQEmu::InventoryProfile::SupportsClickCasting(int16 slot_id)
 {
 	// there are a few non-potion items that identify as ItemTypePotion..so, we still need to ubiquitously include the equipment range
-	if ((uint16)slot_id <= legacy::GENERAL_END || slot_id == inventory::slotPowerSource)
+	if ((uint16)slot_id <= invslot::GENERAL_END || slot_id == invslot::SLOT_POWER_SOURCE)
 	{
 		return true;
 	}
-	else if (slot_id >= legacy::GENERAL_BAGS_BEGIN && slot_id <= legacy::GENERAL_BAGS_END)
+	else if (slot_id >= invbag::GENERAL_BAGS_BEGIN && slot_id <= invbag::GENERAL_BAGS_END)
 	{
 		if (inventory::Lookup(m_mob_version)->AllowClickCastFromBag)
 			return true;
@@ -977,7 +992,7 @@ bool EQEmu::InventoryProfile::SupportsClickCasting(int16 slot_id)
 
 bool EQEmu::InventoryProfile::SupportsPotionBeltCasting(int16 slot_id)
 {
-	if ((uint16)slot_id <= legacy::GENERAL_END || slot_id == inventory::slotPowerSource || (slot_id >= legacy::GENERAL_BAGS_BEGIN && slot_id <= legacy::GENERAL_BAGS_END))
+	if ((uint16)slot_id <= invslot::GENERAL_END || slot_id == invslot::SLOT_POWER_SOURCE || (slot_id >= invbag::GENERAL_BAGS_BEGIN && slot_id <= invbag::GENERAL_BAGS_END))
 		return true;
 
 	return false;
@@ -986,11 +1001,11 @@ bool EQEmu::InventoryProfile::SupportsPotionBeltCasting(int16 slot_id)
 // Test whether a given slot can support a container item
 bool EQEmu::InventoryProfile::SupportsContainers(int16 slot_id)
 {
-	if ((slot_id == inventory::slotCursor) ||
-		(slot_id >= legacy::GENERAL_BEGIN && slot_id <= legacy::GENERAL_END) ||
-		(slot_id >= legacy::BANK_BEGIN && slot_id <= legacy::BANK_END) ||
-		(slot_id >= legacy::SHARED_BANK_BEGIN && slot_id <= legacy::SHARED_BANK_END) ||
-		(slot_id >= legacy::TRADE_BEGIN && slot_id <= legacy::TRADE_END)
+	if ((slot_id == invslot::slotCursor) ||
+		(slot_id >= invslot::GENERAL_BEGIN && slot_id <= invslot::GENERAL_END) ||
+		(slot_id >= invslot::BANK_BEGIN && slot_id <= invslot::BANK_END) ||
+		(slot_id >= invslot::SHARED_BANK_BEGIN && slot_id <= invslot::SHARED_BANK_END) ||
+		(slot_id >= invslot::TRADE_BEGIN && slot_id <= invslot::TRADE_END)
 		) {
 		return true;
 	}
@@ -1028,7 +1043,7 @@ int EQEmu::InventoryProfile::GetSlotByItemInst(ItemInstance *inst) {
 	}
 
 	if (m_cursor.peek_front() == inst) {
-		return inventory::slotCursor;
+		return invslot::slotCursor;
 	}
 
 	return INVALID_INDEX;
@@ -1039,8 +1054,8 @@ uint8 EQEmu::InventoryProfile::FindBrightestLightType()
 	uint8 brightest_light_type = 0;
 
 	for (auto iter = m_worn.begin(); iter != m_worn.end(); ++iter) {
-		if ((iter->first < legacy::EQUIPMENT_BEGIN || iter->first > legacy::EQUIPMENT_END) && iter->first != inventory::slotPowerSource) { continue; }
-		if (iter->first == inventory::slotAmmo) { continue; }
+		if ((iter->first < invslot::EQUIPMENT_BEGIN || iter->first > invslot::EQUIPMENT_END) && iter->first != invslot::SLOT_POWER_SOURCE) { continue; }
+		if (iter->first == invslot::slotAmmo) { continue; }
 
 		auto inst = iter->second;
 		if (inst == nullptr) { continue; }
@@ -1053,7 +1068,7 @@ uint8 EQEmu::InventoryProfile::FindBrightestLightType()
 
 	uint8 general_light_type = 0;
 	for (auto iter = m_inv.begin(); iter != m_inv.end(); ++iter) {
-		if (iter->first < legacy::GENERAL_BEGIN || iter->first > legacy::GENERAL_END) { continue; }
+		if (iter->first < invslot::GENERAL_BEGIN || iter->first > invslot::GENERAL_END) { continue; }
 
 		auto inst = iter->second;
 		if (inst == nullptr) { continue; }
@@ -1184,33 +1199,33 @@ int16 EQEmu::InventoryProfile::_PutItem(int16 slot_id, ItemInstance* inst)
 	int16 result = INVALID_INDEX;
 	int16 parentSlot = INVALID_INDEX;
 
-	if (slot_id == inventory::slotCursor) {
+	if (slot_id == invslot::slotCursor) {
 		// Replace current item on cursor, if exists
 		m_cursor.pop(); // no memory delete, clients of this function know what they are doing
 		m_cursor.push_front(inst);
 		result = slot_id;
 	}
-	else if ((slot_id >= legacy::EQUIPMENT_BEGIN && slot_id <= legacy::EQUIPMENT_END) || (slot_id == inventory::slotPowerSource)) {
+	else if ((slot_id >= invslot::EQUIPMENT_BEGIN && slot_id <= invslot::EQUIPMENT_END) || (slot_id == invslot::SLOT_POWER_SOURCE)) {
 		m_worn[slot_id] = inst;
 		result = slot_id;
 	}
-	else if ((slot_id >= legacy::GENERAL_BEGIN && slot_id <= legacy::GENERAL_END)) {
+	else if ((slot_id >= invslot::GENERAL_BEGIN && slot_id <= invslot::GENERAL_END)) {
 		m_inv[slot_id] = inst;
 		result = slot_id;
 	}
-	else if (slot_id >= legacy::TRIBUTE_BEGIN && slot_id <= legacy::TRIBUTE_END) {
+	else if (slot_id >= invslot::TRIBUTE_BEGIN && slot_id <= invslot::TRIBUTE_END) {
 		m_worn[slot_id] = inst;
 		result = slot_id;
 	}
-	else if (slot_id >= legacy::BANK_BEGIN && slot_id <= legacy::BANK_END) {
+	else if (slot_id >= invslot::BANK_BEGIN && slot_id <= invslot::BANK_END) {
 		m_bank[slot_id] = inst;
 		result = slot_id;
 	}
-	else if (slot_id >= legacy::SHARED_BANK_BEGIN && slot_id <= legacy::SHARED_BANK_END) {
+	else if (slot_id >= invslot::SHARED_BANK_BEGIN && slot_id <= invslot::SHARED_BANK_END) {
 		m_shbank[slot_id] = inst;
 		result = slot_id;
 	}
-	else if (slot_id >= legacy::TRADE_BEGIN && slot_id <= legacy::TRADE_END) {
+	else if (slot_id >= invslot::TRADE_BEGIN && slot_id <= invslot::TRADE_END) {
 		m_trade[slot_id] = inst;
 		result = slot_id;
 	}
@@ -1248,7 +1263,7 @@ int16 EQEmu::InventoryProfile::_HasItem(std::map<int16, ItemInstance*>& bucket,
 				return iter->first;
 		}
 
-		for (int index = inventory::socketBegin; index < inventory::SocketCount; ++index) {
+		for (int index = invaug::SOCKET_BEGIN; index <= invaug::SOCKET_END; ++index) {
 			if (inst->GetAugmentItemID(index) == item_id && quantity <= 1)
 				return legacy::SLOT_AUGMENT;
 		}
@@ -1265,7 +1280,7 @@ int16 EQEmu::InventoryProfile::_HasItem(std::map<int16, ItemInstance*>& bucket,
 					return InventoryProfile::CalcSlotId(iter->first, bag_iter->first);
 			}
 
-			for (int index = inventory::socketBegin; index < inventory::SocketCount; ++index) {
+			for (int index = invaug::SOCKET_BEGIN; index <= invaug::SOCKET_END; ++index) {
 				if (bag_inst->GetAugmentItemID(index) == item_id && quantity <= 1)
 					return legacy::SLOT_AUGMENT;
 			}
@@ -1293,10 +1308,10 @@ int16 EQEmu::InventoryProfile::_HasItem(ItemInstQueue& iqueue, uint32 item_id, u
 		if (inst->GetID() == item_id) {
 			quantity_found += (inst->GetCharges() <= 0) ? 1 : inst->GetCharges();
 			if (quantity_found >= quantity)
-				return inventory::slotCursor;
+				return invslot::slotCursor;
 		}
 
-		for (int index = inventory::socketBegin; index < inventory::SocketCount; ++index) {
+		for (int index = invaug::SOCKET_BEGIN; index <= invaug::SOCKET_END; ++index) {
 			if (inst->GetAugmentItemID(index) == item_id && quantity <= 1)
 				return legacy::SLOT_AUGMENT;
 		}
@@ -1310,10 +1325,10 @@ int16 EQEmu::InventoryProfile::_HasItem(ItemInstQueue& iqueue, uint32 item_id, u
 			if (bag_inst->GetID() == item_id) {
 				quantity_found += (bag_inst->GetCharges() <= 0) ? 1 : bag_inst->GetCharges();
 				if (quantity_found >= quantity)
-					return InventoryProfile::CalcSlotId(inventory::slotCursor, bag_iter->first);
+					return InventoryProfile::CalcSlotId(invslot::slotCursor, bag_iter->first);
 			}
 
-			for (int index = inventory::socketBegin; index < inventory::SocketCount; ++index) {
+			for (int index = invaug::SOCKET_BEGIN; index <= invaug::SOCKET_END; ++index) {
 				if (bag_inst->GetAugmentItemID(index) == item_id && quantity <= 1)
 					return legacy::SLOT_AUGMENT;
 			}
@@ -1370,7 +1385,7 @@ int16 EQEmu::InventoryProfile::_HasItemByUse(ItemInstQueue& iqueue, uint8 use, u
 		if (inst->IsClassCommon() && inst->GetItem()->ItemType == use) {
 			quantity_found += (inst->GetCharges() <= 0) ? 1 : inst->GetCharges();
 			if (quantity_found >= quantity)
-				return inventory::slotCursor;
+				return invslot::slotCursor;
 		}
 
 		if (!inst->IsClassBag()) { continue; }
@@ -1382,7 +1397,7 @@ int16 EQEmu::InventoryProfile::_HasItemByUse(ItemInstQueue& iqueue, uint8 use, u
 			if (bag_inst->IsClassCommon() && bag_inst->GetItem()->ItemType == use) {
 				quantity_found += (bag_inst->GetCharges() <= 0) ? 1 : bag_inst->GetCharges();
 				if (quantity_found >= quantity)
-					return InventoryProfile::CalcSlotId(inventory::slotCursor, bag_iter->first);
+					return InventoryProfile::CalcSlotId(invslot::slotCursor, bag_iter->first);
 			}
 		}
 
@@ -1402,7 +1417,7 @@ int16 EQEmu::InventoryProfile::_HasItemByLoreGroup(std::map<int16, ItemInstance*
 		if (inst->GetItem()->LoreGroup == loregroup)
 			return iter->first;
 
-		for (int index = inventory::socketBegin; index < inventory::SocketCount; ++index) {
+		for (int index = invaug::SOCKET_BEGIN; index <= invaug::SOCKET_END; ++index) {
 			auto aug_inst = inst->GetAugment(index);
 			if (aug_inst == nullptr) { continue; }
 
@@ -1419,7 +1434,7 @@ int16 EQEmu::InventoryProfile::_HasItemByLoreGroup(std::map<int16, ItemInstance*
 			if (bag_inst->IsClassCommon() && bag_inst->GetItem()->LoreGroup == loregroup)
 				return InventoryProfile::CalcSlotId(iter->first, bag_iter->first);
 
-			for (int index = inventory::socketBegin; index < inventory::SocketCount; ++index) {
+			for (int index = invaug::SOCKET_BEGIN; index <= invaug::SOCKET_END; ++index) {
 				auto aug_inst = bag_inst->GetAugment(index);
 				if (aug_inst == nullptr) { continue; }
 
@@ -1440,9 +1455,9 @@ int16 EQEmu::InventoryProfile::_HasItemByLoreGroup(ItemInstQueue& iqueue, uint32
 		if (inst == nullptr) { continue; }
 
 		if (inst->GetItem()->LoreGroup == loregroup)
-			return inventory::slotCursor;
+			return invslot::slotCursor;
 
-		for (int index = inventory::socketBegin; index < inventory::SocketCount; ++index) {
+		for (int index = invaug::SOCKET_BEGIN; index <= invaug::SOCKET_END; ++index) {
 			auto aug_inst = inst->GetAugment(index);
 			if (aug_inst == nullptr) { continue; }
 
@@ -1457,9 +1472,9 @@ int16 EQEmu::InventoryProfile::_HasItemByLoreGroup(ItemInstQueue& iqueue, uint32
 			if (bag_inst == nullptr) { continue; }
 
 			if (bag_inst->IsClassCommon() && bag_inst->GetItem()->LoreGroup == loregroup)
-				return InventoryProfile::CalcSlotId(inventory::slotCursor, bag_iter->first);
+				return InventoryProfile::CalcSlotId(invslot::slotCursor, bag_iter->first);
 
-			for (int index = inventory::socketBegin; index < inventory::SocketCount; ++index) {
+			for (int index = invaug::SOCKET_BEGIN; index <= invaug::SOCKET_END; ++index) {
 				auto aug_inst = bag_inst->GetAugment(index);
 				if (aug_inst == nullptr) { continue; }
 

common/inventory_profile.h

@@ -92,22 +92,13 @@ namespace EQEmu
 		}
 		~InventoryProfile();
 
-		bool SetInventoryVersion(versions::MobVersion inventory_version) {
-			if (!m_mob_version_set) {
-				m_mob_version = versions::ValidateMobVersion(inventory_version);
-				m_lookup = inventory::Lookup(m_mob_version);
-				m_mob_version_set = true;
-				return true;
-			}
-			else {
-				m_lookup = inventory::Lookup(versions::MobVersion::Unknown);
-				return false;
-			}
-		}
+		bool SetInventoryVersion(versions::MobVersion inventory_version);
 		bool SetInventoryVersion(versions::ClientVersion client_version) { return SetInventoryVersion(versions::ConvertClientVersionToMobVersion(client_version)); }
 
 		versions::MobVersion InventoryVersion() { return m_mob_version; }
 
+		const inventory::LookupEntry* GetLookup() const { return m_lookup; }
+
 		static void CleanDirty();
 		static void MarkDirty(ItemInstance *inst);
 
@@ -163,7 +154,7 @@ namespace EQEmu
 
 		// Locate an available inventory slot
 		int16 FindFreeSlot(bool for_bag, bool try_cursor, uint8 min_size = 0, bool is_arrow = false);
-		int16 FindFreeSlotForTradeItem(const ItemInstance* inst, int16 general_start = legacy::GENERAL_BEGIN, uint8 bag_start = inventory::containerBegin);
+		int16 FindFreeSlotForTradeItem(const ItemInstance* inst, int16 general_start = invslot::GENERAL_BEGIN, uint8 bag_start = invbag::SLOT_BEGIN);
 
 		// Calculate slot_id for an item within a bag
 		static int16 CalcSlotId(int16 slot_id); // Calc parent bag's slot_id

common/inventory_slot.cpp

@@ -25,23 +25,23 @@
 int8 EQEmu::inventory::ConvertEquipmentIndexToTextureIndex(int16 slot_index)
 {
 	switch (slot_index) {
-	case slotHead:
+	case invslot::slotHead:
 		return textures::armorHead;
-	case slotChest:
+	case invslot::slotChest:
 		return textures::armorChest;
-	case slotArms:
+	case invslot::slotArms:
 		return textures::armorArms;
-	case slotWrist1:
+	case invslot::slotWrist1:
 		return textures::armorWrist;
-	case slotHands:
+	case invslot::slotHands:
 		return textures::armorHands;
-	case slotLegs:
+	case invslot::slotLegs:
 		return textures::armorLegs;
-	case slotFeet:
+	case invslot::slotFeet:
 		return textures::armorFeet;
-	case slotPrimary:
+	case invslot::slotPrimary:
 		return textures::weaponPrimary;
-	case slotSecondary:
+	case invslot::slotSecondary:
 		return textures::weaponSecondary;
 	default:
 		return textures::textureInvalid;
@@ -50,7 +50,7 @@ int8 EQEmu::inventory::ConvertEquipmentIndexToTextureIndex(int16 slot_index)
 
 int8 EQEmu::inventory::ConvertEquipmentSlotToTextureIndex(const InventorySlot& inventory_slot)
 {
-	if ((!inventory_slot.Typeless() && !inventory_slot.IsTypeIndex(typePossessions)) || !inventory_slot.IsContainerIndex(containerInvalid) || !inventory_slot.IsSocketIndex(socketInvalid))
+	if ((!inventory_slot.Typeless() && !inventory_slot.IsTypeIndex(invtype::typePossessions)) || !inventory_slot.IsContainerIndex(invbag::SLOT_INVALID) || !inventory_slot.IsSocketIndex(invaug::SOCKET_INVALID))
 		return textures::textureInvalid;
 
 	return ConvertEquipmentIndexToTextureIndex(inventory_slot.SlotIndex());
@@ -60,25 +60,25 @@ int16 EQEmu::inventory::ConvertTextureIndexToEquipmentIndex(int8 texture_index)
 {
 	switch (texture_index) {
 	case textures::armorHead:
-		return slotHead;
+		return invslot::slotHead;
 	case textures::armorChest:
-		return slotChest;
+		return invslot::slotChest;
 	case textures::armorArms:
-		return slotArms;
+		return invslot::slotArms;
 	case textures::armorWrist:
-		return slotWrist1;
+		return invslot::slotWrist1;
 	case textures::armorHands:
-		return slotHands;
+		return invslot::slotHands;
 	case textures::armorLegs:
-		return slotLegs;
+		return invslot::slotLegs;
 	case textures::armorFeet:
-		return slotFeet;
+		return invslot::slotFeet;
 	case textures::weaponPrimary:
-		return slotPrimary;
+		return invslot::slotPrimary;
 	case textures::weaponSecondary:
-		return slotSecondary;
+		return invslot::slotSecondary;
 	default:
-		return slotInvalid;
+		return invslot::SLOT_INVALID;
 	}
 }
 
@@ -87,14 +87,14 @@ bool EQEmu::InventorySlot::IsValidSlot() const
 	if (_typeless)
 		return false;
 	
-	int16 slot_count = inventory::SlotCount(_type_index);
-	if (!slot_count || _slot_index < inventory::slotBegin || _slot_index >= slot_count)
+	int16 slot_count = invtype::GetInvTypeSize(_type_index);
+	if (!slot_count || _slot_index < invslot::SLOT_BEGIN || _slot_index >= slot_count)
 		return false;
 
-	if (_container_index < inventory::containerInvalid || _container_index >= inventory::ContainerCount)
+	if (_container_index < invbag::SLOT_INVALID || _container_index >= invbag::SLOT_COUNT)
 		return false;
 
-	if (_socket_index < inventory::socketInvalid || _socket_index >= inventory::SocketCount)
+	if (_socket_index < invaug::SOCKET_INVALID || _socket_index >= invaug::SOCKET_COUNT)
 		return false;
 
 	return true;
@@ -103,16 +103,16 @@ bool EQEmu::InventorySlot::IsValidSlot() const
 bool EQEmu::InventorySlot::IsDeleteSlot() const
 {
 	if (_typeless)
-		return (_slot_index == inventory::slotInvalid && _container_index == inventory::containerInvalid && _socket_index == inventory::socketInvalid);
+		return (_slot_index == invslot::SLOT_INVALID && _container_index == invbag::SLOT_INVALID && _socket_index == invaug::SOCKET_INVALID);
 	else
-		return (_type_index == inventory::typeInvalid && _slot_index == inventory::slotInvalid && _container_index == inventory::containerInvalid && _socket_index == inventory::socketInvalid);
+		return (_type_index == invtype::TYPE_INVALID && _slot_index == invslot::SLOT_INVALID && _container_index == invbag::SLOT_INVALID && _socket_index == invaug::SOCKET_INVALID);
 }
 
 bool EQEmu::InventorySlot::IsEquipmentIndex(int16 slot_index)
 {
 	/*if (slot_index < inventory::EquipmentBegin || slot_index > inventory::EquipmentEnd)
 		return false;*/
-	if ((slot_index < legacy::EQUIPMENT_BEGIN || slot_index > legacy::EQUIPMENT_END) && slot_index != legacy::SLOT_POWER_SOURCE)
+	if ((slot_index < invslot::EQUIPMENT_BEGIN || slot_index > invslot::EQUIPMENT_END) && slot_index != invslot::SLOT_POWER_SOURCE)
 		return false;
 
 	return true;
@@ -122,7 +122,7 @@ bool EQEmu::InventorySlot::IsGeneralIndex(int16 slot_index)
 {
 	/*if (slot_index < inventory::GeneralBegin || slot_index > inventory::GeneralEnd)
 		return false;*/
-	if (slot_index < legacy::GENERAL_BEGIN || slot_index > legacy::GENERAL_END)
+	if (slot_index < invslot::GENERAL_BEGIN || slot_index > invslot::GENERAL_END)
 		return false;
 
 	return true;
@@ -132,7 +132,7 @@ bool EQEmu::InventorySlot::IsCursorIndex(int16 slot_index)
 {
 	/*if (slot_index != inventory::slotCursor)
 		return false;*/
-	if (slot_index != legacy::SLOT_CURSOR)
+	if (slot_index != invslot::slotCursor)
 		return false;
 
 	return true;
@@ -142,7 +142,7 @@ bool EQEmu::InventorySlot::IsWeaponIndex(int16 slot_index)
 {
 	/*if ((slot_index != inventory::slotRange) && (slot_index != inventory::slotPrimary) && (slot_index != inventory::slotSecondary))
 		return false;*/
-	if ((slot_index != legacy::SLOT_RANGE) && (slot_index != legacy::SLOT_PRIMARY) && (slot_index != legacy::SLOT_SECONDARY))
+	if ((slot_index != invslot::slotRange) && (slot_index != invslot::slotPrimary) && (slot_index != invslot::slotSecondary))
 		return false;
 
 	return true;
@@ -151,15 +151,15 @@ bool EQEmu::InventorySlot::IsWeaponIndex(int16 slot_index)
 bool EQEmu::InventorySlot::IsTextureIndex(int16 slot_index)
 {
 	switch (slot_index) {
-	case inventory::slotHead:
-	case inventory::slotChest:
-	case inventory::slotArms:
-	case inventory::slotWrist1:
-	case inventory::slotHands:
-	case inventory::slotLegs:
-	case inventory::slotFeet:
-	case inventory::slotPrimary:
-	case inventory::slotSecondary:
+	case invslot::slotHead:
+	case invslot::slotChest:
+	case invslot::slotArms:
+	case invslot::slotWrist1:
+	case invslot::slotHands:
+	case invslot::slotLegs:
+	case invslot::slotFeet:
+	case invslot::slotPrimary:
+	case invslot::slotSecondary:
 		return true;
 	default:
 		return false;
@@ -169,13 +169,13 @@ bool EQEmu::InventorySlot::IsTextureIndex(int16 slot_index)
 bool EQEmu::InventorySlot::IsTintableIndex(int16 slot_index)
 {
 	switch (slot_index) {
-	case inventory::slotHead:
-	case inventory::slotChest:
-	case inventory::slotArms:
-	case inventory::slotWrist1:
-	case inventory::slotHands:
-	case inventory::slotLegs:
-	case inventory::slotFeet:
+	case invslot::slotHead:
+	case invslot::slotChest:
+	case invslot::slotArms:
+	case invslot::slotWrist1:
+	case invslot::slotHands:
+	case invslot::slotLegs:
+	case invslot::slotFeet:
 		return true;
 	default:
 		return false;
@@ -184,10 +184,10 @@ bool EQEmu::InventorySlot::IsTintableIndex(int16 slot_index)
 
 bool EQEmu::InventorySlot::IsEquipmentSlot() const
 {
-	if (!_typeless && (_type_index != inventory::typePossessions))
+	if (!_typeless && (_type_index != invtype::typePossessions))
 		return false;
 
-	if ((_container_index != inventory::containerInvalid) || (_socket_index != inventory::socketInvalid))
+	if ((_container_index != invbag::SLOT_INVALID) || (_socket_index != invaug::SOCKET_INVALID))
 		return false;
 
 	return IsEquipmentIndex(_slot_index);
@@ -195,10 +195,10 @@ bool EQEmu::InventorySlot::IsEquipmentSlot() const
 
 bool EQEmu::InventorySlot::IsGeneralSlot() const
 {
-	if (!_typeless && (_type_index != inventory::typePossessions))
+	if (!_typeless && (_type_index != invtype::typePossessions))
 		return false;
 
-	if ((_container_index != inventory::containerInvalid) || (_socket_index != inventory::socketInvalid))
+	if ((_container_index != invbag::SLOT_INVALID) || (_socket_index != invaug::SOCKET_INVALID))
 		return false;
 
 	return IsGeneralIndex(_socket_index);
@@ -206,10 +206,10 @@ bool EQEmu::InventorySlot::IsGeneralSlot() const
 
 bool EQEmu::InventorySlot::IsCursorSlot() const
 {
-	if (!_typeless && (_type_index != inventory::typePossessions))
+	if (!_typeless && (_type_index != invtype::typePossessions))
 		return false;
 
-	if ((_container_index != inventory::containerInvalid) || (_socket_index != inventory::socketInvalid))
+	if ((_container_index != invbag::SLOT_INVALID) || (_socket_index != invaug::SOCKET_INVALID))
 		return false;
 
 	return IsCursorIndex(_slot_index);
@@ -217,10 +217,10 @@ bool EQEmu::InventorySlot::IsCursorSlot() const
 
 bool EQEmu::InventorySlot::IsWeaponSlot() const
 {
-	if (!_typeless && (_type_index != inventory::typePossessions))
+	if (!_typeless && (_type_index != invtype::typePossessions))
 		return false;
 
-	if ((_container_index != inventory::containerInvalid) || (_socket_index != inventory::socketInvalid))
+	if ((_container_index != invbag::SLOT_INVALID) || (_socket_index != invaug::SOCKET_INVALID))
 		return false;
 
 	return IsWeaponIndex(_slot_index);
@@ -228,10 +228,10 @@ bool EQEmu::InventorySlot::IsWeaponSlot() const
 
 bool EQEmu::InventorySlot::IsTextureSlot() const
 {
-	if (!_typeless && (_type_index != inventory::typePossessions))
+	if (!_typeless && (_type_index != invtype::typePossessions))
 		return false;
 
-	if ((_container_index != inventory::containerInvalid) || (_socket_index != inventory::socketInvalid))
+	if ((_container_index != invbag::SLOT_INVALID) || (_socket_index != invaug::SOCKET_INVALID))
 		return false;
 
 	return IsTextureIndex(_slot_index);
@@ -239,10 +239,10 @@ bool EQEmu::InventorySlot::IsTextureSlot() const
 
 bool EQEmu::InventorySlot::IsTintableSlot() const
 {
-	if (!_typeless && (_type_index != inventory::typePossessions))
+	if (!_typeless && (_type_index != invtype::typePossessions))
 		return false;
 
-	if ((_container_index != inventory::containerInvalid) || (_socket_index != inventory::socketInvalid))
+	if ((_container_index != invbag::SLOT_INVALID) || (_socket_index != invaug::SOCKET_INVALID))
 		return false;
 
 	return IsTintableIndex(_slot_index);
@@ -250,13 +250,13 @@ bool EQEmu::InventorySlot::IsTintableSlot() const
 
 bool EQEmu::InventorySlot::IsSlot() const
 {
-	if (!_typeless && (_type_index == inventory::typeInvalid))
+	if (!_typeless && (_type_index == invtype::TYPE_INVALID))
 		return false;
-	if (_slot_index == inventory::slotInvalid)
+	if (_slot_index == invslot::SLOT_INVALID)
 		return false;
-	if (_container_index != inventory::containerInvalid)
+	if (_container_index != invbag::SLOT_INVALID)
 		return false;
-	if (_socket_index != inventory::socketInvalid)
+	if (_socket_index != invaug::SOCKET_INVALID)
 		return false;
 
 	return true;
@@ -264,13 +264,13 @@ bool EQEmu::InventorySlot::IsSlot() const
 
 bool EQEmu::InventorySlot::IsSlotSocket() const
 {
-	if (!_typeless && (_type_index == inventory::typeInvalid))
+	if (!_typeless && (_type_index == invtype::TYPE_INVALID))
 		return false;
-	if (_slot_index == inventory::slotInvalid)
+	if (_slot_index == invslot::SLOT_INVALID)
 		return false;
-	if (_container_index != inventory::containerInvalid)
+	if (_container_index != invbag::SLOT_INVALID)
 		return false;
-	if (_socket_index == inventory::socketInvalid)
+	if (_socket_index == invaug::SOCKET_INVALID)
 		return false;
 
 	return true;
@@ -278,13 +278,13 @@ bool EQEmu::InventorySlot::IsSlotSocket() const
 
 bool EQEmu::InventorySlot::IsContainer() const
 {
-	if (!_typeless && (_type_index == inventory::typeInvalid))
+	if (!_typeless && (_type_index == invtype::TYPE_INVALID))
 		return false;
-	if (_slot_index == inventory::slotInvalid)
+	if (_slot_index == invslot::SLOT_INVALID)
 		return false;
-	if (_container_index == inventory::containerInvalid)
+	if (_container_index == invbag::SLOT_INVALID)
 		return false;
-	if (_socket_index != inventory::socketInvalid)
+	if (_socket_index != invaug::SOCKET_INVALID)
 		return false;
 
 	return true;
@@ -292,13 +292,13 @@ bool EQEmu::InventorySlot::IsContainer() const
 
 bool EQEmu::InventorySlot::IsContainerSocket() const
 {
-	if (!_typeless && (_type_index == inventory::typeInvalid))
+	if (!_typeless && (_type_index == invtype::TYPE_INVALID))
 		return false;
-	if (_slot_index == inventory::slotInvalid)
+	if (_slot_index == invslot::SLOT_INVALID)
 		return false;
-	if (_container_index == inventory::containerInvalid)
+	if (_container_index == invbag::SLOT_INVALID)
 		return false;
-	if (_socket_index == inventory::socketInvalid)
+	if (_socket_index == invaug::SOCKET_INVALID)
 		return false;
 
 	return true;
@@ -332,10 +332,10 @@ const std::string EQEmu::InventorySlot::ToName() const
 
 void EQEmu::InventorySlot::SetInvalidSlot()
 {
-	_type_index = inventory::typeInvalid;
-	_slot_index = inventory::slotInvalid;
-	_container_index = inventory::containerInvalid;
-	_socket_index = inventory::socketInvalid;
+	_type_index = invtype::TYPE_INVALID;
+	_slot_index = invslot::SLOT_INVALID;
+	_container_index = invbag::SLOT_INVALID;
+	_socket_index = invaug::SOCKET_INVALID;
 }
 
 //bool EQEmu::InventorySlot::IsBonusIndex(int16 slot_index)

common/inventory_slot.h

@@ -35,10 +35,10 @@ namespace EQEmu
 	
 	class InventorySlot {
 	public:
-		InventorySlot() : _type_index(inventory::typeInvalid), _slot_index(inventory::slotInvalid), _container_index(inventory::containerInvalid), _socket_index(inventory::socketInvalid), _typeless(false) { }
-		InventorySlot(int16 type_index) : _type_index(type_index), _slot_index(inventory::slotInvalid), _container_index(inventory::containerInvalid), _socket_index(inventory::socketInvalid), _typeless(false) { }
-		InventorySlot(int16 type_index, int16 parent_index) : _type_index(type_index), _slot_index(parent_index), _container_index(inventory::containerInvalid), _socket_index(inventory::socketInvalid), _typeless(false) { }
-		InventorySlot(int16 type_index, int16 parent_index, int16 bag_index) : _type_index(type_index), _slot_index(parent_index), _container_index(bag_index), _socket_index(inventory::socketInvalid), _typeless(false) { }
+		InventorySlot() : _type_index(invtype::TYPE_INVALID), _slot_index(invslot::SLOT_INVALID), _container_index(invbag::SLOT_INVALID), _socket_index(invaug::SOCKET_INVALID), _typeless(false) { }
+		InventorySlot(int16 type_index) : _type_index(type_index), _slot_index(invslot::SLOT_INVALID), _container_index(invbag::SLOT_INVALID), _socket_index(invaug::SOCKET_INVALID), _typeless(false) { }
+		InventorySlot(int16 type_index, int16 parent_index) : _type_index(type_index), _slot_index(parent_index), _container_index(invbag::SLOT_INVALID), _socket_index(invaug::SOCKET_INVALID), _typeless(false) { }
+		InventorySlot(int16 type_index, int16 parent_index, int16 bag_index) : _type_index(type_index), _slot_index(parent_index), _container_index(bag_index), _socket_index(invaug::SOCKET_INVALID), _typeless(false) { }
 		InventorySlot(int16 type_index, int16 parent_index, int16 bag_index, int16 aug_index) : _type_index(type_index), _slot_index(parent_index), _container_index(bag_index), _socket_index(aug_index), _typeless(false) { }
 		InventorySlot(const InventorySlot& r) : _type_index(r._type_index), _slot_index(r._slot_index), _container_index(r._container_index), _socket_index(r._socket_index), _typeless(r._typeless) { }
 		InventorySlot(int16 type_index, const InventorySlot& r) : _type_index(type_index), _slot_index(r._slot_index), _container_index(r._container_index), _socket_index(r._socket_index), _typeless(false) { }
@@ -90,15 +90,15 @@ namespace EQEmu
 
 		void SetInvalidSlot();
 
-		void SetTypeInvalid() { _type_index = inventory::typeInvalid; }
-		void SetSlotInvalid() { _slot_index = inventory::slotInvalid; }
-		void SetContainerInvalid() { _container_index = inventory::containerInvalid; }
-		void SetSocketInvalid() { _socket_index = inventory::socketInvalid; }
+		void SetTypeInvalid() { _type_index = invtype::TYPE_INVALID; }
+		void SetSlotInvalid() { _slot_index = invslot::SLOT_INVALID; }
+		void SetContainerInvalid() { _container_index = invbag::SLOT_INVALID; }
+		void SetSocketInvalid() { _socket_index = invaug::SOCKET_INVALID; }
 
-		void SetTypeBegin() { _type_index = inventory::typeBegin; }
-		void SetSlotBegin() { _slot_index = inventory::slotBegin; }
-		void SetContainerBegin() { _container_index = inventory::containerBegin; }
-		void SetSocketBegin() { _socket_index = inventory::socketBegin; }
+		void SetTypeBegin() { _type_index = invtype::TYPE_BEGIN; }
+		void SetSlotBegin() { _slot_index = invslot::SLOT_BEGIN; }
+		void SetContainerBegin() { _container_index = invbag::SLOT_BEGIN; }
+		void SetSocketBegin() { _socket_index = invaug::SOCKET_BEGIN; }
 
 		void IncrementType() { ++_type_index; }
 		void IncrementSlot() { ++_slot_index; }

common/item_data.h

@@ -464,9 +464,9 @@ namespace EQEmu
 		int32	FactionAmt4;	// Faction Amt 4
 		char	CharmFile[32];	// ?
 		uint32	AugType;
-		uint8	AugSlotType[inventory::SocketCount];	// RoF: Augment Slot 1-6 Type
-		uint8	AugSlotVisible[inventory::SocketCount];	// RoF: Augment Slot 1-6 Visible
-		uint8	AugSlotUnk2[inventory::SocketCount];	// RoF: Augment Slot 1-6 Unknown Most likely Powersource related
+		uint8	AugSlotType[invaug::SOCKET_COUNT];	// RoF: Augment Slot 1-6 Type
+		uint8	AugSlotVisible[invaug::SOCKET_COUNT];	// RoF: Augment Slot 1-6 Visible
+		uint8	AugSlotUnk2[invaug::SOCKET_COUNT];	// RoF: Augment Slot 1-6 Unknown Most likely Powersource related
 		uint32	LDoNTheme;
 		uint32	LDoNPrice;
 		uint32	LDoNSold;

common/item_instance.cpp

@@ -273,8 +273,8 @@ bool EQEmu::ItemInstance::IsEquipable(int16 slot_id) const
 
 	// another "shouldn't do" fix..will be fixed in future updates (requires code and database work)
 	int16 use_slot = INVALID_INDEX;
-	if (slot_id == inventory::slotPowerSource) { use_slot = inventory::slotGeneral1; }
-	if ((uint16)slot_id <= legacy::EQUIPMENT_END) { use_slot = slot_id; }
+	if (slot_id == invslot::SLOT_POWER_SOURCE) { use_slot = invslot::slotGeneral1; }
+	if ((uint16)slot_id <= invslot::EQUIPMENT_END) { use_slot = slot_id; }
 
 	if (use_slot != INVALID_INDEX) {
 		if (m_item->Slots & (1 << use_slot))
@@ -289,7 +289,7 @@ bool EQEmu::ItemInstance::IsAugmentable() const
 	if (!m_item)
 		return false;
 
-	for (int index = inventory::socketBegin; index < inventory::SocketCount; ++index) {
+	for (int index = invaug::SOCKET_BEGIN; index <= invaug::SOCKET_END; ++index) {
 		if (m_item->AugSlotType[index] != 0)
 			return true;
 	}
@@ -303,8 +303,8 @@ bool EQEmu::ItemInstance::AvailableWearSlot(uint32 aug_wear_slots) const {
 	if (!m_item || !m_item->IsClassCommon())
 		return false;
 
-	int index = legacy::EQUIPMENT_BEGIN;
-	for (; index <= inventory::slotGeneral1; ++index) { // MainGeneral1 should be legacy::EQUIPMENT_END
+	int index = invslot::EQUIPMENT_BEGIN;
+	for (; index <= invslot::slotGeneral1; ++index) { // MainGeneral1 should be legacy::EQUIPMENT_END
 		if (m_item->Slots & (1 << index)) {
 			if (aug_wear_slots & (1 << index))
 				break;
@@ -319,14 +319,14 @@ int8 EQEmu::ItemInstance::AvailableAugmentSlot(int32 augtype) const
 	if (!m_item || !m_item->IsClassCommon())
 		return INVALID_INDEX;
 
-	int index = inventory::socketBegin;
-	for (; index < inventory::SocketCount; ++index) {
+	int index = invaug::SOCKET_BEGIN;
+	for (; index <= invaug::SOCKET_END; ++index) {
 		if (GetItem(index)) { continue; }
 		if (augtype == -1 || (m_item->AugSlotType[index] && ((1 << (m_item->AugSlotType[index] - 1)) & augtype)))
 			break;
 	}
 
-	return (index < inventory::SocketCount) ? index : INVALID_INDEX;
+	return (index <= invaug::SOCKET_END) ? index : INVALID_INDEX;
 }
 
 bool EQEmu::ItemInstance::IsAugmentSlotAvailable(int32 augtype, uint8 slot) const
@@ -469,7 +469,7 @@ uint8 EQEmu::ItemInstance::FirstOpenSlot() const
 		return INVALID_INDEX;
 
 	uint8 slots = m_item->BagSlots, i;
-	for (i = inventory::containerBegin; i < slots; i++) {
+	for (i = invbag::SLOT_BEGIN; i < slots; i++) {
 		if (!GetItem(i))
 			break;
 	}
@@ -486,7 +486,7 @@ uint8 EQEmu::ItemInstance::GetTotalItemCount() const
 
 	if (m_item && !m_item->IsClassBag()) { return item_count; }
 
-	for (int index = inventory::containerBegin; index < m_item->BagSlots; ++index) { if (GetItem(index)) { ++item_count; } }
+	for (int index = invbag::SLOT_BEGIN; index < m_item->BagSlots; ++index) { if (GetItem(index)) { ++item_count; } }
 
 	return item_count;
 }
@@ -496,7 +496,7 @@ bool EQEmu::ItemInstance::IsNoneEmptyContainer()
 	if (!m_item || !m_item->IsClassBag())
 		return false;
 
-	for (int index = inventory::containerBegin; index < m_item->BagSlots; ++index) {
+	for (int index = invbag::SLOT_BEGIN; index < m_item->BagSlots; ++index) {
 		if (GetItem(index))
 			return true;
 	}
@@ -518,7 +518,7 @@ EQEmu::ItemInstance* EQEmu::ItemInstance::GetOrnamentationAug(int32 ornamentatio
 	if (!m_item || !m_item->IsClassCommon()) { return nullptr; }
 	if (ornamentationAugtype == 0) { return nullptr; }
 
-	for (int i = inventory::socketBegin; i < inventory::SocketCount; i++)
+	for (int i = invaug::SOCKET_BEGIN; i <= invaug::SOCKET_END; i++)
 	{
 		if (GetAugment(i) && m_item->AugSlotType[i] == ornamentationAugtype)
 		{
@@ -686,7 +686,7 @@ bool EQEmu::ItemInstance::IsAugmented()
 	if (!m_item || !m_item->IsClassCommon())
 		return false;
 	
-	for (int index = inventory::socketBegin; index < inventory::SocketCount; ++index) {
+	for (int index = invaug::SOCKET_BEGIN; index <= invaug::SOCKET_END; ++index) {
 		if (GetAugmentItemID(index))
 			return true;
 	}
@@ -814,8 +814,8 @@ bool EQEmu::ItemInstance::IsSlotAllowed(int16 slot_id) const {
 	if (!m_item) { return false; }
 	else if (InventoryProfile::SupportsContainers(slot_id)) { return true; }
 	else if (m_item->Slots & (1 << slot_id)) { return true; }
-	else if (slot_id == inventory::slotPowerSource && (m_item->Slots & (1 << 22))) { return true; } // got lazy... <watch>
-	else if (slot_id != inventory::slotPowerSource && slot_id > legacy::EQUIPMENT_END) { return true; }
+	else if (slot_id == invslot::SLOT_POWER_SOURCE && (m_item->Slots & (1 << 22))) { return true; } // got lazy... <watch>
+	else if (slot_id != invslot::SLOT_POWER_SOURCE && slot_id > invslot::EQUIPMENT_END) { return true; }
 	else { return false; }
 }
 
@@ -993,7 +993,7 @@ int EQEmu::ItemInstance::GetItemArmorClass(bool augments) const
 	if (item) {
 		ac = item->AC;
 		if (augments)
-			for (int i = inventory::socketBegin; i < inventory::SocketCount; ++i)
+			for (int i = invaug::SOCKET_BEGIN; i <= invaug::SOCKET_END; ++i)
 				if (GetAugment(i))
 					ac += GetAugment(i)->GetItemArmorClass();
 	}
@@ -1035,7 +1035,7 @@ int EQEmu::ItemInstance::GetItemElementalDamage(int &magic, int &fire, int &cold
 		}
 
 		if (augments)
-			for (int i = inventory::socketBegin; i < inventory::SocketCount; ++i)
+			for (int i = invaug::SOCKET_BEGIN; i <= invaug::SOCKET_END; ++i)
 				if (GetAugment(i))
 					GetAugment(i)->GetItemElementalDamage(magic, fire, cold, poison, disease, chromatic, prismatic, physical, corruption);
 	}
@@ -1052,7 +1052,7 @@ int EQEmu::ItemInstance::GetItemElementalFlag(bool augments) const
 			return flag;
 
 		if (augments) {
-			for (int i = inventory::socketBegin; i < inventory::SocketCount; ++i) {
+			for (int i = invaug::SOCKET_BEGIN; i <= invaug::SOCKET_END; ++i) {
 				if (GetAugment(i))
 					flag = GetAugment(i)->GetItemElementalFlag();
 				if (flag)
@@ -1073,7 +1073,7 @@ int EQEmu::ItemInstance::GetItemElementalDamage(bool augments) const
 			return damage;
 
 		if (augments) {
-			for (int i = inventory::socketBegin; i < inventory::SocketCount; ++i) {
+			for (int i = invaug::SOCKET_BEGIN; i <= invaug::SOCKET_END; ++i) {
 				if (GetAugment(i))
 					damage = GetAugment(i)->GetItemElementalDamage();
 				if (damage)
@@ -1092,7 +1092,7 @@ int EQEmu::ItemInstance::GetItemRecommendedLevel(bool augments) const
 		level = item->RecLevel;
 
 		if (augments) {
-			for (int i = inventory::socketBegin; i < inventory::SocketCount; ++i) {
+			for (int i = invaug::SOCKET_BEGIN; i <= invaug::SOCKET_END; ++i) {
 				int temp = 0;
 				if (GetAugment(i)) {
 					temp = GetAugment(i)->GetItemRecommendedLevel();
@@ -1114,7 +1114,7 @@ int EQEmu::ItemInstance::GetItemRequiredLevel(bool augments) const
 		level = item->ReqLevel;
 
 		if (augments) {
-			for (int i = inventory::socketBegin; i < inventory::SocketCount; ++i) {
+			for (int i = invaug::SOCKET_BEGIN; i <= invaug::SOCKET_END; ++i) {
 				int temp = 0;
 				if (GetAugment(i)) {
 					temp = GetAugment(i)->GetItemRequiredLevel();
@@ -1136,7 +1136,7 @@ int EQEmu::ItemInstance::GetItemWeaponDamage(bool augments) const
 		damage = item->Damage;
 
 		if (augments) {
-			for (int i = inventory::socketBegin; i < inventory::SocketCount; ++i)
+			for (int i = invaug::SOCKET_BEGIN; i <= invaug::SOCKET_END; ++i)
 				if (GetAugment(i))
 					damage += GetAugment(i)->GetItemWeaponDamage();
 		}
@@ -1152,7 +1152,7 @@ int EQEmu::ItemInstance::GetItemBackstabDamage(bool augments) const
 		damage = item->BackstabDmg;
 
 		if (augments) {
-			for (int i = inventory::socketBegin; i < inventory::SocketCount; ++i)
+			for (int i = invaug::SOCKET_BEGIN; i <= invaug::SOCKET_END; ++i)
 				if (GetAugment(i))
 					damage += GetAugment(i)->GetItemBackstabDamage();
 		}
@@ -1170,7 +1170,7 @@ int EQEmu::ItemInstance::GetItemBaneDamageBody(bool augments) const
 			return body;
 
 		if (augments) {
-			for (int i = inventory::socketBegin; i < inventory::SocketCount; ++i)
+			for (int i = invaug::SOCKET_BEGIN; i <= invaug::SOCKET_END; ++i)
 				if (GetAugment(i)) {
 					body = GetAugment(i)->GetItemBaneDamageBody();
 					if (body)
@@ -1191,7 +1191,7 @@ int EQEmu::ItemInstance::GetItemBaneDamageRace(bool augments) const
 			return race;
 
 		if (augments) {
-			for (int i = inventory::socketBegin; i < inventory::SocketCount; ++i)
+			for (int i = invaug::SOCKET_BEGIN; i <= invaug::SOCKET_END; ++i)
 				if (GetAugment(i)) {
 					race = GetAugment(i)->GetItemBaneDamageRace();
 					if (race)
@@ -1211,7 +1211,7 @@ int EQEmu::ItemInstance::GetItemBaneDamageBody(bodyType against, bool augments)
 			damage += item->BaneDmgAmt;
 
 		if (augments) {
-			for (int i = inventory::socketBegin; i < inventory::SocketCount; ++i)
+			for (int i = invaug::SOCKET_BEGIN; i <= invaug::SOCKET_END; ++i)
 				if (GetAugment(i))
 					damage += GetAugment(i)->GetItemBaneDamageBody(against);
 		}
@@ -1228,7 +1228,7 @@ int EQEmu::ItemInstance::GetItemBaneDamageRace(uint16 against, bool augments) co
 			damage += item->BaneDmgRaceAmt;
 
 		if (augments) {
-			for (int i = inventory::socketBegin; i < inventory::SocketCount; ++i)
+			for (int i = invaug::SOCKET_BEGIN; i <= invaug::SOCKET_END; ++i)
 				if (GetAugment(i))
 					damage += GetAugment(i)->GetItemBaneDamageRace(against);
 		}
@@ -1244,7 +1244,7 @@ int EQEmu::ItemInstance::GetItemMagical(bool augments) const
 			return 1;
 
 		if (augments) {
-			for (int i = inventory::socketBegin; i < inventory::SocketCount; ++i)
+			for (int i = invaug::SOCKET_BEGIN; i <= invaug::SOCKET_END; ++i)
 				if (GetAugment(i) && GetAugment(i)->GetItemMagical())
 					return 1;
 		}
@@ -1259,7 +1259,7 @@ int EQEmu::ItemInstance::GetItemHP(bool augments) const
 	if (item) {
 		hp = item->HP;
 		if (augments)
-			for (int i = inventory::socketBegin; i < inventory::SocketCount; ++i)
+			for (int i = invaug::SOCKET_BEGIN; i <= invaug::SOCKET_END; ++i)
 				if (GetAugment(i))
 					hp += GetAugment(i)->GetItemHP();
 	}
@@ -1273,7 +1273,7 @@ int EQEmu::ItemInstance::GetItemMana(bool augments) const
 	if (item) {
 		mana = item->Mana;
 		if (augments)
-			for (int i = inventory::socketBegin; i < inventory::SocketCount; ++i)
+			for (int i = invaug::SOCKET_BEGIN; i <= invaug::SOCKET_END; ++i)
 				if (GetAugment(i))
 					mana += GetAugment(i)->GetItemMana();
 	}
@@ -1287,7 +1287,7 @@ int EQEmu::ItemInstance::GetItemEndur(bool augments) const
 	if (item) {
 		endur = item->Endur;
 		if (augments)
-			for (int i = inventory::socketBegin; i < inventory::SocketCount; ++i)
+			for (int i = invaug::SOCKET_BEGIN; i <= invaug::SOCKET_END; ++i)
 				if (GetAugment(i))
 					endur += GetAugment(i)->GetItemEndur();
 	}
@@ -1301,7 +1301,7 @@ int EQEmu::ItemInstance::GetItemAttack(bool augments) const
 	if (item) {
 		atk = item->Attack;
 		if (augments)
-			for (int i = inventory::socketBegin; i < inventory::SocketCount; ++i)
+			for (int i = invaug::SOCKET_BEGIN; i <= invaug::SOCKET_END; ++i)
 				if (GetAugment(i))
 					atk += GetAugment(i)->GetItemAttack();
 	}
@@ -1315,7 +1315,7 @@ int EQEmu::ItemInstance::GetItemStr(bool augments) const
 	if (item) {
 		str = item->AStr;
 		if (augments)
-			for (int i = inventory::socketBegin; i < inventory::SocketCount; ++i)
+			for (int i = invaug::SOCKET_BEGIN; i <= invaug::SOCKET_END; ++i)
 				if (GetAugment(i))
 					str += GetAugment(i)->GetItemStr();
 	}
@@ -1329,7 +1329,7 @@ int EQEmu::ItemInstance::GetItemSta(bool augments) const
 	if (item) {
 		sta = item->ASta;
 		if (augments)
-			for (int i = inventory::socketBegin; i < inventory::SocketCount; ++i)
+			for (int i = invaug::SOCKET_BEGIN; i <= invaug::SOCKET_END; ++i)
 				if (GetAugment(i))
 					sta += GetAugment(i)->GetItemSta();
 	}
@@ -1343,7 +1343,7 @@ int EQEmu::ItemInstance::GetItemDex(bool augments) const
 	if (item) {
 		total = item->ADex;
 		if (augments)
-			for (int i = inventory::socketBegin; i < inventory::SocketCount; ++i)
+			for (int i = invaug::SOCKET_BEGIN; i <= invaug::SOCKET_END; ++i)
 				if (GetAugment(i))
 					total += GetAugment(i)->GetItemDex();
 	}
@@ -1357,7 +1357,7 @@ int EQEmu::ItemInstance::GetItemAgi(bool augments) const
 	if (item) {
 		total = item->AAgi;
 		if (augments)
-			for (int i = inventory::socketBegin; i < inventory::SocketCount; ++i)
+			for (int i = invaug::SOCKET_BEGIN; i <= invaug::SOCKET_END; ++i)
 				if (GetAugment(i))
 					total += GetAugment(i)->GetItemAgi();
 	}
@@ -1371,7 +1371,7 @@ int EQEmu::ItemInstance::GetItemInt(bool augments) const
 	if (item) {
 		total = item->AInt;
 		if (augments)
-			for (int i = inventory::socketBegin; i < inventory::SocketCount; ++i)
+			for (int i = invaug::SOCKET_BEGIN; i <= invaug::SOCKET_END; ++i)
 				if (GetAugment(i))
 					total += GetAugment(i)->GetItemInt();
 	}
@@ -1385,7 +1385,7 @@ int EQEmu::ItemInstance::GetItemWis(bool augments) const
 	if (item) {
 		total = item->AWis;
 		if (augments)
-			for (int i = inventory::socketBegin; i < inventory::SocketCount; ++i)
+			for (int i = invaug::SOCKET_BEGIN; i <= invaug::SOCKET_END; ++i)
 				if (GetAugment(i))
 					total += GetAugment(i)->GetItemWis();
 	}
@@ -1399,7 +1399,7 @@ int EQEmu::ItemInstance::GetItemCha(bool augments) const
 	if (item) {
 		total = item->ACha;
 		if (augments)
-			for (int i = inventory::socketBegin; i < inventory::SocketCount; ++i)
+			for (int i = invaug::SOCKET_BEGIN; i <= invaug::SOCKET_END; ++i)
 				if (GetAugment(i))
 					total += GetAugment(i)->GetItemCha();
 	}
@@ -1413,7 +1413,7 @@ int EQEmu::ItemInstance::GetItemMR(bool augments) const
 	if (item) {
 		total = item->MR;
 		if (augments)
-			for (int i = inventory::socketBegin; i < inventory::SocketCount; ++i)
+			for (int i = invaug::SOCKET_BEGIN; i <= invaug::SOCKET_END; ++i)
 				if (GetAugment(i))
 					total += GetAugment(i)->GetItemMR();
 	}
@@ -1427,7 +1427,7 @@ int EQEmu::ItemInstance::GetItemFR(bool augments) const
 	if (item) {
 		total = item->FR;
 		if (augments)
-			for (int i = inventory::socketBegin; i < inventory::SocketCount; ++i)
+			for (int i = invaug::SOCKET_BEGIN; i <= invaug::SOCKET_END; ++i)
 				if (GetAugment(i))
 					total += GetAugment(i)->GetItemFR();
 	}
@@ -1441,7 +1441,7 @@ int EQEmu::ItemInstance::GetItemCR(bool augments) const
 	if (item) {
 		total = item->CR;
 		if (augments)
-			for (int i = inventory::socketBegin; i < inventory::SocketCount; ++i)
+			for (int i = invaug::SOCKET_BEGIN; i <= invaug::SOCKET_END; ++i)
 				if (GetAugment(i))
 					total += GetAugment(i)->GetItemCR();
 	}
@@ -1455,7 +1455,7 @@ int EQEmu::ItemInstance::GetItemPR(bool augments) const
 	if (item) {
 		total = item->PR;
 		if (augments)
-			for (int i = inventory::socketBegin; i < inventory::SocketCount; ++i)
+			for (int i = invaug::SOCKET_BEGIN; i <= invaug::SOCKET_END; ++i)
 				if (GetAugment(i))
 					total += GetAugment(i)->GetItemPR();
 	}
@@ -1469,7 +1469,7 @@ int EQEmu::ItemInstance::GetItemDR(bool augments) const
 	if (item) {
 		total = item->DR;
 		if (augments)
-			for (int i = inventory::socketBegin; i < inventory::SocketCount; ++i)
+			for (int i = invaug::SOCKET_BEGIN; i <= invaug::SOCKET_END; ++i)
 				if (GetAugment(i))
 					total += GetAugment(i)->GetItemDR();
 	}
@@ -1483,7 +1483,7 @@ int EQEmu::ItemInstance::GetItemCorrup(bool augments) const
 	if (item) {
 		total = item->SVCorruption;
 		if (augments)
-			for (int i = inventory::socketBegin; i < inventory::SocketCount; ++i)
+			for (int i = invaug::SOCKET_BEGIN; i <= invaug::SOCKET_END; ++i)
 				if (GetAugment(i))
 					total += GetAugment(i)->GetItemCorrup();
 	}
@@ -1497,7 +1497,7 @@ int EQEmu::ItemInstance::GetItemHeroicStr(bool augments) const
 	if (item) {
 		total = item->HeroicStr;
 		if (augments)
-			for (int i = inventory::socketBegin; i < inventory::SocketCount; ++i)
+			for (int i = invaug::SOCKET_BEGIN; i <= invaug::SOCKET_END; ++i)
 				if (GetAugment(i))
 					total += GetAugment(i)->GetItemHeroicStr();
 	}
@@ -1511,7 +1511,7 @@ int EQEmu::ItemInstance::GetItemHeroicSta(bool augments) const
 	if (item) {
 		total = item->HeroicSta;
 		if (augments)
-			for (int i = inventory::socketBegin; i < inventory::SocketCount; ++i)
+			for (int i = invaug::SOCKET_BEGIN; i <= invaug::SOCKET_END; ++i)
 				if (GetAugment(i))
 					total += GetAugment(i)->GetItemHeroicSta();
 	}
@@ -1525,7 +1525,7 @@ int EQEmu::ItemInstance::GetItemHeroicDex(bool augments) const
 	if (item) {
 		total = item->HeroicDex;
 		if (augments)
-			for (int i = inventory::socketBegin; i < inventory::SocketCount; ++i)
+			for (int i = invaug::SOCKET_BEGIN; i <= invaug::SOCKET_END; ++i)
 				if (GetAugment(i))
 					total += GetAugment(i)->GetItemHeroicDex();
 	}
@@ -1539,7 +1539,7 @@ int EQEmu::ItemInstance::GetItemHeroicAgi(bool augments) const
 	if (item) {
 		total = item->HeroicAgi;
 		if (augments)
-			for (int i = inventory::socketBegin; i < inventory::SocketCount; ++i)
+			for (int i = invaug::SOCKET_BEGIN; i <= invaug::SOCKET_END; ++i)
 				if (GetAugment(i))
 					total += GetAugment(i)->GetItemHeroicAgi();
 	}
@@ -1553,7 +1553,7 @@ int EQEmu::ItemInstance::GetItemHeroicInt(bool augments) const
 	if (item) {
 		total = item->HeroicInt;
 		if (augments)
-			for (int i = inventory::socketBegin; i < inventory::SocketCount; ++i)
+			for (int i = invaug::SOCKET_BEGIN; i <= invaug::SOCKET_END; ++i)
 				if (GetAugment(i))
 					total += GetAugment(i)->GetItemHeroicInt();
 	}
@@ -1567,7 +1567,7 @@ int EQEmu::ItemInstance::GetItemHeroicWis(bool augments) const
 	if (item) {
 		total = item->HeroicWis;
 		if (augments)
-			for (int i = inventory::socketBegin; i < inventory::SocketCount; ++i)
+			for (int i = invaug::SOCKET_BEGIN; i <= invaug::SOCKET_END; ++i)
 				if (GetAugment(i))
 					total += GetAugment(i)->GetItemHeroicWis();
 	}
@@ -1581,7 +1581,7 @@ int EQEmu::ItemInstance::GetItemHeroicCha(bool augments) const
 	if (item) {
 		total = item->HeroicCha;
 		if (augments)
-			for (int i = inventory::socketBegin; i < inventory::SocketCount; ++i)
+			for (int i = invaug::SOCKET_BEGIN; i <= invaug::SOCKET_END; ++i)
 				if (GetAugment(i))
 					total += GetAugment(i)->GetItemHeroicCha();
 	}
@@ -1595,7 +1595,7 @@ int EQEmu::ItemInstance::GetItemHeroicMR(bool augments) const
 	if (item) {
 		total = item->HeroicMR;
 		if (augments)
-			for (int i = inventory::socketBegin; i < inventory::SocketCount; ++i)
+			for (int i = invaug::SOCKET_BEGIN; i <= invaug::SOCKET_END; ++i)
 				if (GetAugment(i))
 					total += GetAugment(i)->GetItemHeroicMR();
 	}
@@ -1609,7 +1609,7 @@ int EQEmu::ItemInstance::GetItemHeroicFR(bool augments) const
 	if (item) {
 		total = item->HeroicFR;
 		if (augments)
-			for (int i = inventory::socketBegin; i < inventory::SocketCount; ++i)
+			for (int i = invaug::SOCKET_BEGIN; i <= invaug::SOCKET_END; ++i)
 				if (GetAugment(i))
 					total += GetAugment(i)->GetItemHeroicFR();
 	}
@@ -1623,7 +1623,7 @@ int EQEmu::ItemInstance::GetItemHeroicCR(bool augments) const
 	if (item) {
 		total = item->HeroicCR;
 		if (augments)
-			for (int i = inventory::socketBegin; i < inventory::SocketCount; ++i)
+			for (int i = invaug::SOCKET_BEGIN; i <= invaug::SOCKET_END; ++i)
 				if (GetAugment(i))
 					total += GetAugment(i)->GetItemHeroicCR();
 	}
@@ -1637,7 +1637,7 @@ int EQEmu::ItemInstance::GetItemHeroicPR(bool augments) const
 	if (item) {
 		total = item->HeroicPR;
 		if (augments)
-			for (int i = inventory::socketBegin; i < inventory::SocketCount; ++i)
+			for (int i = invaug::SOCKET_BEGIN; i <= invaug::SOCKET_END; ++i)
 				if (GetAugment(i))
 					total += GetAugment(i)->GetItemHeroicPR();
 	}
@@ -1651,7 +1651,7 @@ int EQEmu::ItemInstance::GetItemHeroicDR(bool augments) const
 	if (item) {
 		total = item->HeroicDR;
 		if (augments)
-			for (int i = inventory::socketBegin; i < inventory::SocketCount; ++i)
+			for (int i = invaug::SOCKET_BEGIN; i <= invaug::SOCKET_END; ++i)
 				if (GetAugment(i))
 					total += GetAugment(i)->GetItemHeroicDR();
 	}
@@ -1665,7 +1665,7 @@ int EQEmu::ItemInstance::GetItemHeroicCorrup(bool augments) const
 	if (item) {
 		total = item->HeroicSVCorrup;
 		if (augments)
-			for (int i = inventory::socketBegin; i < inventory::SocketCount; ++i)
+			for (int i = invaug::SOCKET_BEGIN; i <= invaug::SOCKET_END; ++i)
 				if (GetAugment(i))
 					total += GetAugment(i)->GetItemHeroicCorrup();
 	}
@@ -1679,7 +1679,7 @@ int EQEmu::ItemInstance::GetItemHaste(bool augments) const
 	if (item) {
 		total = item->Haste;
 		if (augments)
-			for (int i = inventory::socketBegin; i < inventory::SocketCount; ++i)
+			for (int i = invaug::SOCKET_BEGIN; i <= invaug::SOCKET_END; ++i)
 				if (GetAugment(i)) {
 					int temp = GetAugment(i)->GetItemHaste();
 					if (temp > total)

common/misc_functions.cpp

@@ -275,7 +275,7 @@ float EQHtoFloat(int d)
 }
 
 // returns a swapped-bit value for use in client translator and inventory functions
-uint32 SwapBits21and22(uint32 mask)
+uint32 SwapBits21And22(uint32 mask)
 {
 	static const uint32 BIT21 = 1 << 21;
 	static const uint32 BIT22 = 1 << 22;

common/misc_functions.h

@@ -69,7 +69,7 @@ int FloatToEQSpeedRun(float d);
 // brings heading back into EQ angles range
 float FixHeading(float in);
 
-uint32 SwapBits21and22(uint32 mask);
+uint32 SwapBits21And22(uint32 mask);
 uint32 Catch22(uint32 mask);
 
 // macro to catch fp errors (provided by noudness)

common/mysql_request_result.h

@@ -6,6 +6,7 @@
 	#include <windows.h>
 #endif
 
+#include <string>
 #include <mysql.h>
 #include "types.h"
 #include "mysql_request_row.h"

common/net/console_server_connection.cpp

@@ -1,9 +1,9 @@
 #include "console_server.h"
-#include "../common/util/uuid.h"
-#include "../common/net/packet.h"
-#include "../common/eqemu_logsys.h"
-#include "../common/servertalk.h"
-#include "../common/rulesys.h"
+#include "../util/uuid.h"
+#include "../net/packet.h"
+#include "../eqemu_logsys.h"
+#include "../servertalk.h"
+#include "../rulesys.h"
 
 EQ::Net::ConsoleServerConnection::ConsoleServerConnection(ConsoleServer *parent, std::shared_ptr<TCPConnection> connection)
 {

common/net/daybreak_connection.cpp

@@ -747,7 +747,7 @@ void EQ::Net::DaybreakConnection::ProcessDecodedPacket(const Packet &p)
 				response.zero = 0;
 				response.opcode = OP_SessionStatResponse;
 				response.timestamp = request.timestamp;
-				response.our_timestamp = EQ::Net::HostToNetwork(std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count());
+				response.our_timestamp = EQ::Net::HostToNetwork(std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now().time_since_epoch()).count());
 				response.client_sent = request.packets_sent;
 				response.client_recv = request.packets_recv;
 				response.server_sent = EQ::Net::HostToNetwork(m_stats.sent_packets);

common/net/daybreak_connection.h

@@ -68,8 +68,8 @@ namespace EQ
 			SequencePast
 		};
 
-		typedef std::chrono::high_resolution_clock::time_point Timestamp;
-		typedef std::chrono::high_resolution_clock Clock;
+		typedef std::chrono::steady_clock::time_point Timestamp;
+		typedef std::chrono::steady_clock Clock;
 
 		struct DaybreakConnectionStats
 		{
@@ -282,4 +282,4 @@ namespace EQ
 			friend class DaybreakConnection;
 		};
 	}
-}
+}

common/patches/rof.cpp

@@ -1863,120 +1863,6 @@ namespace RoF
 		FINISH_ENCODE();
 	}
 
-	/*
-	ENCODE(OP_OpenNewTasksWindow)
-	{
-	AvailableTaskHeader_Struct*	__emu_AvailableTaskHeader;
-	AvailableTaskData1_Struct* 	__emu_AvailableTaskData1;
-	AvailableTaskData2_Struct* 	__emu_AvailableTaskData2;
-	AvailableTaskTrailer_Struct* 	__emu_AvailableTaskTrailer;
-
-	structs::AvailableTaskHeader_Struct*	__eq_AvailableTaskHeader;
-	structs::AvailableTaskData1_Struct* 	__eq_AvailableTaskData1;
-	structs::AvailableTaskData2_Struct* 	__eq_AvailableTaskData2;
-	structs::AvailableTaskTrailer_Struct* 	__eq_AvailableTaskTrailer;
-
-	EQApplicationPacket *in = *p;
-	*p = nullptr;
-
-	unsigned char *__emu_buffer = in->pBuffer;
-
-	__emu_AvailableTaskHeader = (AvailableTaskHeader_Struct*)__emu_buffer;
-
-	// For each task, SoF has an extra uint32 and what appears to be space for a null terminated string.
-	//
-	in->size = in->size + (__emu_AvailableTaskHeader->TaskCount * 5);
-
-	in->pBuffer = new unsigned char[in->size];
-
-	unsigned char *__eq_buffer = in->pBuffer;
-
-	__eq_AvailableTaskHeader = (structs::AvailableTaskHeader_Struct*)__eq_buffer;
-
-	char *__eq_ptr, *__emu_Ptr;
-
-	// Copy Header
-	//
-	//
-
-	__eq_AvailableTaskHeader->TaskCount = __emu_AvailableTaskHeader->TaskCount;
-	__eq_AvailableTaskHeader->unknown1 = __emu_AvailableTaskHeader->unknown1;
-	__eq_AvailableTaskHeader->TaskGiver = __emu_AvailableTaskHeader->TaskGiver;
-
-	__emu_Ptr = (char *) __emu_AvailableTaskHeader + sizeof(AvailableTaskHeader_Struct);
-	__eq_ptr = (char *) __eq_AvailableTaskHeader + sizeof(structs::AvailableTaskHeader_Struct);
-
-	for(uint32 i=0; i<__emu_AvailableTaskHeader->TaskCount; i++) {
-
-	__emu_AvailableTaskData1 = (AvailableTaskData1_Struct*)__emu_Ptr;
-	__eq_AvailableTaskData1 = (structs::AvailableTaskData1_Struct*)__eq_ptr;
-
-	__eq_AvailableTaskData1->TaskID = __emu_AvailableTaskData1->TaskID;
-	// This next unknown seems to affect the colour of the task title. 0x3f80000 is what I have seen
-	// in RoF packets. Changing it to 0x3f000000 makes the title red.
-	__eq_AvailableTaskData1->unknown1 = 0x3f800000;
-	__eq_AvailableTaskData1->TimeLimit = __emu_AvailableTaskData1->TimeLimit;
-	__eq_AvailableTaskData1->unknown2 = __emu_AvailableTaskData1->unknown2;
-
-	__emu_Ptr += sizeof(AvailableTaskData1_Struct);
-	__eq_ptr += sizeof(structs::AvailableTaskData1_Struct);
-
-	strcpy(__eq_ptr, __emu_Ptr); // Title
-
-	__emu_Ptr += strlen(__emu_Ptr) + 1;
-	__eq_ptr += strlen(__eq_ptr) + 1;
-
-	strcpy(__eq_ptr, __emu_Ptr); // Description
-
-	__emu_Ptr += strlen(__emu_Ptr) + 1;
-	__eq_ptr += strlen(__eq_ptr) + 1;
-
-	__eq_ptr[0] = 0;
-	__eq_ptr += strlen(__eq_ptr) + 1;
-
-	__emu_AvailableTaskData2 = (AvailableTaskData2_Struct*)__emu_Ptr;
-	__eq_AvailableTaskData2 = (structs::AvailableTaskData2_Struct*)__eq_ptr;
-
-	__eq_AvailableTaskData2->unknown1 = __emu_AvailableTaskData2->unknown1;
-	__eq_AvailableTaskData2->unknown2 = __emu_AvailableTaskData2->unknown2;
-	__eq_AvailableTaskData2->unknown3 = __emu_AvailableTaskData2->unknown3;
-	__eq_AvailableTaskData2->unknown4 = __emu_AvailableTaskData2->unknown4;
-
-	__emu_Ptr += sizeof(AvailableTaskData2_Struct);
-	__eq_ptr += sizeof(structs::AvailableTaskData2_Struct);
-
-	strcpy(__eq_ptr, __emu_Ptr); // Unknown string
-
-	__emu_Ptr += strlen(__emu_Ptr) + 1;
-	__eq_ptr += strlen(__eq_ptr) + 1;
-
-	strcpy(__eq_ptr, __emu_Ptr); // Unknown string
-
-	__emu_Ptr += strlen(__emu_Ptr) + 1;
-	__eq_ptr += strlen(__eq_ptr) + 1;
-
-	__emu_AvailableTaskTrailer = (AvailableTaskTrailer_Struct*)__emu_Ptr;
-	__eq_AvailableTaskTrailer = (structs::AvailableTaskTrailer_Struct*)__eq_ptr;
-
-	__eq_AvailableTaskTrailer->ItemCount = __emu_AvailableTaskTrailer->ItemCount;
-	__eq_AvailableTaskTrailer->unknown1 = __emu_AvailableTaskTrailer->unknown1;
-	__eq_AvailableTaskTrailer->unknown2 = __emu_AvailableTaskTrailer->unknown2;
-	__eq_AvailableTaskTrailer->StartZone = __emu_AvailableTaskTrailer->StartZone;
-
-	__emu_Ptr += sizeof(AvailableTaskTrailer_Struct);
-	__eq_ptr += sizeof(structs::AvailableTaskTrailer_Struct);
-
-	strcpy(__eq_ptr, __emu_Ptr); // Unknown string
-
-	__emu_Ptr += strlen(__emu_Ptr) + 1;
-	__eq_ptr += strlen(__eq_ptr) + 1;
-	}
-
-	delete[] __emu_buffer;
-	dest->FastQueuePacket(&in, ack_req);
-	}
-	*/
-
 	ENCODE(OP_PetBuffWindow)
 	{
 		// The format of the RoF packet is identical to the OP_BuffCreate packet.
@@ -2338,12 +2224,12 @@ namespace RoF
 		outapp->WriteUInt8(0);				// Unknown
 		outapp->WriteUInt8(0);				// Unknown
 
-		outapp->WriteUInt32(profile::BandoliersSize);
+		outapp->WriteUInt32(profile::BANDOLIERS_SIZE);
 
 		// Copy bandoliers where server and client indexes converge
-		for (uint32 r = 0; r < EQEmu::legacy::BANDOLIERS_SIZE && r < profile::BandoliersSize; ++r) {
+		for (uint32 r = 0; r < EQEmu::profile::BANDOLIERS_SIZE && r < profile::BANDOLIERS_SIZE; ++r) {
 			outapp->WriteString(emu->bandoliers[r].Name);
-			for (uint32 j = 0; j < profile::BandolierItemCount; ++j) { // Will need adjusting if 'server != client' is ever true
+			for (uint32 j = 0; j < profile::BANDOLIER_ITEM_COUNT; ++j) { // Will need adjusting if 'server != client' is ever true
 				outapp->WriteString(emu->bandoliers[r].Items[j].Name);
 				outapp->WriteUInt32(emu->bandoliers[r].Items[j].ID);
 				if (emu->bandoliers[r].Items[j].Icon) {
@@ -2356,19 +2242,19 @@ namespace RoF
 			}
 		}
 		// Nullify bandoliers where server and client indexes diverge, with a client bias
-		for (uint32 r = EQEmu::legacy::BANDOLIERS_SIZE; r < profile::BandoliersSize; ++r) {
+		for (uint32 r = EQEmu::profile::BANDOLIERS_SIZE; r < profile::BANDOLIERS_SIZE; ++r) {
 			outapp->WriteString("");
-			for (uint32 j = 0; j < profile::BandolierItemCount; ++j) { // Will need adjusting if 'server != client' is ever true
+			for (uint32 j = 0; j < profile::BANDOLIER_ITEM_COUNT; ++j) { // Will need adjusting if 'server != client' is ever true
 				outapp->WriteString("");
 				outapp->WriteUInt32(0);
 				outapp->WriteSInt32(-1);
 			}
 		}
 
-		outapp->WriteUInt32(profile::PotionBeltSize);
+		outapp->WriteUInt32(profile::POTION_BELT_SIZE);
 
 		// Copy potion belt where server and client indexes converge
-		for (uint32 r = 0; r < EQEmu::legacy::POTION_BELT_ITEM_COUNT && r < profile::PotionBeltSize; ++r) {
+		for (uint32 r = 0; r < EQEmu::profile::POTION_BELT_SIZE && r < profile::POTION_BELT_SIZE; ++r) {
 			outapp->WriteString(emu->potionbelt.Items[r].Name);
 			outapp->WriteUInt32(emu->potionbelt.Items[r].ID);
 			if (emu->potionbelt.Items[r].Icon) {
@@ -2380,7 +2266,7 @@ namespace RoF
 			}
 		}
 		// Nullify potion belt where server and client indexes diverge, with a client bias
-		for (uint32 r = EQEmu::legacy::POTION_BELT_ITEM_COUNT; r < profile::PotionBeltSize; ++r) {
+		for (uint32 r = EQEmu::profile::POTION_BELT_SIZE; r < profile::POTION_BELT_SIZE; ++r) {
 			outapp->WriteString("");
 			outapp->WriteUInt32(0);
 			outapp->WriteSInt32(-1);
@@ -2501,9 +2387,9 @@ namespace RoF
 		outapp->WriteUInt8(0);				// Unknown
 		outapp->WriteUInt8(0);				// Unknown
 
-		outapp->WriteUInt32(EQEmu::legacy::TRIBUTE_SIZE);
+		outapp->WriteUInt32(EQEmu::invtype::TRIBUTE_SIZE);
 
-		for (uint32 r = 0; r < EQEmu::legacy::TRIBUTE_SIZE; r++)
+		for (uint32 r = 0; r < EQEmu::invtype::TRIBUTE_SIZE; r++)
 		{
 			outapp->WriteUInt32(emu->tributes[r].tribute);
 			outapp->WriteUInt32(emu->tributes[r].tier);
@@ -2994,7 +2880,7 @@ namespace RoF
 
 		size_t names_length = 0;
 		size_t character_count = 0;
-		for (; character_count < emu->CharCount && character_count < constants::SayLinkBodySize; ++character_count) {
+		for (; character_count < emu->CharCount && character_count < constants::CHARACTER_CREATION_LIMIT; ++character_count) {
 			emu_cse = (CharacterSelectEntry_Struct *)emu_ptr;
 			names_length += strlen(emu_cse->Name);
 			emu_ptr += sizeof(CharacterSelectEntry_Struct);
@@ -3368,13 +3254,16 @@ namespace RoF
 		InBuffer += description_size;
 		InBuffer += sizeof(TaskDescriptionData2_Struct);
 
-		std::string old_message = InBuffer; // start 'Reward' as string
+		uint32 reward_size = strlen(InBuffer) + 1;
+		InBuffer += reward_size;
+
+		std::string old_message = InBuffer; // start item link string
 		std::string new_message;
 		ServerToRoFSayLink(new_message, old_message);
 
 		in->size = sizeof(TaskDescriptionHeader_Struct) + sizeof(TaskDescriptionData1_Struct)+
 			sizeof(TaskDescriptionData2_Struct) + sizeof(TaskDescriptionTrailer_Struct)+
-			title_size + description_size + new_message.length() + 1;
+			title_size + description_size + reward_size + new_message.length() + 1;
 
 		in->pBuffer = new unsigned char[in->size];
 
@@ -4811,7 +4700,7 @@ namespace RoF
 
 		IN(item_id);
 		int r;
-		for (r = EQEmu::inventory::socketBegin; r < EQEmu::inventory::SocketCount; r++) {
+		for (r = EQEmu::invaug::SOCKET_BEGIN; r <= EQEmu::invaug::SOCKET_END; r++) {
 			IN(augments[r]);
 		}
 		IN(link_hash);
@@ -5205,7 +5094,7 @@ namespace RoF
 
 		structs::InventorySlot_Struct slot_id = ServerToRoFSlot(slot_id_in);
 
-		hdr.slot_type = (inst->GetMerchantSlot() ? invtype::InvTypeMerchant : slot_id.Type);
+		hdr.slot_type = (inst->GetMerchantSlot() ? invtype::typeMerchant : slot_id.Type);
 		hdr.main_slot = (inst->GetMerchantSlot() ? inst->GetMerchantSlot() : slot_id.Slot);
 		hdr.sub_slot = (inst->GetMerchantSlot() ? 0xffff : slot_id.SubIndex);
 		hdr.aug_slot = (inst->GetMerchantSlot() ? 0xffff : slot_id.AugIndex);
@@ -5299,7 +5188,7 @@ namespace RoF
 		ibs.nodrop = item->NoDrop;
 		ibs.attune = item->Attuneable;
 		ibs.size = item->Size;
-		ibs.slots = SwapBits21and22(item->Slots);
+		ibs.slots = SwapBits21And22(item->Slots);
 		ibs.price = item->Price;
 		ibs.icon = item->Icon;
 		ibs.unknown1 = 1;
@@ -5393,7 +5282,7 @@ namespace RoF
 		isbs.augdistiller = 65535;
 		isbs.augrestrict = item->AugRestrict;
 
-		for (int index = 0; index < invaug::ItemAugSize; ++index) {
+		for (int index = invaug::SOCKET_BEGIN; index <= invaug::SOCKET_END; ++index) {
 			isbs.augslots[index].type = item->AugSlotType[index];
 			isbs.augslots[index].visible = item->AugSlotVisible[index];
 			isbs.augslots[index].unknown = item->AugSlotUnk2[index];
@@ -5603,18 +5492,18 @@ namespace RoF
 
 		ob.write((const char*)&subitem_count, sizeof(uint32));
 
-		for (uint32 index = EQEmu::inventory::containerBegin; index < EQEmu::inventory::ContainerCount; ++index) {
+		for (uint32 index = EQEmu::invbag::SLOT_BEGIN; index <= EQEmu::invbag::SLOT_END; ++index) {
 			EQEmu::ItemInstance* sub = inst->GetItem(index);
 			if (!sub)
 				continue;
 
 			int SubSlotNumber = INVALID_INDEX;
-			if (slot_id_in >= EQEmu::legacy::GENERAL_BEGIN && slot_id_in <= EQEmu::legacy::GENERAL_END)
-				SubSlotNumber = (((slot_id_in + 3) * EQEmu::inventory::ContainerCount) + index + 1);
-			else if (slot_id_in >= EQEmu::legacy::BANK_BEGIN && slot_id_in <= EQEmu::legacy::BANK_END)
-				SubSlotNumber = (((slot_id_in - EQEmu::legacy::BANK_BEGIN) * EQEmu::inventory::ContainerCount) + EQEmu::legacy::BANK_BAGS_BEGIN + index);
-			else if (slot_id_in >= EQEmu::legacy::SHARED_BANK_BEGIN && slot_id_in <= EQEmu::legacy::SHARED_BANK_END)
-				SubSlotNumber = (((slot_id_in - EQEmu::legacy::SHARED_BANK_BEGIN) * EQEmu::inventory::ContainerCount) + EQEmu::legacy::SHARED_BANK_BAGS_BEGIN + index);
+			if (slot_id_in >= EQEmu::invslot::GENERAL_BEGIN && slot_id_in <= EQEmu::invslot::GENERAL_END)
+				SubSlotNumber = (((slot_id_in + 3) * EQEmu::invbag::SLOT_COUNT) + index + 1);
+			else if (slot_id_in >= EQEmu::invslot::BANK_BEGIN && slot_id_in <= EQEmu::invslot::BANK_END)
+				SubSlotNumber = (((slot_id_in - EQEmu::invslot::BANK_BEGIN) * EQEmu::invbag::SLOT_COUNT) + EQEmu::invbag::BANK_BAGS_BEGIN + index);
+			else if (slot_id_in >= EQEmu::invslot::SHARED_BANK_BEGIN && slot_id_in <= EQEmu::invslot::SHARED_BANK_END)
+				SubSlotNumber = (((slot_id_in - EQEmu::invslot::SHARED_BANK_BEGIN) * EQEmu::invbag::SLOT_COUNT) + EQEmu::invbag::SHARED_BANK_BAGS_BEGIN + index);
 			else
 				SubSlotNumber = slot_id_in;
 
@@ -5640,17 +5529,17 @@ namespace RoF
 
 		uint32 TempSlot = 0;
 
-		if (serverSlot < 56 || serverSlot == EQEmu::inventory::slotPowerSource) { // Main Inventory and Cursor
-			RoFSlot.Type = invtype::InvTypePossessions;
+		if (serverSlot < 56 || serverSlot == EQEmu::invslot::SLOT_POWER_SOURCE) { // Main Inventory and Cursor
+			RoFSlot.Type = invtype::typePossessions;
 			RoFSlot.Slot = serverSlot;
 
-			if (serverSlot == EQEmu::inventory::slotPowerSource)
-				RoFSlot.Slot = invslot::PossessionsPowerSource;
+			if (serverSlot == EQEmu::invslot::SLOT_POWER_SOURCE)
+				RoFSlot.Slot = invslot::slotPowerSource;
 
-			else if (serverSlot >= EQEmu::inventory::slotCursor) // Cursor and Extended Corpse Inventory
+			else if (serverSlot >= EQEmu::invslot::slotCursor) // Cursor and Extended Corpse Inventory
 				RoFSlot.Slot += 3;
 
-			else if (serverSlot >= EQEmu::inventory::slotAmmo) // (> 20)
+			else if (serverSlot >= EQEmu::invslot::slotAmmo) // (> 20)
 				RoFSlot.Slot += 1;
 		}
 
@@ -5659,51 +5548,51 @@ namespace RoF
 		RoFSlot.MainSlot = ServerSlot - 31;
 		}*/
 
-		else if (serverSlot >= EQEmu::legacy::GENERAL_BAGS_BEGIN && serverSlot <= EQEmu::legacy::CURSOR_BAG_END) { // (> 250 && < 341)
-			RoFSlot.Type = invtype::InvTypePossessions;
+		else if (serverSlot >= EQEmu::invbag::GENERAL_BAGS_BEGIN && serverSlot <= EQEmu::invbag::CURSOR_BAG_END) { // (> 250 && < 341)
+			RoFSlot.Type = invtype::typePossessions;
 			TempSlot = serverSlot - 1;
-			RoFSlot.Slot = int(TempSlot / EQEmu::inventory::ContainerCount) - 2;
-			RoFSlot.SubIndex = TempSlot - ((RoFSlot.Slot + 2) * EQEmu::inventory::ContainerCount);
+			RoFSlot.Slot = int(TempSlot / EQEmu::invbag::SLOT_COUNT) - 2;
+			RoFSlot.SubIndex = TempSlot - ((RoFSlot.Slot + 2) * EQEmu::invbag::SLOT_COUNT);
 
-			if (RoFSlot.Slot >= invslot::PossessionsGeneral9) // (> 30)
-				RoFSlot.Slot = invslot::PossessionsCursor;
+			if (RoFSlot.Slot >= invslot::slotGeneral9) // (> 30)
+				RoFSlot.Slot = invslot::slotCursor;
 		}
 
-		else if (serverSlot >= EQEmu::legacy::TRIBUTE_BEGIN && serverSlot <= EQEmu::legacy::TRIBUTE_END) { // Tribute
-			RoFSlot.Type = invtype::InvTypeTribute;
-			RoFSlot.Slot = serverSlot - EQEmu::legacy::TRIBUTE_BEGIN;
+		else if (serverSlot >= EQEmu::invslot::TRIBUTE_BEGIN && serverSlot <= EQEmu::invslot::TRIBUTE_END) { // Tribute
+			RoFSlot.Type = invtype::typeTribute;
+			RoFSlot.Slot = serverSlot - EQEmu::invslot::TRIBUTE_BEGIN;
 		}
 
-		else if (serverSlot >= EQEmu::legacy::BANK_BEGIN && serverSlot <= EQEmu::legacy::BANK_BAGS_END) {
-			RoFSlot.Type = invtype::InvTypeBank;
-			TempSlot = serverSlot - EQEmu::legacy::BANK_BEGIN;
+		else if (serverSlot >= EQEmu::invslot::BANK_BEGIN && serverSlot <= EQEmu::invbag::BANK_BAGS_END) {
+			RoFSlot.Type = invtype::typeBank;
+			TempSlot = serverSlot - EQEmu::invslot::BANK_BEGIN;
 			RoFSlot.Slot = TempSlot;
 
 			if (TempSlot > 30) { // (> 30)
-				RoFSlot.Slot = int(TempSlot / EQEmu::inventory::ContainerCount) - 3;
-				RoFSlot.SubIndex = TempSlot - ((RoFSlot.Slot + 3) * EQEmu::inventory::ContainerCount);
+				RoFSlot.Slot = int(TempSlot / EQEmu::invbag::SLOT_COUNT) - 3;
+				RoFSlot.SubIndex = TempSlot - ((RoFSlot.Slot + 3) * EQEmu::invbag::SLOT_COUNT);
 			}
 		}
 
-		else if (serverSlot >= EQEmu::legacy::SHARED_BANK_BEGIN && serverSlot <= EQEmu::legacy::SHARED_BANK_BAGS_END) {
-			RoFSlot.Type = invtype::InvTypeSharedBank;
-			TempSlot = serverSlot - EQEmu::legacy::SHARED_BANK_BEGIN;
+		else if (serverSlot >= EQEmu::invslot::SHARED_BANK_BEGIN && serverSlot <= EQEmu::invbag::SHARED_BANK_BAGS_END) {
+			RoFSlot.Type = invtype::typeSharedBank;
+			TempSlot = serverSlot - EQEmu::invslot::SHARED_BANK_BEGIN;
 			RoFSlot.Slot = TempSlot;
 
 			if (TempSlot > 30) { // (> 30)
-				RoFSlot.Slot = int(TempSlot / EQEmu::inventory::ContainerCount) - 3;
-				RoFSlot.SubIndex = TempSlot - ((RoFSlot.Slot + 3) * EQEmu::inventory::ContainerCount);
+				RoFSlot.Slot = int(TempSlot / EQEmu::invbag::SLOT_COUNT) - 3;
+				RoFSlot.SubIndex = TempSlot - ((RoFSlot.Slot + 3) * EQEmu::invbag::SLOT_COUNT);
 			}
 		}
 
-		else if (serverSlot >= EQEmu::legacy::TRADE_BEGIN && serverSlot <= EQEmu::legacy::TRADE_BAGS_END) {
-			RoFSlot.Type = invtype::InvTypeTrade;
-			TempSlot = serverSlot - EQEmu::legacy::TRADE_BEGIN;
+		else if (serverSlot >= EQEmu::invslot::TRADE_BEGIN && serverSlot <= EQEmu::invbag::TRADE_BAGS_END) {
+			RoFSlot.Type = invtype::typeTrade;
+			TempSlot = serverSlot - EQEmu::invslot::TRADE_BEGIN;
 			RoFSlot.Slot = TempSlot;
 
 			if (TempSlot > 30) {
-				RoFSlot.Slot = int(TempSlot / EQEmu::inventory::ContainerCount) - 3;
-				RoFSlot.SubIndex = TempSlot - ((RoFSlot.Slot + 3) * EQEmu::inventory::ContainerCount);
+				RoFSlot.Slot = int(TempSlot / EQEmu::invbag::SLOT_COUNT) - 3;
+				RoFSlot.SubIndex = TempSlot - ((RoFSlot.Slot + 3) * EQEmu::invbag::SLOT_COUNT);
 			}
 
 			/*
@@ -5720,9 +5609,9 @@ namespace RoF
 			*/
 		}
 
-		else if (serverSlot >= EQEmu::legacy::WORLD_BEGIN && serverSlot <= EQEmu::legacy::WORLD_END) {
-			RoFSlot.Type = invtype::InvTypeWorld;
-			TempSlot = serverSlot - EQEmu::legacy::WORLD_BEGIN;
+		else if (serverSlot >= EQEmu::invslot::WORLD_BEGIN && serverSlot <= EQEmu::invslot::WORLD_END) {
+			RoFSlot.Type = invtype::typeWorld;
+			TempSlot = serverSlot - EQEmu::invslot::WORLD_BEGIN;
 			RoFSlot.Slot = TempSlot;
 		}
 
@@ -5741,16 +5630,16 @@ namespace RoF
 
 		uint32 TempSlot = 0;
 
-		if (serverSlot < 56 || serverSlot == EQEmu::inventory::slotPowerSource) { // (< 52)
+		if (serverSlot < 56 || serverSlot == EQEmu::invslot::SLOT_POWER_SOURCE) { // (< 52)
 			RoFSlot.Slot = serverSlot;
 
-			if (serverSlot == EQEmu::inventory::slotPowerSource)
-				RoFSlot.Slot = invslot::PossessionsPowerSource;
+			if (serverSlot == EQEmu::invslot::SLOT_POWER_SOURCE)
+				RoFSlot.Slot = invslot::slotPowerSource;
 
-			else if (serverSlot >= EQEmu::inventory::slotCursor) // Cursor and Extended Corpse Inventory
+			else if (serverSlot >= EQEmu::invslot::slotCursor) // Cursor and Extended Corpse Inventory
 				RoFSlot.Slot += 3;
 
-			else if (serverSlot >= EQEmu::inventory::slotAmmo) // Ammo and Personl Inventory
+			else if (serverSlot >= EQEmu::invslot::slotAmmo) // Ammo and Personl Inventory
 				RoFSlot.Slot += 1;
 
 			/*else if (ServerSlot >= MainCursor) { // Cursor
@@ -5761,10 +5650,10 @@ namespace RoF
 			}*/
 		}
 
-		else if (serverSlot >= EQEmu::legacy::GENERAL_BAGS_BEGIN && serverSlot <= EQEmu::legacy::CURSOR_BAG_END) {
+		else if (serverSlot >= EQEmu::invbag::GENERAL_BAGS_BEGIN && serverSlot <= EQEmu::invbag::CURSOR_BAG_END) {
 			TempSlot = serverSlot - 1;
-			RoFSlot.Slot = int(TempSlot / EQEmu::inventory::ContainerCount) - 2;
-			RoFSlot.SubIndex = TempSlot - ((RoFSlot.Slot + 2) * EQEmu::inventory::ContainerCount);
+			RoFSlot.Slot = int(TempSlot / EQEmu::invbag::SLOT_COUNT) - 2;
+			RoFSlot.SubIndex = TempSlot - ((RoFSlot.Slot + 2) * EQEmu::invbag::SLOT_COUNT);
 		}
 
 		Log(Logs::General, Logs::Netcode, "[ERROR] Convert Server Slot %i to RoF Slots: Main %i, Sub %i, Aug %i, Unk1 %i", serverSlot, RoFSlot.Slot, RoFSlot.SubIndex, RoFSlot.AugIndex, RoFSlot.Unknown01);
@@ -5782,11 +5671,11 @@ namespace RoF
 		uint32 ServerSlot = INVALID_INDEX;
 		uint32 TempSlot = 0;
 
-		if (rofSlot.Type == invtype::InvTypePossessions && rofSlot.Slot < 57) { // Worn/Personal Inventory and Cursor (< 51)
-			if (rofSlot.Slot == invslot::PossessionsPowerSource)
-				TempSlot = EQEmu::inventory::slotPowerSource;
+		if (rofSlot.Type == invtype::typePossessions && rofSlot.Slot < 57) { // Worn/Personal Inventory and Cursor (< 51)
+			if (rofSlot.Slot == invslot::slotPowerSource)
+				TempSlot = EQEmu::invslot::SLOT_POWER_SOURCE;
 
-			else if (rofSlot.Slot >= invslot::PossessionsCursor) // Cursor and Extended Corpse Inventory
+			else if (rofSlot.Slot >= invslot::slotCursor) // Cursor and Extended Corpse Inventory
 				TempSlot = rofSlot.Slot - 3;
 
 			/*else if (RoFSlot.MainSlot == slots::MainGeneral9 || RoFSlot.MainSlot == slots::MainGeneral10) { // 9th and 10th RoF inventory/corpse slots
@@ -5800,23 +5689,23 @@ namespace RoF
 			// For now, it's probably best to leave as-is and let this work itself out in the inventory rework.
 			}*/
 
-			else if (rofSlot.Slot >= invslot::PossessionsAmmo) // Ammo and Main Inventory
+			else if (rofSlot.Slot >= invslot::slotAmmo) // Ammo and Main Inventory
 				TempSlot = rofSlot.Slot - 1;
 
 			else // Worn Slots
 				TempSlot = rofSlot.Slot;
 
-			if (rofSlot.SubIndex >= EQEmu::inventory::containerBegin) // Bag Slots
-				TempSlot = ((TempSlot + 3) * EQEmu::inventory::ContainerCount) + rofSlot.SubIndex + 1;
+			if (rofSlot.SubIndex >= EQEmu::invbag::SLOT_BEGIN) // Bag Slots
+				TempSlot = ((TempSlot + 3) * EQEmu::invbag::SLOT_COUNT) + rofSlot.SubIndex + 1;
 
 			ServerSlot = TempSlot;
 		}
 
-		else if (rofSlot.Type == invtype::InvTypeBank) {
-			TempSlot = EQEmu::legacy::BANK_BEGIN;
+		else if (rofSlot.Type == invtype::typeBank) {
+			TempSlot = EQEmu::invslot::BANK_BEGIN;
 
-			if (rofSlot.SubIndex >= EQEmu::inventory::containerBegin)
-				TempSlot += ((rofSlot.Slot + 3) * EQEmu::inventory::ContainerCount) + rofSlot.SubIndex + 1;
+			if (rofSlot.SubIndex >= EQEmu::invbag::SLOT_BEGIN)
+				TempSlot += ((rofSlot.Slot + 3) * EQEmu::invbag::SLOT_COUNT) + rofSlot.SubIndex + 1;
 
 			else
 				TempSlot += rofSlot.Slot;
@@ -5824,11 +5713,11 @@ namespace RoF
 			ServerSlot = TempSlot;
 		}
 
-		else if (rofSlot.Type == invtype::InvTypeSharedBank) {
-			TempSlot = EQEmu::legacy::SHARED_BANK_BEGIN;
+		else if (rofSlot.Type == invtype::typeSharedBank) {
+			TempSlot = EQEmu::invslot::SHARED_BANK_BEGIN;
 
-			if (rofSlot.SubIndex >= EQEmu::inventory::containerBegin)
-				TempSlot += ((rofSlot.Slot + 3) * EQEmu::inventory::ContainerCount) + rofSlot.SubIndex + 1;
+			if (rofSlot.SubIndex >= EQEmu::invbag::SLOT_BEGIN)
+				TempSlot += ((rofSlot.Slot + 3) * EQEmu::invbag::SLOT_COUNT) + rofSlot.SubIndex + 1;
 
 			else
 				TempSlot += rofSlot.Slot;
@@ -5836,11 +5725,11 @@ namespace RoF
 			ServerSlot = TempSlot;
 		}
 
-		else if (rofSlot.Type == invtype::InvTypeTrade) {
-			TempSlot = EQEmu::legacy::TRADE_BEGIN;
+		else if (rofSlot.Type == invtype::typeTrade) {
+			TempSlot = EQEmu::invslot::TRADE_BEGIN;
 
-			if (rofSlot.SubIndex >= EQEmu::inventory::containerBegin)
-				TempSlot += ((rofSlot.Slot + 3) * EQEmu::inventory::ContainerCount) + rofSlot.SubIndex + 1;
+			if (rofSlot.SubIndex >= EQEmu::invbag::SLOT_BEGIN)
+				TempSlot += ((rofSlot.Slot + 3) * EQEmu::invbag::SLOT_COUNT) + rofSlot.SubIndex + 1;
 			// OLD CODE:
 			//TempSlot += 100 + (RoFSlot.MainSlot * EQEmu::inventory::ContainerCount) + RoFSlot.SubSlot;
 
@@ -5850,10 +5739,10 @@ namespace RoF
 			ServerSlot = TempSlot;
 		}
 
-		else if (rofSlot.Type == invtype::InvTypeWorld) {
-			TempSlot = EQEmu::legacy::WORLD_BEGIN;
+		else if (rofSlot.Type == invtype::typeWorld) {
+			TempSlot = EQEmu::invslot::WORLD_BEGIN;
 
-			if (rofSlot.Slot >= EQEmu::inventory::containerBegin)
+			if (rofSlot.Slot >= EQEmu::invbag::SLOT_BEGIN)
 				TempSlot += rofSlot.Slot;
 
 			ServerSlot = TempSlot;
@@ -5868,7 +5757,7 @@ namespace RoF
 		ServerSlot = TempSlot;
 		}*/
 
-		else if (rofSlot.Type == invtype::InvTypeGuildTribute) {
+		else if (rofSlot.Type == invtype::typeGuildTribute) {
 			ServerSlot = INVALID_INDEX;
 		}
 
@@ -5883,10 +5772,10 @@ namespace RoF
 		uint32 TempSlot = 0;
 
 		if (rofSlot.Slot < 57) { // Worn/Personal Inventory and Cursor (< 33)
-			if (rofSlot.Slot == invslot::PossessionsPowerSource)
-				TempSlot = EQEmu::inventory::slotPowerSource;
+			if (rofSlot.Slot == invslot::slotPowerSource)
+				TempSlot = EQEmu::invslot::SLOT_POWER_SOURCE;
 
-			else if (rofSlot.Slot >= invslot::PossessionsCursor) // Cursor and Extended Corpse Inventory
+			else if (rofSlot.Slot >= invslot::slotCursor) // Cursor and Extended Corpse Inventory
 				TempSlot = rofSlot.Slot - 3;
 
 			/*else if (RoFSlot.MainSlot == slots::MainGeneral9 || RoFSlot.MainSlot == slots::MainGeneral10) { // 9th and 10th RoF inventory slots
@@ -5895,14 +5784,14 @@ namespace RoF
 			// Same as above
 			}*/
 
-			else if (rofSlot.Slot >= invslot::PossessionsAmmo) // Main Inventory and Ammo Slots
+			else if (rofSlot.Slot >= invslot::slotAmmo) // Main Inventory and Ammo Slots
 				TempSlot = rofSlot.Slot - 1;
 
 			else
 				TempSlot = rofSlot.Slot;
 
-			if (rofSlot.SubIndex >= EQEmu::inventory::containerBegin) // Bag Slots
-				TempSlot = ((TempSlot + 3) * EQEmu::inventory::ContainerCount) + rofSlot.SubIndex + 1;
+			if (rofSlot.SubIndex >= EQEmu::invbag::SLOT_BEGIN) // Bag Slots
+				TempSlot = ((TempSlot + 3) * EQEmu::invbag::SLOT_COUNT) + rofSlot.SubIndex + 1;
 
 			ServerSlot = TempSlot;
 		}
@@ -5919,7 +5808,7 @@ namespace RoF
 
 	static inline void ServerToRoFSayLink(std::string& rofSayLink, const std::string& serverSayLink)
 	{
-		if ((constants::SayLinkBodySize == EQEmu::constants::SayLinkBodySize) || (serverSayLink.find('\x12') == std::string::npos)) {
+		if ((constants::SAY_LINK_BODY_SIZE == EQEmu::constants::SAY_LINK_BODY_SIZE) || (serverSayLink.find('\x12') == std::string::npos)) {
 			rofSayLink = serverSayLink;
 			return;
 		}
@@ -5928,7 +5817,7 @@ namespace RoF
 
 		for (size_t segment_iter = 0; segment_iter < segments.size(); ++segment_iter) {
 			if (segment_iter & 1) {
-				if (segments[segment_iter].length() <= EQEmu::constants::SayLinkBodySize) {
+				if (segments[segment_iter].length() <= EQEmu::constants::SAY_LINK_BODY_SIZE) {
 					rofSayLink.append(segments[segment_iter]);
 					// TODO: log size mismatch error
 					continue;
@@ -5958,7 +5847,7 @@ namespace RoF
 
 	static inline void RoFToServerSayLink(std::string& serverSayLink, const std::string& rofSayLink)
 	{
-		if ((EQEmu::constants::SayLinkBodySize == constants::SayLinkBodySize) || (rofSayLink.find('\x12') == std::string::npos)) {
+		if ((EQEmu::constants::SAY_LINK_BODY_SIZE == constants::SAY_LINK_BODY_SIZE) || (rofSayLink.find('\x12') == std::string::npos)) {
 			serverSayLink = rofSayLink;
 			return;
 		}
@@ -5967,7 +5856,7 @@ namespace RoF
 
 		for (size_t segment_iter = 0; segment_iter < segments.size(); ++segment_iter) {
 			if (segment_iter & 1) {
-				if (segments[segment_iter].length() <= constants::SayLinkBodySize) {
+				if (segments[segment_iter].length() <= constants::SAY_LINK_BODY_SIZE) {
 					serverSayLink.append(segments[segment_iter]);
 					// TODO: log size mismatch error
 					continue;

common/patches/rof2.cpp

@@ -1940,120 +1940,6 @@ namespace RoF2
 		FINISH_ENCODE();
 	}
 
-	/*
-	ENCODE(OP_OpenNewTasksWindow)
-	{
-	AvailableTaskHeader_Struct*	__emu_AvailableTaskHeader;
-	AvailableTaskData1_Struct* 	__emu_AvailableTaskData1;
-	AvailableTaskData2_Struct* 	__emu_AvailableTaskData2;
-	AvailableTaskTrailer_Struct* 	__emu_AvailableTaskTrailer;
-
-	structs::AvailableTaskHeader_Struct*	__eq_AvailableTaskHeader;
-	structs::AvailableTaskData1_Struct* 	__eq_AvailableTaskData1;
-	structs::AvailableTaskData2_Struct* 	__eq_AvailableTaskData2;
-	structs::AvailableTaskTrailer_Struct* 	__eq_AvailableTaskTrailer;
-
-	EQApplicationPacket *in = *p;
-	*p = nullptr;
-
-	unsigned char *__emu_buffer = in->pBuffer;
-
-	__emu_AvailableTaskHeader = (AvailableTaskHeader_Struct*)__emu_buffer;
-
-	// For each task, SoF has an extra uint32 and what appears to be space for a null terminated string.
-	//
-	in->size = in->size + (__emu_AvailableTaskHeader->TaskCount * 5);
-
-	in->pBuffer = new unsigned char[in->size];
-
-	unsigned char *__eq_buffer = in->pBuffer;
-
-	__eq_AvailableTaskHeader = (structs::AvailableTaskHeader_Struct*)__eq_buffer;
-
-	char *__eq_ptr, *__emu_Ptr;
-
-	// Copy Header
-	//
-	//
-
-	__eq_AvailableTaskHeader->TaskCount = __emu_AvailableTaskHeader->TaskCount;
-	__eq_AvailableTaskHeader->unknown1 = __emu_AvailableTaskHeader->unknown1;
-	__eq_AvailableTaskHeader->TaskGiver = __emu_AvailableTaskHeader->TaskGiver;
-
-	__emu_Ptr = (char *) __emu_AvailableTaskHeader + sizeof(AvailableTaskHeader_Struct);
-	__eq_ptr = (char *) __eq_AvailableTaskHeader + sizeof(structs::AvailableTaskHeader_Struct);
-
-	for(uint32 i=0; i<__emu_AvailableTaskHeader->TaskCount; i++) {
-
-	__emu_AvailableTaskData1 = (AvailableTaskData1_Struct*)__emu_Ptr;
-	__eq_AvailableTaskData1 = (structs::AvailableTaskData1_Struct*)__eq_ptr;
-
-	__eq_AvailableTaskData1->TaskID = __emu_AvailableTaskData1->TaskID;
-	// This next unknown seems to affect the colour of the task title. 0x3f80000 is what I have seen
-	// in RoF2 packets. Changing it to 0x3f000000 makes the title red.
-	__eq_AvailableTaskData1->unknown1 = 0x3f800000;
-	__eq_AvailableTaskData1->TimeLimit = __emu_AvailableTaskData1->TimeLimit;
-	__eq_AvailableTaskData1->unknown2 = __emu_AvailableTaskData1->unknown2;
-
-	__emu_Ptr += sizeof(AvailableTaskData1_Struct);
-	__eq_ptr += sizeof(structs::AvailableTaskData1_Struct);
-
-	strcpy(__eq_ptr, __emu_Ptr); // Title
-
-	__emu_Ptr += strlen(__emu_Ptr) + 1;
-	__eq_ptr += strlen(__eq_ptr) + 1;
-
-	strcpy(__eq_ptr, __emu_Ptr); // Description
-
-	__emu_Ptr += strlen(__emu_Ptr) + 1;
-	__eq_ptr += strlen(__eq_ptr) + 1;
-
-	__eq_ptr[0] = 0;
-	__eq_ptr += strlen(__eq_ptr) + 1;
-
-	__emu_AvailableTaskData2 = (AvailableTaskData2_Struct*)__emu_Ptr;
-	__eq_AvailableTaskData2 = (structs::AvailableTaskData2_Struct*)__eq_ptr;
-
-	__eq_AvailableTaskData2->unknown1 = __emu_AvailableTaskData2->unknown1;
-	__eq_AvailableTaskData2->unknown2 = __emu_AvailableTaskData2->unknown2;
-	__eq_AvailableTaskData2->unknown3 = __emu_AvailableTaskData2->unknown3;
-	__eq_AvailableTaskData2->unknown4 = __emu_AvailableTaskData2->unknown4;
-
-	__emu_Ptr += sizeof(AvailableTaskData2_Struct);
-	__eq_ptr += sizeof(structs::AvailableTaskData2_Struct);
-
-	strcpy(__eq_ptr, __emu_Ptr); // Unknown string
-
-	__emu_Ptr += strlen(__emu_Ptr) + 1;
-	__eq_ptr += strlen(__eq_ptr) + 1;
-
-	strcpy(__eq_ptr, __emu_Ptr); // Unknown string
-
-	__emu_Ptr += strlen(__emu_Ptr) + 1;
-	__eq_ptr += strlen(__eq_ptr) + 1;
-
-	__emu_AvailableTaskTrailer = (AvailableTaskTrailer_Struct*)__emu_Ptr;
-	__eq_AvailableTaskTrailer = (structs::AvailableTaskTrailer_Struct*)__eq_ptr;
-
-	__eq_AvailableTaskTrailer->ItemCount = __emu_AvailableTaskTrailer->ItemCount;
-	__eq_AvailableTaskTrailer->unknown1 = __emu_AvailableTaskTrailer->unknown1;
-	__eq_AvailableTaskTrailer->unknown2 = __emu_AvailableTaskTrailer->unknown2;
-	__eq_AvailableTaskTrailer->StartZone = __emu_AvailableTaskTrailer->StartZone;
-
-	__emu_Ptr += sizeof(AvailableTaskTrailer_Struct);
-	__eq_ptr += sizeof(structs::AvailableTaskTrailer_Struct);
-
-	strcpy(__eq_ptr, __emu_Ptr); // Unknown string
-
-	__emu_Ptr += strlen(__emu_Ptr) + 1;
-	__eq_ptr += strlen(__eq_ptr) + 1;
-	}
-
-	delete[] __emu_buffer;
-	dest->FastQueuePacket(&in, ack_req);
-	}
-	*/
-
 	ENCODE(OP_PetBuffWindow)
 	{
 		// The format of the RoF2 packet is identical to the OP_BuffCreate packet.
@@ -2415,12 +2301,12 @@ namespace RoF2
 		outapp->WriteUInt8(0);				// Unknown
 		outapp->WriteUInt8(0);				// Unknown
 
-		outapp->WriteUInt32(profile::BandoliersSize);
+		outapp->WriteUInt32(profile::BANDOLIERS_SIZE);
 
 		// Copy bandoliers where server and client indexes converge
-		for (uint32 r = 0; r < EQEmu::legacy::BANDOLIERS_SIZE && r < profile::BandoliersSize; ++r) {
+		for (uint32 r = 0; r < EQEmu::profile::BANDOLIERS_SIZE && r < profile::BANDOLIERS_SIZE; ++r) {
 			outapp->WriteString(emu->bandoliers[r].Name);
-			for (uint32 j = 0; j < profile::BandolierItemCount; ++j) { // Will need adjusting if 'server != client' is ever true
+			for (uint32 j = 0; j < profile::BANDOLIER_ITEM_COUNT; ++j) { // Will need adjusting if 'server != client' is ever true
 				outapp->WriteString(emu->bandoliers[r].Items[j].Name);
 				outapp->WriteUInt32(emu->bandoliers[r].Items[j].ID);
 				if (emu->bandoliers[r].Items[j].Icon) {
@@ -2433,19 +2319,19 @@ namespace RoF2
  			}
  		}
 		// Nullify bandoliers where server and client indexes diverge, with a client bias
-		for (uint32 r = EQEmu::legacy::BANDOLIERS_SIZE; r < profile::BandoliersSize; ++r) {
+		for (uint32 r = EQEmu::profile::BANDOLIERS_SIZE; r < profile::BANDOLIERS_SIZE; ++r) {
  			outapp->WriteString("");
-			for (uint32 j = 0; j < profile::BandolierItemCount; ++j) { // Will need adjusting if 'server != client' is ever true
+			for (uint32 j = 0; j < profile::BANDOLIER_ITEM_COUNT; ++j) { // Will need adjusting if 'server != client' is ever true
  				outapp->WriteString("");
  				outapp->WriteUInt32(0);
  				outapp->WriteSInt32(-1);
  			}
  		}
 
-		outapp->WriteUInt32(profile::PotionBeltSize);
+		outapp->WriteUInt32(profile::POTION_BELT_SIZE);
 
 		// Copy potion belt where server and client indexes converge
-		for (uint32 r = 0; r < EQEmu::legacy::POTION_BELT_ITEM_COUNT && r < profile::PotionBeltSize; ++r) {
+		for (uint32 r = 0; r < EQEmu::profile::POTION_BELT_SIZE && r < profile::POTION_BELT_SIZE; ++r) {
 			outapp->WriteString(emu->potionbelt.Items[r].Name);
 			outapp->WriteUInt32(emu->potionbelt.Items[r].ID);
 			if (emu->potionbelt.Items[r].Icon) {
@@ -2457,7 +2343,7 @@ namespace RoF2
  			}
  		}
 		// Nullify potion belt where server and client indexes diverge, with a client bias
-		for (uint32 r = EQEmu::legacy::POTION_BELT_ITEM_COUNT; r < profile::PotionBeltSize; ++r) {
+		for (uint32 r = EQEmu::profile::POTION_BELT_SIZE; r < profile::POTION_BELT_SIZE; ++r) {
 			outapp->WriteString("");
 			outapp->WriteUInt32(0);
 			outapp->WriteSInt32(-1);
@@ -2574,9 +2460,9 @@ namespace RoF2
 		outapp->WriteUInt8(0);				// Unknown
 		outapp->WriteUInt8(0);				// Unknown
 
-		outapp->WriteUInt32(EQEmu::legacy::TRIBUTE_SIZE);
+		outapp->WriteUInt32(EQEmu::invtype::TRIBUTE_SIZE);
 
-		for (uint32 r = 0; r < EQEmu::legacy::TRIBUTE_SIZE; r++)
+		for (uint32 r = 0; r < EQEmu::invtype::TRIBUTE_SIZE; r++)
 		{
 			outapp->WriteUInt32(emu->tributes[r].tribute);
 			outapp->WriteUInt32(emu->tributes[r].tier);
@@ -3081,7 +2967,7 @@ namespace RoF2
 
 		size_t names_length = 0;
 		size_t character_count = 0;
-		for (; character_count < emu->CharCount && character_count < constants::CharacterCreationLimit; ++character_count) {
+		for (; character_count < emu->CharCount && character_count < constants::CHARACTER_CREATION_LIMIT; ++character_count) {
 			emu_cse = (CharacterSelectEntry_Struct *)emu_ptr;
 			names_length += strlen(emu_cse->Name);
 			emu_ptr += sizeof(CharacterSelectEntry_Struct);
@@ -3437,13 +3323,16 @@ namespace RoF2
 		InBuffer += description_size;
 		InBuffer += sizeof(TaskDescriptionData2_Struct);
 
-		std::string old_message = InBuffer; // start 'Reward' as string
+		uint32 reward_size = strlen(InBuffer) + 1;
+		InBuffer += reward_size;
+
+		std::string old_message = InBuffer; // start item link string
 		std::string new_message;
 		ServerToRoF2SayLink(new_message, old_message);
 
 		in->size = sizeof(TaskDescriptionHeader_Struct) + sizeof(TaskDescriptionData1_Struct)+
 			sizeof(TaskDescriptionData2_Struct) + sizeof(TaskDescriptionTrailer_Struct)+
-			title_size + description_size + new_message.length() + 1;
+			title_size + description_size + reward_size + new_message.length() + 1;
 
 		in->pBuffer = new unsigned char[in->size];
 
@@ -5051,7 +4940,7 @@ namespace RoF2
 
 		IN(item_id);
 		int r;
-		for (r = EQEmu::inventory::socketBegin; r < EQEmu::inventory::SocketCount; r++) {
+		for (r = EQEmu::invaug::SOCKET_BEGIN; r <= EQEmu::invaug::SOCKET_END; r++) {
 			IN(augments[r]);
 		}
 		IN(link_hash);
@@ -5500,7 +5389,7 @@ namespace RoF2
 
 		structs::InventorySlot_Struct slot_id = ServerToRoF2Slot(slot_id_in, packet_type);
 
-		hdr.slot_type = (inst->GetMerchantSlot() ? invtype::InvTypeMerchant : slot_id.Type);
+		hdr.slot_type = (inst->GetMerchantSlot() ? invtype::typeMerchant : slot_id.Type);
 		hdr.main_slot = (inst->GetMerchantSlot() ? inst->GetMerchantSlot() : slot_id.Slot);
 		hdr.sub_slot = (inst->GetMerchantSlot() ? 0xffff : slot_id.SubIndex);
 		hdr.aug_slot = (inst->GetMerchantSlot() ? 0xffff : slot_id.AugIndex);
@@ -5594,7 +5483,7 @@ namespace RoF2
 		ibs.nodrop = item->NoDrop;
 		ibs.attune = item->Attuneable;
 		ibs.size = item->Size;
-		ibs.slots = SwapBits21and22(item->Slots);
+		ibs.slots = SwapBits21And22(item->Slots);
 		ibs.price = item->Price;
 		ibs.icon = item->Icon;
 		ibs.unknown1 = 1;
@@ -5688,7 +5577,7 @@ namespace RoF2
 		isbs.augrestrict2 = -1;
 		isbs.augrestrict = item->AugRestrict;
 
-		for (int index = 0; index < invaug::ItemAugSize; ++index) {
+		for (int index = invaug::SOCKET_BEGIN; index <= invaug::SOCKET_END; ++index) {
 			isbs.augslots[index].type = item->AugSlotType[index];
 			isbs.augslots[index].visible = item->AugSlotVisible[index];
 			isbs.augslots[index].unknown = item->AugSlotUnk2[index];
@@ -5908,18 +5797,18 @@ namespace RoF2
 
 		ob.write((const char*)&subitem_count, sizeof(uint32));
 
-		for (uint32 index = EQEmu::inventory::containerBegin; index < EQEmu::inventory::ContainerCount; ++index) {
+		for (uint32 index = EQEmu::invbag::SLOT_BEGIN; index <= EQEmu::invbag::SLOT_END; ++index) {
 			EQEmu::ItemInstance* sub = inst->GetItem(index);
 			if (!sub)
 				continue;
 
 			int SubSlotNumber = INVALID_INDEX;
-			if (slot_id_in >= EQEmu::legacy::GENERAL_BEGIN && slot_id_in <= EQEmu::legacy::GENERAL_END)
-				SubSlotNumber = (((slot_id_in + 3) * EQEmu::inventory::ContainerCount) + index + 1);
-			else if (slot_id_in >= EQEmu::legacy::BANK_BEGIN && slot_id_in <= EQEmu::legacy::BANK_END)
-				SubSlotNumber = (((slot_id_in - EQEmu::legacy::BANK_BEGIN) * EQEmu::inventory::ContainerCount) + EQEmu::legacy::BANK_BAGS_BEGIN + index);
-			else if (slot_id_in >= EQEmu::legacy::SHARED_BANK_BEGIN && slot_id_in <= EQEmu::legacy::SHARED_BANK_END)
-				SubSlotNumber = (((slot_id_in - EQEmu::legacy::SHARED_BANK_BEGIN) * EQEmu::inventory::ContainerCount) + EQEmu::legacy::SHARED_BANK_BAGS_BEGIN + index);
+			if (slot_id_in >= EQEmu::invslot::GENERAL_BEGIN && slot_id_in <= EQEmu::invslot::GENERAL_END)
+				SubSlotNumber = (((slot_id_in + 3) * EQEmu::invbag::SLOT_COUNT) + index + 1);
+			else if (slot_id_in >= EQEmu::invslot::BANK_BEGIN && slot_id_in <= EQEmu::invslot::BANK_END)
+				SubSlotNumber = (((slot_id_in - EQEmu::invslot::BANK_BEGIN) * EQEmu::invbag::SLOT_COUNT) + EQEmu::invbag::BANK_BAGS_BEGIN + index);
+			else if (slot_id_in >= EQEmu::invslot::SHARED_BANK_BEGIN && slot_id_in <= EQEmu::invslot::SHARED_BANK_END)
+				SubSlotNumber = (((slot_id_in - EQEmu::invslot::SHARED_BANK_BEGIN) * EQEmu::invbag::SLOT_COUNT) + EQEmu::invbag::SHARED_BANK_BAGS_BEGIN + index);
 			else
 				SubSlotNumber = slot_id_in;
 
@@ -5945,25 +5834,25 @@ namespace RoF2
 
 		uint32 TempSlot = 0;
 
-		if (serverSlot < 56 || serverSlot == EQEmu::inventory::slotPowerSource) { // Main Inventory and Cursor
+		if (serverSlot < 56 || serverSlot == EQEmu::invslot::SLOT_POWER_SOURCE) { // Main Inventory and Cursor
 			if (PacketType == ItemPacketLoot)
 			{
-				RoF2Slot.Type = invtype::InvTypeCorpse;
-				RoF2Slot.Slot = serverSlot - EQEmu::legacy::CORPSE_BEGIN;
+				RoF2Slot.Type = invtype::typeCorpse;
+				RoF2Slot.Slot = serverSlot - EQEmu::invslot::CORPSE_BEGIN;
 			}
 			else
 			{
-				RoF2Slot.Type = invtype::InvTypePossessions;
+				RoF2Slot.Type = invtype::typePossessions;
 				RoF2Slot.Slot = serverSlot;
 			}
 
-			if (serverSlot == EQEmu::inventory::slotPowerSource)
-				RoF2Slot.Slot = invslot::PossessionsPowerSource;
+			if (serverSlot == EQEmu::invslot::SLOT_POWER_SOURCE)
+				RoF2Slot.Slot = invslot::slotPowerSource;
 
-			else if (serverSlot >= EQEmu::inventory::slotCursor && PacketType != ItemPacketLoot) // Cursor and Extended Corpse Inventory
+			else if (serverSlot >= EQEmu::invslot::slotCursor && PacketType != ItemPacketLoot) // Cursor and Extended Corpse Inventory
 				RoF2Slot.Slot += 3;
 
-			else if (serverSlot >= EQEmu::inventory::slotAmmo) // (> 20)
+			else if (serverSlot >= EQEmu::invslot::slotAmmo) // (> 20)
 				RoF2Slot.Slot += 1;
 		}
 
@@ -5972,51 +5861,51 @@ namespace RoF2
 		RoF2Slot.MainSlot = ServerSlot - 31;
 		}*/
 
-		else if (serverSlot >= EQEmu::legacy::GENERAL_BAGS_BEGIN && serverSlot <= EQEmu::legacy::CURSOR_BAG_END) { // (> 250 && < 341)
-			RoF2Slot.Type = invtype::InvTypePossessions;
+		else if (serverSlot >= EQEmu::invbag::GENERAL_BAGS_BEGIN && serverSlot <= EQEmu::invbag::CURSOR_BAG_END) { // (> 250 && < 341)
+			RoF2Slot.Type = invtype::typePossessions;
 			TempSlot = serverSlot - 1;
-			RoF2Slot.Slot = int(TempSlot / EQEmu::inventory::ContainerCount) - 2;
-			RoF2Slot.SubIndex = TempSlot - ((RoF2Slot.Slot + 2) * EQEmu::inventory::ContainerCount);
+			RoF2Slot.Slot = int(TempSlot / EQEmu::invbag::SLOT_COUNT) - 2;
+			RoF2Slot.SubIndex = TempSlot - ((RoF2Slot.Slot + 2) * EQEmu::invbag::SLOT_COUNT);
 
-			if (RoF2Slot.Slot >= invslot::PossessionsGeneral9) // (> 30)
-				RoF2Slot.Slot = invslot::PossessionsCursor;
+			if (RoF2Slot.Slot >= invslot::slotGeneral9) // (> 30)
+				RoF2Slot.Slot = invslot::slotCursor;
 		}
 
-		else if (serverSlot >= EQEmu::legacy::TRIBUTE_BEGIN && serverSlot <= EQEmu::legacy::TRIBUTE_END) { // Tribute
-			RoF2Slot.Type = invtype::InvTypeTribute;
-			RoF2Slot.Slot = serverSlot - EQEmu::legacy::TRIBUTE_BEGIN;
+		else if (serverSlot >= EQEmu::invslot::TRIBUTE_BEGIN && serverSlot <= EQEmu::invslot::TRIBUTE_END) { // Tribute
+			RoF2Slot.Type = invtype::typeTribute;
+			RoF2Slot.Slot = serverSlot - EQEmu::invslot::TRIBUTE_BEGIN;
 		}
 
-		else if (serverSlot >= EQEmu::legacy::BANK_BEGIN && serverSlot <= EQEmu::legacy::BANK_BAGS_END) {
-			RoF2Slot.Type = invtype::InvTypeBank;
-			TempSlot = serverSlot - EQEmu::legacy::BANK_BEGIN;
+		else if (serverSlot >= EQEmu::invslot::BANK_BEGIN && serverSlot <= EQEmu::invbag::BANK_BAGS_END) {
+			RoF2Slot.Type = invtype::typeBank;
+			TempSlot = serverSlot - EQEmu::invslot::BANK_BEGIN;
 			RoF2Slot.Slot = TempSlot;
 
 			if (TempSlot > 30) { // (> 30)
-				RoF2Slot.Slot = int(TempSlot / EQEmu::inventory::ContainerCount) - 3;
-				RoF2Slot.SubIndex = TempSlot - ((RoF2Slot.Slot + 3) * EQEmu::inventory::ContainerCount);
+				RoF2Slot.Slot = int(TempSlot / EQEmu::invbag::SLOT_COUNT) - 3;
+				RoF2Slot.SubIndex = TempSlot - ((RoF2Slot.Slot + 3) * EQEmu::invbag::SLOT_COUNT);
 			}
 		}
 
-		else if (serverSlot >= EQEmu::legacy::SHARED_BANK_BEGIN && serverSlot <= EQEmu::legacy::SHARED_BANK_BAGS_END) {
-			RoF2Slot.Type = invtype::InvTypeSharedBank;
-			TempSlot = serverSlot - EQEmu::legacy::SHARED_BANK_BEGIN;
+		else if (serverSlot >= EQEmu::invslot::SHARED_BANK_BEGIN && serverSlot <= EQEmu::invbag::SHARED_BANK_BAGS_END) {
+			RoF2Slot.Type = invtype::typeSharedBank;
+			TempSlot = serverSlot - EQEmu::invslot::SHARED_BANK_BEGIN;
 			RoF2Slot.Slot = TempSlot;
 
 			if (TempSlot > 30) { // (> 30)
-				RoF2Slot.Slot = int(TempSlot / EQEmu::inventory::ContainerCount) - 3;
-				RoF2Slot.SubIndex = TempSlot - ((RoF2Slot.Slot + 3) * EQEmu::inventory::ContainerCount);
+				RoF2Slot.Slot = int(TempSlot / EQEmu::invbag::SLOT_COUNT) - 3;
+				RoF2Slot.SubIndex = TempSlot - ((RoF2Slot.Slot + 3) * EQEmu::invbag::SLOT_COUNT);
 			}
 		}
 
-		else if (serverSlot >= EQEmu::legacy::TRADE_BEGIN && serverSlot <= EQEmu::legacy::TRADE_BAGS_END) {
-			RoF2Slot.Type = invtype::InvTypeTrade;
-			TempSlot = serverSlot - EQEmu::legacy::TRADE_BEGIN;
+		else if (serverSlot >= EQEmu::invslot::TRADE_BEGIN && serverSlot <= EQEmu::invbag::TRADE_BAGS_END) {
+			RoF2Slot.Type = invtype::typeTrade;
+			TempSlot = serverSlot - EQEmu::invslot::TRADE_BEGIN;
 			RoF2Slot.Slot = TempSlot;
 
 			if (TempSlot > 30) {
-				RoF2Slot.Slot = int(TempSlot / EQEmu::inventory::ContainerCount) - 3;
-				RoF2Slot.SubIndex = TempSlot - ((RoF2Slot.Slot + 3) * EQEmu::inventory::ContainerCount);
+				RoF2Slot.Slot = int(TempSlot / EQEmu::invbag::SLOT_COUNT) - 3;
+				RoF2Slot.SubIndex = TempSlot - ((RoF2Slot.Slot + 3) * EQEmu::invbag::SLOT_COUNT);
 			}
 
 			/*
@@ -6033,9 +5922,9 @@ namespace RoF2
 			*/
 		}
 
-		else if (serverSlot >= EQEmu::legacy::WORLD_BEGIN && serverSlot <= EQEmu::legacy::WORLD_END) {
-			RoF2Slot.Type = invtype::InvTypeWorld;
-			TempSlot = serverSlot - EQEmu::legacy::WORLD_BEGIN;
+		else if (serverSlot >= EQEmu::invslot::WORLD_BEGIN && serverSlot <= EQEmu::invslot::WORLD_END) {
+			RoF2Slot.Type = invtype::typeWorld;
+			TempSlot = serverSlot - EQEmu::invslot::WORLD_BEGIN;
 			RoF2Slot.Slot = TempSlot;
 		}
 
@@ -6054,16 +5943,16 @@ namespace RoF2
 
 		uint32 TempSlot = 0;
 
-		if (serverSlot < 56 || serverSlot == EQEmu::inventory::slotPowerSource) { // (< 52)
+		if (serverSlot < 56 || serverSlot == EQEmu::invslot::SLOT_POWER_SOURCE) { // (< 52)
 			RoF2Slot.Slot = serverSlot;
 
-			if (serverSlot == EQEmu::inventory::slotPowerSource)
-				RoF2Slot.Slot = invslot::PossessionsPowerSource;
+			if (serverSlot == EQEmu::invslot::SLOT_POWER_SOURCE)
+				RoF2Slot.Slot = invslot::slotPowerSource;
 
-			else if (serverSlot >= EQEmu::inventory::slotCursor) // Cursor and Extended Corpse Inventory
+			else if (serverSlot >= EQEmu::invslot::slotCursor) // Cursor and Extended Corpse Inventory
 				RoF2Slot.Slot += 3;
 
-			else if (serverSlot >= EQEmu::inventory::slotAmmo) // Ammo and Personl Inventory
+			else if (serverSlot >= EQEmu::invslot::slotAmmo) // Ammo and Personl Inventory
 				RoF2Slot.Slot += 1;
 
 			/*else if (ServerSlot >= MainCursor) { // Cursor
@@ -6074,10 +5963,10 @@ namespace RoF2
 			}*/
 		}
 
-		else if (serverSlot >= EQEmu::legacy::GENERAL_BAGS_BEGIN && serverSlot <= EQEmu::legacy::CURSOR_BAG_END) {
+		else if (serverSlot >= EQEmu::invbag::GENERAL_BAGS_BEGIN && serverSlot <= EQEmu::invbag::CURSOR_BAG_END) {
 			TempSlot = serverSlot - 1;
-			RoF2Slot.Slot = int(TempSlot / EQEmu::inventory::ContainerCount) - 2;
-			RoF2Slot.SubIndex = TempSlot - ((RoF2Slot.Slot + 2) * EQEmu::inventory::ContainerCount);
+			RoF2Slot.Slot = int(TempSlot / EQEmu::invbag::SLOT_COUNT) - 2;
+			RoF2Slot.SubIndex = TempSlot - ((RoF2Slot.Slot + 2) * EQEmu::invbag::SLOT_COUNT);
 		}
 
 		Log(Logs::General, Logs::Netcode, "[ERROR] Convert Server Slot %i to RoF2 Slots: Main %i, Sub %i, Aug %i, Unk1 %i", serverSlot, RoF2Slot.Slot, RoF2Slot.SubIndex, RoF2Slot.AugIndex, RoF2Slot.Unknown01);
@@ -6087,7 +5976,7 @@ namespace RoF2
 
 	static inline uint32 ServerToRoF2CorpseSlot(uint32 serverCorpseSlot)
 	{
-		return (serverCorpseSlot - EQEmu::legacy::CORPSE_BEGIN + 1);
+		return (serverCorpseSlot - EQEmu::invslot::CORPSE_BEGIN + 1);
 	}
 
 	static inline uint32 RoF2ToServerSlot(structs::InventorySlot_Struct rof2Slot, ItemPacketType PacketType)
@@ -6095,11 +5984,11 @@ namespace RoF2
 		uint32 ServerSlot = INVALID_INDEX;
 		uint32 TempSlot = 0;
 
-		if (rof2Slot.Type == invtype::InvTypePossessions && rof2Slot.Slot < 57) { // Worn/Personal Inventory and Cursor (< 51)
-			if (rof2Slot.Slot == invslot::PossessionsPowerSource)
-				TempSlot = EQEmu::inventory::slotPowerSource;
+		if (rof2Slot.Type == invtype::typePossessions && rof2Slot.Slot < 57) { // Worn/Personal Inventory and Cursor (< 51)
+			if (rof2Slot.Slot == invslot::slotPowerSource)
+				TempSlot = EQEmu::invslot::SLOT_POWER_SOURCE;
 
-			else if (rof2Slot.Slot >= invslot::PossessionsCursor) // Cursor and Extended Corpse Inventory
+			else if (rof2Slot.Slot >= invslot::slotCursor) // Cursor and Extended Corpse Inventory
 				TempSlot = rof2Slot.Slot - 3;
 
 			/*else if (RoF2Slot.MainSlot == slots::MainGeneral9 || RoF2Slot.MainSlot == slots::MainGeneral10) { // 9th and 10th RoF2 inventory/corpse slots
@@ -6113,23 +6002,23 @@ namespace RoF2
 			// For now, it's probably best to leave as-is and let this work itself out in the inventory rework.
 			}*/
 
-			else if (rof2Slot.Slot >= invslot::PossessionsAmmo) // Ammo and Main Inventory
+			else if (rof2Slot.Slot >= invslot::slotAmmo) // Ammo and Main Inventory
 				TempSlot = rof2Slot.Slot - 1;
 
 			else // Worn Slots
 				TempSlot = rof2Slot.Slot;
 
-			if (rof2Slot.SubIndex >= EQEmu::inventory::containerBegin) // Bag Slots
-				TempSlot = ((TempSlot + 3) * EQEmu::inventory::ContainerCount) + rof2Slot.SubIndex + 1;
+			if (rof2Slot.SubIndex >= EQEmu::invbag::SLOT_BEGIN) // Bag Slots
+				TempSlot = ((TempSlot + 3) * EQEmu::invbag::SLOT_COUNT) + rof2Slot.SubIndex + 1;
 
 			ServerSlot = TempSlot;
 		}
 
-		else if (rof2Slot.Type == invtype::InvTypeBank) {
-			TempSlot = EQEmu::legacy::BANK_BEGIN;
+		else if (rof2Slot.Type == invtype::typeBank) {
+			TempSlot = EQEmu::invslot::BANK_BEGIN;
 
-			if (rof2Slot.SubIndex >= EQEmu::inventory::containerBegin)
-				TempSlot += ((rof2Slot.Slot + 3) * EQEmu::inventory::ContainerCount) + rof2Slot.SubIndex + 1;
+			if (rof2Slot.SubIndex >= EQEmu::invbag::SLOT_BEGIN)
+				TempSlot += ((rof2Slot.Slot + 3) * EQEmu::invbag::SLOT_COUNT) + rof2Slot.SubIndex + 1;
 
 			else
 				TempSlot += rof2Slot.Slot;
@@ -6137,11 +6026,11 @@ namespace RoF2
 			ServerSlot = TempSlot;
 		}
 
-		else if (rof2Slot.Type == invtype::InvTypeSharedBank) {
-			TempSlot = EQEmu::legacy::SHARED_BANK_BEGIN;
+		else if (rof2Slot.Type == invtype::typeSharedBank) {
+			TempSlot = EQEmu::invslot::SHARED_BANK_BEGIN;
 
-			if (rof2Slot.SubIndex >= EQEmu::inventory::containerBegin)
-				TempSlot += ((rof2Slot.Slot + 3) * EQEmu::inventory::ContainerCount) + rof2Slot.SubIndex + 1;
+			if (rof2Slot.SubIndex >= EQEmu::invbag::SLOT_BEGIN)
+				TempSlot += ((rof2Slot.Slot + 3) * EQEmu::invbag::SLOT_COUNT) + rof2Slot.SubIndex + 1;
 
 			else
 				TempSlot += rof2Slot.Slot;
@@ -6149,11 +6038,11 @@ namespace RoF2
 			ServerSlot = TempSlot;
 		}
 
-		else if (rof2Slot.Type == invtype::InvTypeTrade) {
-			TempSlot = EQEmu::legacy::TRADE_BEGIN;
+		else if (rof2Slot.Type == invtype::typeTrade) {
+			TempSlot = EQEmu::invslot::TRADE_BEGIN;
 
-			if (rof2Slot.SubIndex >= EQEmu::inventory::containerBegin)
-				TempSlot += ((rof2Slot.Slot + 3) * EQEmu::inventory::ContainerCount) + rof2Slot.SubIndex + 1;
+			if (rof2Slot.SubIndex >= EQEmu::invbag::SLOT_BEGIN)
+				TempSlot += ((rof2Slot.Slot + 3) * EQEmu::invbag::SLOT_COUNT) + rof2Slot.SubIndex + 1;
 			// OLD CODE:
 			//TempSlot += 100 + (RoF2Slot.MainSlot * EmuConstants::ITEM_CONTAINER_SIZE) + RoF2Slot.SubSlot;
 
@@ -6163,10 +6052,10 @@ namespace RoF2
 			ServerSlot = TempSlot;
 		}
 
-		else if (rof2Slot.Type == invtype::InvTypeWorld) {
-			TempSlot = EQEmu::legacy::WORLD_BEGIN;
+		else if (rof2Slot.Type == invtype::typeWorld) {
+			TempSlot = EQEmu::invslot::WORLD_BEGIN;
 
-			if (rof2Slot.Slot >= EQEmu::inventory::containerBegin)
+			if (rof2Slot.Slot >= EQEmu::invbag::SLOT_BEGIN)
 				TempSlot += rof2Slot.Slot;
 
 			ServerSlot = TempSlot;
@@ -6181,12 +6070,12 @@ namespace RoF2
 		ServerSlot = TempSlot;
 		}*/
 
-		else if (rof2Slot.Type == invtype::InvTypeGuildTribute) {
+		else if (rof2Slot.Type == invtype::typeGuildTribute) {
 			ServerSlot = INVALID_INDEX;
 		}
 
-		else if (rof2Slot.Type == invtype::InvTypeCorpse) {
-			ServerSlot = rof2Slot.Slot + EQEmu::legacy::CORPSE_BEGIN;
+		else if (rof2Slot.Type == invtype::typeCorpse) {
+			ServerSlot = rof2Slot.Slot + EQEmu::invslot::CORPSE_BEGIN;
 		}
 
 		Log(Logs::General, Logs::Netcode, "[ERROR] Convert RoF2 Slots: Type %i, Unk2 %i, Main %i, Sub %i, Aug %i, Unk1 %i to Server Slot %i", rof2Slot.Type, rof2Slot.Unknown02, rof2Slot.Slot, rof2Slot.SubIndex, rof2Slot.AugIndex, rof2Slot.Unknown01, ServerSlot);
@@ -6200,10 +6089,10 @@ namespace RoF2
 		uint32 TempSlot = 0;
 
 		if (rof2Slot.Slot < 57) { // Worn/Personal Inventory and Cursor (< 33)
-			if (rof2Slot.Slot == invslot::PossessionsPowerSource)
-				TempSlot = EQEmu::inventory::slotPowerSource;
+			if (rof2Slot.Slot == invslot::slotPowerSource)
+				TempSlot = EQEmu::invslot::SLOT_POWER_SOURCE;
 
-			else if (rof2Slot.Slot >= invslot::PossessionsCursor) // Cursor and Extended Corpse Inventory
+			else if (rof2Slot.Slot >= invslot::slotCursor) // Cursor and Extended Corpse Inventory
 				TempSlot = rof2Slot.Slot - 3;
 
 			/*else if (RoF2Slot.MainSlot == slots::MainGeneral9 || RoF2Slot.MainSlot == slots::MainGeneral10) { // 9th and 10th RoF2 inventory slots
@@ -6212,14 +6101,14 @@ namespace RoF2
 			// Same as above
 			}*/
 
-			else if (rof2Slot.Slot >= invslot::PossessionsAmmo) // Main Inventory and Ammo Slots
+			else if (rof2Slot.Slot >= invslot::slotAmmo) // Main Inventory and Ammo Slots
 				TempSlot = rof2Slot.Slot - 1;
 
 			else
 				TempSlot = rof2Slot.Slot;
 
-			if (rof2Slot.SubIndex >= EQEmu::inventory::containerBegin) // Bag Slots
-				TempSlot = ((TempSlot + 3) * EQEmu::inventory::ContainerCount) + rof2Slot.SubIndex + 1;
+			if (rof2Slot.SubIndex >= EQEmu::invbag::SLOT_BEGIN) // Bag Slots
+				TempSlot = ((TempSlot + 3) * EQEmu::invbag::SLOT_COUNT) + rof2Slot.SubIndex + 1;
 
 			ServerSlot = TempSlot;
 		}
@@ -6231,12 +6120,12 @@ namespace RoF2
 
 	static inline uint32 RoF2ToServerCorpseSlot(uint32 rof2CorpseSlot)
 	{
-		return (rof2CorpseSlot + EQEmu::legacy::CORPSE_BEGIN - 1);
+		return (rof2CorpseSlot + EQEmu::invslot::CORPSE_BEGIN - 1);
 	}
 
 	static inline void ServerToRoF2SayLink(std::string& rof2SayLink, const std::string& serverSayLink)
 	{
-		if ((constants::SayLinkBodySize == EQEmu::constants::SayLinkBodySize) || (serverSayLink.find('\x12') == std::string::npos)) {
+		if ((constants::SAY_LINK_BODY_SIZE == EQEmu::constants::SAY_LINK_BODY_SIZE) || (serverSayLink.find('\x12') == std::string::npos)) {
 			rof2SayLink = serverSayLink;
 			return;
 		}
@@ -6245,7 +6134,7 @@ namespace RoF2
 
 		for (size_t segment_iter = 0; segment_iter < segments.size(); ++segment_iter) {
 			if (segment_iter & 1) {
-				if (segments[segment_iter].length() <= EQEmu::constants::SayLinkBodySize) {
+				if (segments[segment_iter].length() <= EQEmu::constants::SAY_LINK_BODY_SIZE) {
 					rof2SayLink.append(segments[segment_iter]);
 					// TODO: log size mismatch error
 					continue;
@@ -6268,7 +6157,7 @@ namespace RoF2
 
 	static inline void RoF2ToServerSayLink(std::string& serverSayLink, const std::string& rof2SayLink)
 	{
-		if ((EQEmu::constants::SayLinkBodySize == constants::SayLinkBodySize) || (rof2SayLink.find('\x12') == std::string::npos)) {
+		if ((EQEmu::constants::SAY_LINK_BODY_SIZE == constants::SAY_LINK_BODY_SIZE) || (rof2SayLink.find('\x12') == std::string::npos)) {
 			serverSayLink = rof2SayLink;
 			return;
 		}
@@ -6277,7 +6166,7 @@ namespace RoF2
 
 		for (size_t segment_iter = 0; segment_iter < segments.size(); ++segment_iter) {
 			if (segment_iter & 1) {
-				if (segments[segment_iter].length() <= constants::SayLinkBodySize) {
+				if (segments[segment_iter].length() <= constants::SAY_LINK_BODY_SIZE) {
 					serverSayLink.append(segments[segment_iter]);
 					// TODO: log size mismatch error
 					continue;

common/patches/rof2_limits.cpp

@@ -22,231 +22,231 @@
 #include "../string_util.h"
 
 
-size_t RoF2::invtype::GetInvTypeSize(int inv_type)
+int16 RoF2::invtype::GetInvTypeSize(int16 inv_type)
 {
 	switch (inv_type) {
-	case invtype::InvTypePossessions:
-		return invtype::InvTypePossessionsSize;
-	case invtype::InvTypeBank:
-		return invtype::InvTypeBankSize;
-	case invtype::InvTypeSharedBank:
-		return invtype::InvTypeSharedBankSize;
-	case invtype::InvTypeTrade:
-		return invtype::InvTypeTradeSize;
-	case invtype::InvTypeWorld:
-		return invtype::InvTypeWorldSize;
-	case invtype::InvTypeLimbo:
-		return invtype::InvTypeLimboSize;
-	case invtype::InvTypeTribute:
-		return invtype::InvTypeTributeSize;
-	case invtype::InvTypeTrophyTribute:
-		return invtype::InvTypeTrophyTributeSize;
-	case invtype::InvTypeGuildTribute:
-		return invtype::InvTypeGuildTributeSize;
-	case invtype::InvTypeMerchant:
-		return invtype::InvTypeMerchantSize;
-	case invtype::InvTypeDeleted:
-		return invtype::InvTypeDeletedSize;
-	case invtype::InvTypeCorpse:
-		return invtype::InvTypeCorpseSize;
-	case invtype::InvTypeBazaar:
-		return invtype::InvTypeBazaarSize;
-	case invtype::InvTypeInspect:
-		return invtype::InvTypeInspectSize;
-	case invtype::InvTypeRealEstate:
-		return invtype::InvTypeRealEstateSize;
-	case invtype::InvTypeViewMODPC:
-		return invtype::InvTypeViewMODPCSize;
-	case invtype::InvTypeViewMODBank:
-		return invtype::InvTypeViewMODBankSize;
-	case invtype::InvTypeViewMODSharedBank:
-		return invtype::InvTypeViewMODSharedBankSize;
-	case invtype::InvTypeViewMODLimbo:
-		return invtype::InvTypeViewMODLimboSize;
-	case invtype::InvTypeAltStorage:
-		return invtype::InvTypeAltStorageSize;
-	case invtype::InvTypeArchived:
-		return invtype::InvTypeArchivedSize;
-	case invtype::InvTypeMail:
-		return invtype::InvTypeMailSize;
-	case invtype::InvTypeGuildTrophyTribute:
-		return invtype::InvTypeGuildTrophyTributeSize;
-	case invtype::InvTypeKrono:
-		return invtype::InvTypeKronoSize;
-	case invtype::InvTypeOther:
-		return invtype::InvTypeOtherSize;
+	case invtype::typePossessions:
+		return invtype::POSSESSIONS_SIZE;
+	case invtype::typeBank:
+		return invtype::BANK_SIZE;
+	case invtype::typeSharedBank:
+		return invtype::SHARED_BANK_SIZE;
+	case invtype::typeTrade:
+		return invtype::TRADE_SIZE;
+	case invtype::typeWorld:
+		return invtype::WORLD_SIZE;
+	case invtype::typeLimbo:
+		return invtype::LIMBO_SIZE;
+	case invtype::typeTribute:
+		return invtype::TRIBUTE_SIZE;
+	case invtype::typeTrophyTribute:
+		return invtype::TROPHY_TRIBUTE_SIZE;
+	case invtype::typeGuildTribute:
+		return invtype::GUILD_TRIBUTE_SIZE;
+	case invtype::typeMerchant:
+		return invtype::MERCHANT_SIZE;
+	case invtype::typeDeleted:
+		return invtype::DELETED_SIZE;
+	case invtype::typeCorpse:
+		return invtype::CORPSE_SIZE;
+	case invtype::typeBazaar:
+		return invtype::BAZAAR_SIZE;
+	case invtype::typeInspect:
+		return invtype::INSPECT_SIZE;
+	case invtype::typeRealEstate:
+		return invtype::REAL_ESTATE_SIZE;
+	case invtype::typeViewMODPC:
+		return invtype::VIEW_MOD_PC_SIZE;
+	case invtype::typeViewMODBank:
+		return invtype::VIEW_MOD_BANK_SIZE;
+	case invtype::typeViewMODSharedBank:
+		return invtype::VIEW_MOD_SHARED_BANK_SIZE;
+	case invtype::typeViewMODLimbo:
+		return invtype::VIEW_MOD_LIMBO_SIZE;
+	case invtype::typeAltStorage:
+		return invtype::ALT_STORAGE_SIZE;
+	case invtype::typeArchived:
+		return invtype::ARCHIVED_SIZE;
+	case invtype::typeMail:
+		return invtype::MAIL_SIZE;
+	case invtype::typeGuildTrophyTribute:
+		return invtype::GUILD_TROPHY_TRIBUTE_SIZE;
+	case invtype::typeKrono:
+		return invtype::KRONO_SIZE;
+	case invtype::typeOther:
+		return invtype::OTHER_SIZE;
 	default:
-		return 0;
+		return INULL;
 	}
 }
 
-const char* RoF2::invtype::GetInvTypeName(int inv_type)
+const char* RoF2::invtype::GetInvTypeName(int16 inv_type)
 {
 	switch (inv_type) {
-	case invtype::InvTypeInvalid:
+	case invtype::TYPE_INVALID:
 		return "Invalid Type";
-	case invtype::InvTypePossessions:
+	case invtype::typePossessions:
 		return "Possessions";
-	case invtype::InvTypeBank:
+	case invtype::typeBank:
 		return "Bank";
-	case invtype::InvTypeSharedBank:
+	case invtype::typeSharedBank:
 		return "Shared Bank";
-	case invtype::InvTypeTrade:
+	case invtype::typeTrade:
 		return "Trade";
-	case invtype::InvTypeWorld:
+	case invtype::typeWorld:
 		return "World";
-	case invtype::InvTypeLimbo:
+	case invtype::typeLimbo:
 		return "Limbo";
-	case invtype::InvTypeTribute:
+	case invtype::typeTribute:
 		return "Tribute";
-	case invtype::InvTypeTrophyTribute:
+	case invtype::typeTrophyTribute:
 		return "Trophy Tribute";
-	case invtype::InvTypeGuildTribute:
+	case invtype::typeGuildTribute:
 		return "Guild Tribute";
-	case invtype::InvTypeMerchant:
+	case invtype::typeMerchant:
 		return "Merchant";
-	case invtype::InvTypeDeleted:
+	case invtype::typeDeleted:
 		return "Deleted";
-	case invtype::InvTypeCorpse:
+	case invtype::typeCorpse:
 		return "Corpse";
-	case invtype::InvTypeBazaar:
+	case invtype::typeBazaar:
 		return "Bazaar";
-	case invtype::InvTypeInspect:
+	case invtype::typeInspect:
 		return "Inspect";
-	case invtype::InvTypeRealEstate:
+	case invtype::typeRealEstate:
 		return "Real Estate";
-	case invtype::InvTypeViewMODPC:
+	case invtype::typeViewMODPC:
 		return "View MOD PC";
-	case invtype::InvTypeViewMODBank:
+	case invtype::typeViewMODBank:
 		return "View MOD Bank";
-	case invtype::InvTypeViewMODSharedBank:
+	case invtype::typeViewMODSharedBank:
 		return "View MOD Shared Bank";
-	case invtype::InvTypeViewMODLimbo:
+	case invtype::typeViewMODLimbo:
 		return "View MOD Limbo";
-	case invtype::InvTypeAltStorage:
+	case invtype::typeAltStorage:
 		return "Alt Storage";
-	case invtype::InvTypeArchived:
+	case invtype::typeArchived:
 		return "Archived";
-	case invtype::InvTypeMail:
+	case invtype::typeMail:
 		return "Mail";
-	case invtype::InvTypeGuildTrophyTribute:
+	case invtype::typeGuildTrophyTribute:
 		return "Guild Trophy Tribute";
-	case invtype::InvTypeKrono:
+	case invtype::typeKrono:
 		return "Krono";
-	case invtype::InvTypeOther:
+	case invtype::typeOther:
 		return "Other";
 	default:
 		return "Unknown Type";
 	}
 }
 
-bool RoF2::invtype::IsInvTypePersistent(int inv_type)
+bool RoF2::invtype::IsInvTypePersistent(int16 inv_type)
 {
 	switch (inv_type) {
-	case invtype::InvTypePossessions:
-	case invtype::InvTypeBank:
-	case invtype::InvTypeSharedBank:
-	case invtype::InvTypeTrade:
-	case invtype::InvTypeWorld:
-	case invtype::InvTypeLimbo:
-	case invtype::InvTypeTribute:
-	case invtype::InvTypeTrophyTribute:
-	case invtype::InvTypeGuildTribute:
+	case invtype::typePossessions:
+	case invtype::typeBank:
+	case invtype::typeSharedBank:
+	case invtype::typeTrade:
+	case invtype::typeWorld:
+	case invtype::typeLimbo:
+	case invtype::typeTribute:
+	case invtype::typeTrophyTribute:
+	case invtype::typeGuildTribute:
 		return true;
 	default:
 		return false;
 	}
 }
 
-const char* RoF2::invslot::GetInvPossessionsSlotName(int inv_slot)
+const char* RoF2::invslot::GetInvPossessionsSlotName(int16 inv_slot)
 {
 	switch (inv_slot) {
-	case invslot::InvSlotInvalid:
+	case invslot::SLOT_INVALID:
 		return "Invalid Slot";
-	case invslot::PossessionsCharm:
+	case invslot::slotCharm:
 		return "Charm";
-	case invslot::PossessionsEar1:
+	case invslot::slotEar1:
 		return "Ear 1";
-	case invslot::PossessionsHead:
+	case invslot::slotHead:
 		return "Head";
-	case invslot::PossessionsFace:
+	case invslot::slotFace:
 		return "Face";
-	case invslot::PossessionsEar2:
+	case invslot::slotEar2:
 		return "Ear 2";
-	case invslot::PossessionsNeck:
+	case invslot::slotNeck:
 		return "Neck";
-	case invslot::PossessionsShoulders:
+	case invslot::slotShoulders:
 		return "Shoulders";
-	case invslot::PossessionsArms:
+	case invslot::slotArms:
 		return "Arms";
-	case invslot::PossessionsBack:
+	case invslot::slotBack:
 		return "Back";
-	case invslot::PossessionsWrist1:
+	case invslot::slotWrist1:
 		return "Wrist 1";
-	case invslot::PossessionsWrist2:
+	case invslot::slotWrist2:
 		return "Wrist 2";
-	case invslot::PossessionsRange:
+	case invslot::slotRange:
 		return "Range";
-	case invslot::PossessionsHands:
+	case invslot::slotHands:
 		return "Hands";
-	case invslot::PossessionsPrimary:
+	case invslot::slotPrimary:
 		return "Primary";
-	case invslot::PossessionsSecondary:
+	case invslot::slotSecondary:
 		return "Secondary";
-	case invslot::PossessionsFinger1:
+	case invslot::slotFinger1:
 		return "Finger 1";
-	case invslot::PossessionsFinger2:
+	case invslot::slotFinger2:
 		return "Finger 2";
-	case invslot::PossessionsChest:
+	case invslot::slotChest:
 		return "Chest";
-	case invslot::PossessionsLegs:
+	case invslot::slotLegs:
 		return "Legs";
-	case invslot::PossessionsFeet:
+	case invslot::slotFeet:
 		return "Feet";
-	case invslot::PossessionsWaist:
+	case invslot::slotWaist:
 		return "Waist";
-	case invslot::PossessionsPowerSource:
+	case invslot::slotPowerSource:
 		return "Power Source";
-	case invslot::PossessionsAmmo:
+	case invslot::slotAmmo:
 		return "Ammo";
-	case invslot::PossessionsGeneral1:
+	case invslot::slotGeneral1:
 		return "General 1";
-	case invslot::PossessionsGeneral2:
+	case invslot::slotGeneral2:
 		return "General 2";
-	case invslot::PossessionsGeneral3:
+	case invslot::slotGeneral3:
 		return "General 3";
-	case invslot::PossessionsGeneral4:
+	case invslot::slotGeneral4:
 		return "General 4";
-	case invslot::PossessionsGeneral5:
+	case invslot::slotGeneral5:
 		return "General 5";
-	case invslot::PossessionsGeneral6:
+	case invslot::slotGeneral6:
 		return "General 6";
-	case invslot::PossessionsGeneral7:
+	case invslot::slotGeneral7:
 		return "General 7";
-	case invslot::PossessionsGeneral8:
+	case invslot::slotGeneral8:
 		return "General 8";
-	case invslot::PossessionsGeneral9:
+	case invslot::slotGeneral9:
 		return "General 9";
-	case invslot::PossessionsGeneral10:
+	case invslot::slotGeneral10:
 		return "General 10";
-	case invslot::PossessionsCursor:
+	case invslot::slotCursor:
 		return "Cursor";
 	default:
 		return "Unknown Slot";
 	}
 }
 
-const char* RoF2::invslot::GetInvSlotName(int inv_type, int inv_slot)
+const char* RoF2::invslot::GetInvSlotName(int16 inv_type, int16 inv_slot)
 {
-	if (inv_type == invtype::InvTypePossessions)
+	if (inv_type == invtype::typePossessions)
 		return invslot::GetInvPossessionsSlotName(inv_slot);
 
-	size_t type_size = invtype::GetInvTypeSize(inv_type);
+	int16 type_size = invtype::GetInvTypeSize(inv_type);
 
-	if (!type_size || inv_slot == invslot::InvSlotInvalid)
+	if (!type_size || inv_slot == invslot::SLOT_INVALID)
 		return "Invalid Slot";
 
-	if ((size_t)(inv_slot + 1) >= type_size)
+	if ((inv_slot + 1) >= type_size)
 		return "Unknown Slot";
 
 	static std::string ret_str;
@@ -255,12 +255,12 @@ const char* RoF2::invslot::GetInvSlotName(int inv_type, int inv_slot)
 	return ret_str.c_str();
 }
 
-const char* RoF2::invbag::GetInvBagIndexName(int bag_index)
+const char* RoF2::invbag::GetInvBagIndexName(int16 bag_index)
 {
-	if (bag_index == invbag::InvBagInvalid)
+	if (bag_index == invbag::SLOT_INVALID)
 		return "Invalid Bag";
 
-	if ((size_t)bag_index >= invbag::ItemBagSize)
+	if (bag_index >= invbag::SLOT_COUNT)
 		return "Unknown Bag";
 
 	static std::string ret_str;
@@ -269,12 +269,12 @@ const char* RoF2::invbag::GetInvBagIndexName(int bag_index)
 	return ret_str.c_str();
 }
 
-const char* RoF2::invaug::GetInvAugIndexName(int aug_index)
+const char* RoF2::invaug::GetInvAugIndexName(int16 aug_index)
 {
-	if (aug_index == invaug::InvAugInvalid)
+	if (aug_index == invaug::SOCKET_INVALID)
 		return "Invalid Augment";
 
-	if ((size_t)aug_index >= invaug::ItemAugSize)
+	if (aug_index >= invaug::SOCKET_COUNT)
 		return "Unknown Augment";
 
 	static std::string ret_str;

common/patches/rof2_limits.h

@@ -27,116 +27,191 @@
 
 namespace RoF2
 {
-	enum : int { Invalid = -1, Null, Safety };
+	const int16 IINVALID = -1;
+	const int16 INULL = 0;
 
-	enum : bool { False = false, True = true };
-
-	// pre-declarations
 	namespace inventory {
 		inline EQEmu::versions::ClientVersion GetInventoryRef() { return EQEmu::versions::ClientVersion::RoF2; }
 
+		const bool ConcatenateInvTypeLimbo = false;
+
+		const bool AllowOverLevelEquipment = true;
+
+		const bool AllowEmptyBagInBag = true;
+		const bool AllowClickCastFromBag = true;
+
 	} /*inventory*/
 
 	namespace invtype {
 		inline EQEmu::versions::ClientVersion GetInvTypeRef() { return EQEmu::versions::ClientVersion::RoF2; }
 
-		enum : int { InvTypeInvalid = -1, InvTypeBegin };
+		namespace enum_ {
+			enum InventoryTypes : int16 {
+				typePossessions = INULL,
+				typeBank,
+				typeSharedBank,
+				typeTrade,
+				typeWorld,
+				typeLimbo,
+				typeTribute,
+				typeTrophyTribute,
+				typeGuildTribute,
+				typeMerchant,
+				typeDeleted,
+				typeCorpse,
+				typeBazaar,
+				typeInspect,
+				typeRealEstate,
+				typeViewMODPC,
+				typeViewMODBank,
+				typeViewMODSharedBank,
+				typeViewMODLimbo,
+				typeAltStorage,
+				typeArchived,
+				typeMail,
+				typeGuildTrophyTribute,
+				typeKrono,
+				typeOther
+			};
 
-		enum InventoryType : int {
-			InvTypePossessions = InvTypeBegin,
-			InvTypeBank,
-			InvTypeSharedBank,
-			InvTypeTrade,
-			InvTypeWorld,
-			InvTypeLimbo,
-			InvTypeTribute,
-			InvTypeTrophyTribute,
-			InvTypeGuildTribute,
-			InvTypeMerchant,
-			InvTypeDeleted,
-			InvTypeCorpse,
-			InvTypeBazaar,
-			InvTypeInspect,
-			InvTypeRealEstate,
-			InvTypeViewMODPC,
-			InvTypeViewMODBank,
-			InvTypeViewMODSharedBank,
-			InvTypeViewMODLimbo,
-			InvTypeAltStorage,
-			InvTypeArchived,
-			InvTypeMail,
-			InvTypeGuildTrophyTribute,
-			InvTypeKrono,
-			InvTypeOther,
-			InvTypeCount
-		};
+		} // namespace enum_
+		using namespace enum_;
+
+		const int16 POSSESSIONS_SIZE = 34;
+		const int16 BANK_SIZE = 24;
+		const int16 SHARED_BANK_SIZE = 2;
+		const int16 TRADE_SIZE = 8;
+		const int16 WORLD_SIZE = 10;
+		const int16 LIMBO_SIZE = 36;
+		const int16 TRIBUTE_SIZE = 5;
+		const int16 TROPHY_TRIBUTE_SIZE = 0;//unknown
+		const int16 GUILD_TRIBUTE_SIZE = 2;//unverified
+		const int16 MERCHANT_SIZE = 200;
+		const int16 DELETED_SIZE = 0;//unknown - "Recovery Tab"
+		const int16 CORPSE_SIZE = POSSESSIONS_SIZE;
+		const int16 BAZAAR_SIZE = 200;
+		const int16 INSPECT_SIZE = 23;
+		const int16 REAL_ESTATE_SIZE = 0;//unknown
+		const int16 VIEW_MOD_PC_SIZE = POSSESSIONS_SIZE;
+		const int16 VIEW_MOD_BANK_SIZE = BANK_SIZE;
+		const int16 VIEW_MOD_SHARED_BANK_SIZE = SHARED_BANK_SIZE;
+		const int16 VIEW_MOD_LIMBO_SIZE = LIMBO_SIZE;
+		const int16 ALT_STORAGE_SIZE = 0;//unknown - "Shroud Bank"
+		const int16 ARCHIVED_SIZE = 0;//unknown
+		const int16 MAIL_SIZE = 0;//unknown
+		const int16 GUILD_TROPHY_TRIBUTE_SIZE = 0;//unknown
+		const int16 KRONO_SIZE = 0;//unknown
+		const int16 OTHER_SIZE = 0;//unknown
+
+		const int16 TRADE_NPC_SIZE = 4; // defined by implication
+
+		const int16 TYPE_INVALID = IINVALID;
+		const int16 TYPE_BEGIN = typePossessions;
+		const int16 TYPE_END = typeOther;
+		const int16 TYPE_COUNT = (TYPE_END - TYPE_BEGIN) + 1;
+
+		int16 GetInvTypeSize(int16 inv_type);
+		const char* GetInvTypeName(int16 inv_type);
+
+		bool IsInvTypePersistent(int16 inv_type);
 
 	} /*invtype*/
 
 	namespace invslot {
 		inline EQEmu::versions::ClientVersion GetInvSlotRef() { return EQEmu::versions::ClientVersion::RoF2; }
 
-		enum : int { InvSlotInvalid = -1, InvSlotBegin };
+		namespace enum_ {
+			enum InventorySlots : int16 {
+				slotCharm = INULL,
+				slotEar1,
+				slotHead,
+				slotFace,
+				slotEar2,
+				slotNeck,
+				slotShoulders,
+				slotArms,
+				slotBack,
+				slotWrist1,
+				slotWrist2,
+				slotRange,
+				slotHands,
+				slotPrimary,
+				slotSecondary,
+				slotFinger1,
+				slotFinger2,
+				slotChest,
+				slotLegs,
+				slotFeet,
+				slotWaist,
+				slotPowerSource,
+				slotAmmo,
+				slotGeneral1,
+				slotGeneral2,
+				slotGeneral3,
+				slotGeneral4,
+				slotGeneral5,
+				slotGeneral6,
+				slotGeneral7,
+				slotGeneral8,
+				slotGeneral9,
+				slotGeneral10,
+				slotCursor
+			};
 
-		enum PossessionsSlot : int {
-			PossessionsCharm = InvSlotBegin,
-			PossessionsEar1,
-			PossessionsHead,
-			PossessionsFace,
-			PossessionsEar2,
-			PossessionsNeck,
-			PossessionsShoulders,
-			PossessionsArms,
-			PossessionsBack,
-			PossessionsWrist1,
-			PossessionsWrist2,
-			PossessionsRange,
-			PossessionsHands,
-			PossessionsPrimary,
-			PossessionsSecondary,
-			PossessionsFinger1,
-			PossessionsFinger2,
-			PossessionsChest,
-			PossessionsLegs,
-			PossessionsFeet,
-			PossessionsWaist,
-			PossessionsPowerSource,
-			PossessionsAmmo,
-			PossessionsGeneral1,
-			PossessionsGeneral2,
-			PossessionsGeneral3,
-			PossessionsGeneral4,
-			PossessionsGeneral5,
-			PossessionsGeneral6,
-			PossessionsGeneral7,
-			PossessionsGeneral8,
-			PossessionsGeneral9,
-			PossessionsGeneral10,
-			PossessionsCursor,
-			PossessionsCount
-		};
+		} // namespace enum_
+		using namespace enum_;
 
-		const int EquipmentBegin = PossessionsCharm;
-		const int EquipmentEnd = PossessionsAmmo;
-		const int EquipmentCount = (EquipmentEnd - EquipmentBegin + 1);
+		const int16 SLOT_INVALID = IINVALID;
+		const int16 SLOT_BEGIN = INULL;
 
-		const int GeneralBegin = PossessionsGeneral1;
-		const int GeneralEnd = PossessionsGeneral10;
-		const int GeneralCount = (GeneralEnd - GeneralBegin + 1);
+		const int16 POSSESSIONS_BEGIN = slotCharm;
+		const int16 POSSESSIONS_END = slotCursor;
+		const int16 POSSESSIONS_COUNT = (POSSESSIONS_END - POSSESSIONS_BEGIN) + 1;
+
+		const int16 EQUIPMENT_BEGIN = slotCharm;
+		const int16 EQUIPMENT_END = slotAmmo;
+		const int16 EQUIPMENT_COUNT = (EQUIPMENT_END - EQUIPMENT_BEGIN) + 1;
+
+		const int16 GENERAL_BEGIN = slotGeneral1;
+		const int16 GENERAL_END = slotGeneral10;
+		const int16 GENERAL_COUNT = (GENERAL_END - GENERAL_BEGIN) + 1;
+
+		const int16 BONUS_BEGIN = invslot::slotCharm;
+		const int16 BONUS_STAT_END = invslot::slotPowerSource;
+		const int16 BONUS_SKILL_END = invslot::slotAmmo;
+
+		const int16 CORPSE_BEGIN = invslot::slotGeneral1;
+		const int16 CORPSE_END = invslot::slotGeneral1 + invslot::slotCursor;
+
+		const uint64 POSSESSIONS_BITMASK = 0x00000003FFFFFFFF; // based on 34-slot count (RoF+)
+		const uint64 CORPSE_BITMASK = 0x01FFFFFFFF800000; // based on 34-slot count (RoF+)
+
+		const char* GetInvPossessionsSlotName(int16 inv_slot);
+		const char* GetInvSlotName(int16 inv_type, int16 inv_slot);
 
 	} /*invslot*/
 
 	namespace invbag {
 		inline EQEmu::versions::ClientVersion GetInvBagRef() { return EQEmu::versions::ClientVersion::RoF2; }
 
-		enum : int { InvBagInvalid = -1, InvBagBegin };
+		const int16 SLOT_INVALID = IINVALID;
+		const int16 SLOT_BEGIN = INULL;
+		const int16 SLOT_END = 9; //254;
+		const int16 SLOT_COUNT = 10; //255; // server Size will be 255..unsure what actual client is (test)
+
+		const char* GetInvBagIndexName(int16 bag_index);
 
 	} /*invbag*/
 
 	namespace invaug {
 		inline EQEmu::versions::ClientVersion GetInvAugRef() { return EQEmu::versions::ClientVersion::RoF2; }
 
-		enum : int { InvAugInvalid = -1, InvAugBegin };
+		const int16 SOCKET_INVALID = IINVALID;
+		const int16 SOCKET_BEGIN = INULL;
+		const int16 SOCKET_END = 5;
+		const int16 SOCKET_COUNT = 6;
+
+		const char* GetInvAugIndexName(int16 aug_index);
 
 	} /*invaug*/
 
@@ -172,110 +247,21 @@ namespace RoF2
 	namespace profile {
 		inline EQEmu::versions::ClientVersion GetProfileRef() { return EQEmu::versions::ClientVersion::RoF2; }
 
+		const int16 BANDOLIERS_SIZE = 20;		// number of bandolier instances
+		const int16 BANDOLIER_ITEM_COUNT = 4;	// number of equipment slots in bandolier instance
+
+		const int16 POTION_BELT_SIZE = 5;
+
+		const int16 SKILL_ARRAY_SIZE = 100;
+
 	} /*profile*/
 
 	namespace constants {
 		inline EQEmu::versions::ClientVersion GetConstantsRef() { return EQEmu::versions::ClientVersion::RoF2; }
 
-	} /*constants*/
+		const size_t CHARACTER_CREATION_LIMIT = 12;
 
-	namespace behavior {
-		inline EQEmu::versions::ClientVersion GetBehaviorRef() { return EQEmu::versions::ClientVersion::RoF2; }
-
-	} /*behavior*/
-
-	namespace skills {
-		inline EQEmu::versions::ClientVersion GetSkillsRef() { return EQEmu::versions::ClientVersion::RoF2; }
-
-	} /*skills*/
-
-
-	// declarations
-	namespace inventory {
-		const bool ConcatenateInvTypeLimbo = false;
-
-		const bool AllowOverLevelEquipment = true;
-
-		const bool AllowEmptyBagInBag = true;
-		const bool AllowClickCastFromBag = true;
-
-	} /*inventory*/
-
-	namespace invtype {
-		const size_t InvTypePossessionsSize = invslot::PossessionsCount;
-		const size_t InvTypeBankSize = 24;
-		const size_t InvTypeSharedBankSize = 2;
-		const size_t InvTypeTradeSize = 8;
-		const size_t InvTypeWorldSize = 10;
-		const size_t InvTypeLimboSize = 36;
-		const size_t InvTypeTributeSize = 5;
-		const size_t InvTypeTrophyTributeSize = 0;//unknown
-		const size_t InvTypeGuildTributeSize = 2;//unverified
-		const size_t InvTypeMerchantSize = 200;
-		const size_t InvTypeDeletedSize = 0;//unknown - "Recovery Tab"
-		const size_t InvTypeCorpseSize = InvTypePossessionsSize;
-		const size_t InvTypeBazaarSize = 200;
-		const size_t InvTypeInspectSize = invslot::EquipmentCount;
-		const size_t InvTypeRealEstateSize = 0;//unknown
-		const size_t InvTypeViewMODPCSize = InvTypePossessionsSize;
-		const size_t InvTypeViewMODBankSize = InvTypeBankSize;
-		const size_t InvTypeViewMODSharedBankSize = InvTypeSharedBankSize;
-		const size_t InvTypeViewMODLimboSize = InvTypeLimboSize;
-		const size_t InvTypeAltStorageSize = 0;//unknown - "Shroud Bank"
-		const size_t InvTypeArchivedSize = 0;//unknown
-		const size_t InvTypeMailSize = 0;//unknown
-		const size_t InvTypeGuildTrophyTributeSize = 0;//unknown
-		const size_t InvTypeKronoSize = 0;//unknown
-		const size_t InvTypeOtherSize = 0;//unknown
-
-		extern size_t GetInvTypeSize(int inv_type);
-		extern const char* GetInvTypeName(int inv_type);
-
-		extern bool IsInvTypePersistent(int inv_type);
-
-	} /*invtype*/
-
-	namespace invslot {
-		extern const char* GetInvPossessionsSlotName(int inv_slot);
-		extern const char* GetInvSlotName(int inv_type, int inv_slot);
-
-	} /*invslot*/
-
-	namespace invbag {
-		const size_t ItemBagSize = 255; // server Size will be 255..unsure what actual client is (test)
-
-		extern const char* GetInvBagIndexName(int bag_index);
-
-	} /*invbag*/
-
-	namespace invaug {
-		const size_t ItemAugSize = 6;
-
-		extern const char* GetInvAugIndexName(int aug_index);
-
-	} /*invaug*/
-
-	namespace item {
-
-	} /*item*/
-
-	namespace profile {
-		const size_t TributeSize = invtype::InvTypeTributeSize;
-		const size_t GuildTributeSize = invtype::InvTypeGuildTributeSize;
-
-		const size_t BandoliersSize = 20;		// number of bandolier instances
-		const size_t BandolierItemCount = 4;	// number of equipment slots in bandolier instance
-
-		const size_t PotionBeltSize = 5;
-
-		const size_t SkillArraySize = 100;
-
-	} /*profile*/
-
-	namespace constants {
-		const size_t CharacterCreationLimit = 12;
-
-		const size_t SayLinkBodySize = 56;
+		const size_t SAY_LINK_BODY_SIZE = 56;
 
 		const int LongBuffs = 42;
 		const int ShortBuffs = 20;
@@ -288,11 +274,15 @@ namespace RoF2
 	} /*constants*/
 
 	namespace behavior {
+		inline EQEmu::versions::ClientVersion GetBehaviorRef() { return EQEmu::versions::ClientVersion::RoF2; }
+
 		const bool CoinHasWeight = false;
 
 	} /*behavior*/
 
 	namespace skills {
+		inline EQEmu::versions::ClientVersion GetSkillsRef() { return EQEmu::versions::ClientVersion::RoF2; }
+
 		const size_t LastUsableSkill = EQEmu::skills::Skill2HPiercing;
 
 	} /*skills*/

common/patches/rof2_ops.h

@@ -98,7 +98,6 @@ E(OP_MoveItem)
 E(OP_NewSpawn)
 E(OP_NewZone)
 E(OP_OnLevelMessage)
-//E(OP_OpenNewTasksWindow)
 E(OP_PetBuffWindow)
 E(OP_PlayerProfile)
 E(OP_RaidJoin)

common/patches/rof2_structs.h

@@ -957,13 +957,13 @@ struct BandolierItem_Struct_Old
 struct Bandolier_Struct
 {
 	char Name[1];	// Variable Length
-	BandolierItem_Struct Items[profile::BandolierItemCount];
+	BandolierItem_Struct Items[profile::BANDOLIER_ITEM_COUNT];
 };
 
 struct Bandolier_Struct_Old
 {
 	char Name[32];
-	BandolierItem_Struct Items[profile::BandolierItemCount];
+	BandolierItem_Struct Items[profile::BANDOLIER_ITEM_COUNT];
 };
 
 struct PotionBeltItem_Struct
@@ -983,12 +983,12 @@ struct PotionBeltItem_Struct_Old
 
 struct PotionBelt_Struct
 {
-	PotionBeltItem_Struct Items[profile::PotionBeltSize];
+	PotionBeltItem_Struct Items[profile::POTION_BELT_SIZE];
 };
 
 struct PotionBelt_Struct_Old
 {
-	PotionBeltItem_Struct_Old Items[profile::PotionBeltSize];
+	PotionBeltItem_Struct_Old Items[profile::POTION_BELT_SIZE];
 };
 
 struct GroupLeadershipAA_Struct {
@@ -1198,7 +1198,7 @@ union
 /*12949*/ uint32 aapoints;				// Unspent AA points - Seen 1
 /*12953*/ uint16 unknown_rof20;			//
 /*12955*/ uint32 bandolier_count;		// Seen 20
-/*12959*/ Bandolier_Struct bandoliers[profile::BandoliersSize]; // [20] 740 bytes (Variable Name Sizes) - bandolier contents
+/*12959*/ Bandolier_Struct bandoliers[profile::BANDOLIERS_SIZE]; // [20] 740 bytes (Variable Name Sizes) - bandolier contents
 /*13699*/ uint32 potionbelt_count;		// Seen 5
 /*13703*/ PotionBelt_Struct potionbelt;	// [5] 45 bytes potion belt - (Variable Name Sizes)
 /*13748*/ int32 unknown_rof21;			// Seen -1
@@ -2346,7 +2346,6 @@ struct AltCurrencySelectItem_Struct
 /*064*/ uint32 unknown064;
 /*068*/ uint32 unknown068;
 /*072*/ uint32 unknown072;
-/*076*/ uint32 unknown076;
 };
 
 //Server -> Client

common/patches/rof_limits.cpp

@@ -22,227 +22,227 @@
 #include "../string_util.h"
 
 
-size_t RoF::invtype::GetInvTypeSize(int inv_type)
+int16 RoF::invtype::GetInvTypeSize(int16 inv_type)
 {
 	switch (inv_type) {
-	case invtype::InvTypePossessions:
-		return invtype::InvTypePossessionsSize;
-	case invtype::InvTypeBank:
-		return invtype::InvTypeBankSize;
-	case invtype::InvTypeSharedBank:
-		return invtype::InvTypeSharedBankSize;
-	case invtype::InvTypeTrade:
-		return invtype::InvTypeTradeSize;
-	case invtype::InvTypeWorld:
-		return invtype::InvTypeWorldSize;
-	case invtype::InvTypeLimbo:
-		return invtype::InvTypeLimboSize;
-	case invtype::InvTypeTribute:
-		return invtype::InvTypeTributeSize;
-	case invtype::InvTypeTrophyTribute:
-		return invtype::InvTypeTrophyTributeSize;
-	case invtype::InvTypeGuildTribute:
-		return invtype::InvTypeGuildTributeSize;
-	case invtype::InvTypeMerchant:
-		return invtype::InvTypeMerchantSize;
-	case invtype::InvTypeDeleted:
-		return invtype::InvTypeDeletedSize;
-	case invtype::InvTypeCorpse:
-		return invtype::InvTypeCorpseSize;
-	case invtype::InvTypeBazaar:
-		return invtype::InvTypeBazaarSize;
-	case invtype::InvTypeInspect:
-		return invtype::InvTypeInspectSize;
-	case invtype::InvTypeRealEstate:
-		return invtype::InvTypeRealEstateSize;
-	case invtype::InvTypeViewMODPC:
-		return invtype::InvTypeViewMODPCSize;
-	case invtype::InvTypeViewMODBank:
-		return invtype::InvTypeViewMODBankSize;
-	case invtype::InvTypeViewMODSharedBank:
-		return invtype::InvTypeViewMODSharedBankSize;
-	case invtype::InvTypeViewMODLimbo:
-		return invtype::InvTypeViewMODLimboSize;
-	case invtype::InvTypeAltStorage:
-		return invtype::InvTypeAltStorageSize;
-	case invtype::InvTypeArchived:
-		return invtype::InvTypeArchivedSize;
-	case invtype::InvTypeMail:
-		return invtype::InvTypeMailSize;
-	case invtype::InvTypeGuildTrophyTribute:
-		return invtype::InvTypeGuildTrophyTributeSize;
-	case invtype::InvTypeOther:
-		return invtype::InvTypeOtherSize;
+	case invtype::typePossessions:
+		return invtype::POSSESSIONS_SIZE;
+	case invtype::typeBank:
+		return invtype::BANK_SIZE;
+	case invtype::typeSharedBank:
+		return invtype::SHARED_BANK_SIZE;
+	case invtype::typeTrade:
+		return invtype::TRADE_SIZE;
+	case invtype::typeWorld:
+		return invtype::WORLD_SIZE;
+	case invtype::typeLimbo:
+		return invtype::LIMBO_SIZE;
+	case invtype::typeTribute:
+		return invtype::TRIBUTE_SIZE;
+	case invtype::typeTrophyTribute:
+		return invtype::TROPHY_TRIBUTE_SIZE;
+	case invtype::typeGuildTribute:
+		return invtype::GUILD_TRIBUTE_SIZE;
+	case invtype::typeMerchant:
+		return invtype::MERCHANT_SIZE;
+	case invtype::typeDeleted:
+		return invtype::DELETED_SIZE;
+	case invtype::typeCorpse:
+		return invtype::CORPSE_SIZE;
+	case invtype::typeBazaar:
+		return invtype::BAZAAR_SIZE;
+	case invtype::typeInspect:
+		return invtype::INSPECT_SIZE;
+	case invtype::typeRealEstate:
+		return invtype::REAL_ESTATE_SIZE;
+	case invtype::typeViewMODPC:
+		return invtype::VIEW_MOD_PC_SIZE;
+	case invtype::typeViewMODBank:
+		return invtype::VIEW_MOD_BANK_SIZE;
+	case invtype::typeViewMODSharedBank:
+		return invtype::VIEW_MOD_SHARED_BANK_SIZE;
+	case invtype::typeViewMODLimbo:
+		return invtype::VIEW_MOD_LIMBO_SIZE;
+	case invtype::typeAltStorage:
+		return invtype::ALT_STORAGE_SIZE;
+	case invtype::typeArchived:
+		return invtype::ARCHIVED_SIZE;
+	case invtype::typeMail:
+		return invtype::MAIL_SIZE;
+	case invtype::typeGuildTrophyTribute:
+		return invtype::GUILD_TROPHY_TRIBUTE_SIZE;
+	case invtype::typeOther:
+		return invtype::OTHER_SIZE;
 	default:
-		return 0;
+		return INULL;
 	}
 }
 
-const char* RoF::invtype::GetInvTypeName(int inv_type)
+const char* RoF::invtype::GetInvTypeName(int16 inv_type)
 {
 	switch (inv_type) {
-	case invtype::InvTypeInvalid:
+	case invtype::TYPE_INVALID:
 		return "Invalid Type";
-	case invtype::InvTypePossessions:
+	case invtype::typePossessions:
 		return "Possessions";
-	case invtype::InvTypeBank:
+	case invtype::typeBank:
 		return "Bank";
-	case invtype::InvTypeSharedBank:
+	case invtype::typeSharedBank:
 		return "Shared Bank";
-	case invtype::InvTypeTrade:
+	case invtype::typeTrade:
 		return "Trade";
-	case invtype::InvTypeWorld:
+	case invtype::typeWorld:
 		return "World";
-	case invtype::InvTypeLimbo:
+	case invtype::typeLimbo:
 		return "Limbo";
-	case invtype::InvTypeTribute:
+	case invtype::typeTribute:
 		return "Tribute";
-	case invtype::InvTypeTrophyTribute:
+	case invtype::typeTrophyTribute:
 		return "Trophy Tribute";
-	case invtype::InvTypeGuildTribute:
+	case invtype::typeGuildTribute:
 		return "Guild Tribute";
-	case invtype::InvTypeMerchant:
+	case invtype::typeMerchant:
 		return "Merchant";
-	case invtype::InvTypeDeleted:
+	case invtype::typeDeleted:
 		return "Deleted";
-	case invtype::InvTypeCorpse:
+	case invtype::typeCorpse:
 		return "Corpse";
-	case invtype::InvTypeBazaar:
+	case invtype::typeBazaar:
 		return "Bazaar";
-	case invtype::InvTypeInspect:
+	case invtype::typeInspect:
 		return "Inspect";
-	case invtype::InvTypeRealEstate:
+	case invtype::typeRealEstate:
 		return "Real Estate";
-	case invtype::InvTypeViewMODPC:
+	case invtype::typeViewMODPC:
 		return "View MOD PC";
-	case invtype::InvTypeViewMODBank:
+	case invtype::typeViewMODBank:
 		return "View MOD Bank";
-	case invtype::InvTypeViewMODSharedBank:
+	case invtype::typeViewMODSharedBank:
 		return "View MOD Shared Bank";
-	case invtype::InvTypeViewMODLimbo:
+	case invtype::typeViewMODLimbo:
 		return "View MOD Limbo";
-	case invtype::InvTypeAltStorage:
+	case invtype::typeAltStorage:
 		return "Alt Storage";
-	case invtype::InvTypeArchived:
+	case invtype::typeArchived:
 		return "Archived";
-	case invtype::InvTypeMail:
+	case invtype::typeMail:
 		return "Mail";
-	case invtype::InvTypeGuildTrophyTribute:
+	case invtype::typeGuildTrophyTribute:
 		return "Guild Trophy Tribute";
-	case invtype::InvTypeOther:
+	case invtype::typeOther:
 		return "Other";
 	default:
 		return "Unknown Type";
 	}
 }
 
-bool RoF::invtype::IsInvTypePersistent(int inv_type)
+bool RoF::invtype::IsInvTypePersistent(int16 inv_type)
 {
 	switch (inv_type) {
-	case invtype::InvTypePossessions:
-	case invtype::InvTypeBank:
-	case invtype::InvTypeSharedBank:
-	case invtype::InvTypeTrade:
-	case invtype::InvTypeWorld:
-	case invtype::InvTypeLimbo:
-	case invtype::InvTypeTribute:
-	case invtype::InvTypeTrophyTribute:
-	case invtype::InvTypeGuildTribute:
+	case invtype::typePossessions:
+	case invtype::typeBank:
+	case invtype::typeSharedBank:
+	case invtype::typeTrade:
+	case invtype::typeWorld:
+	case invtype::typeLimbo:
+	case invtype::typeTribute:
+	case invtype::typeTrophyTribute:
+	case invtype::typeGuildTribute:
 		return true;
 	default:
 		return false;
 	}
 }
 
-const char* RoF::invslot::GetInvPossessionsSlotName(int inv_slot)
+const char* RoF::invslot::GetInvPossessionsSlotName(int16 inv_slot)
 {
 	switch (inv_slot) {
-	case invslot::InvSlotInvalid:
+	case invslot::SLOT_INVALID:
 		return "Invalid Slot";
-	case invslot::PossessionsCharm:
+	case invslot::slotCharm:
 		return "Charm";
-	case invslot::PossessionsEar1:
+	case invslot::slotEar1:
 		return "Ear 1";
-	case invslot::PossessionsHead:
+	case invslot::slotHead:
 		return "Head";
-	case invslot::PossessionsFace:
+	case invslot::slotFace:
 		return "Face";
-	case invslot::PossessionsEar2:
+	case invslot::slotEar2:
 		return "Ear 2";
-	case invslot::PossessionsNeck:
+	case invslot::slotNeck:
 		return "Neck";
-	case invslot::PossessionsShoulders:
+	case invslot::slotShoulders:
 		return "Shoulders";
-	case invslot::PossessionsArms:
+	case invslot::slotArms:
 		return "Arms";
-	case invslot::PossessionsBack:
+	case invslot::slotBack:
 		return "Back";
-	case invslot::PossessionsWrist1:
+	case invslot::slotWrist1:
 		return "Wrist 1";
-	case invslot::PossessionsWrist2:
+	case invslot::slotWrist2:
 		return "Wrist 2";
-	case invslot::PossessionsRange:
+	case invslot::slotRange:
 		return "Range";
-	case invslot::PossessionsHands:
+	case invslot::slotHands:
 		return "Hands";
-	case invslot::PossessionsPrimary:
+	case invslot::slotPrimary:
 		return "Primary";
-	case invslot::PossessionsSecondary:
+	case invslot::slotSecondary:
 		return "Secondary";
-	case invslot::PossessionsFinger1:
+	case invslot::slotFinger1:
 		return "Finger 1";
-	case invslot::PossessionsFinger2:
+	case invslot::slotFinger2:
 		return "Finger 2";
-	case invslot::PossessionsChest:
+	case invslot::slotChest:
 		return "Chest";
-	case invslot::PossessionsLegs:
+	case invslot::slotLegs:
 		return "Legs";
-	case invslot::PossessionsFeet:
+	case invslot::slotFeet:
 		return "Feet";
-	case invslot::PossessionsWaist:
+	case invslot::slotWaist:
 		return "Waist";
-	case invslot::PossessionsPowerSource:
+	case invslot::slotPowerSource:
 		return "Power Source";
-	case invslot::PossessionsAmmo:
+	case invslot::slotAmmo:
 		return "Ammo";
-	case invslot::PossessionsGeneral1:
+	case invslot::slotGeneral1:
 		return "General 1";
-	case invslot::PossessionsGeneral2:
+	case invslot::slotGeneral2:
 		return "General 2";
-	case invslot::PossessionsGeneral3:
+	case invslot::slotGeneral3:
 		return "General 3";
-	case invslot::PossessionsGeneral4:
+	case invslot::slotGeneral4:
 		return "General 4";
-	case invslot::PossessionsGeneral5:
+	case invslot::slotGeneral5:
 		return "General 5";
-	case invslot::PossessionsGeneral6:
+	case invslot::slotGeneral6:
 		return "General 6";
-	case invslot::PossessionsGeneral7:
+	case invslot::slotGeneral7:
 		return "General 7";
-	case invslot::PossessionsGeneral8:
+	case invslot::slotGeneral8:
 		return "General 8";
-	case invslot::PossessionsGeneral9:
+	case invslot::slotGeneral9:
 		return "General 9";
-	case invslot::PossessionsGeneral10:
+	case invslot::slotGeneral10:
 		return "General 10";
-	case invslot::PossessionsCursor:
+	case invslot::slotCursor:
 		return "Cursor";
 	default:
 		return "Unknown Slot";
 	}
 }
 
-const char* RoF::invslot::GetInvSlotName(int inv_type, int inv_slot)
+const char* RoF::invslot::GetInvSlotName(int16 inv_type, int16 inv_slot)
 {
-	if (inv_type == invtype::InvTypePossessions)
+	if (inv_type == invtype::typePossessions)
 		return invslot::GetInvPossessionsSlotName(inv_slot);
 
-	size_t type_size = invtype::GetInvTypeSize(inv_type);
+	int16 type_size = invtype::GetInvTypeSize(inv_type);
 
-	if (!type_size || inv_slot == invslot::InvSlotInvalid)
+	if (!type_size || inv_slot == invslot::SLOT_INVALID)
 		return "Invalid Slot";
 
-	if ((size_t)(inv_slot + 1) >= type_size)
+	if ((inv_slot + 1) >= type_size)
 		return "Unknown Slot";
 
 	static std::string ret_str;
@@ -251,12 +251,12 @@ const char* RoF::invslot::GetInvSlotName(int inv_type, int inv_slot)
 	return ret_str.c_str();
 }
 
-const char* RoF::invbag::GetInvBagIndexName(int bag_index)
+const char* RoF::invbag::GetInvBagIndexName(int16 bag_index)
 {
-	if (bag_index == invbag::InvBagInvalid)
+	if (bag_index == invbag::SLOT_INVALID)
 		return "Invalid Bag";
 
-	if ((size_t)bag_index >= invbag::ItemBagSize)
+	if (bag_index >= invbag::SLOT_COUNT)
 		return "Unknown Bag";
 
 	static std::string ret_str;
@@ -265,12 +265,12 @@ const char* RoF::invbag::GetInvBagIndexName(int bag_index)
 	return ret_str.c_str();
 }
 
-const char* RoF::invaug::GetInvAugIndexName(int aug_index)
+const char* RoF::invaug::GetInvAugIndexName(int16 aug_index)
 {
-	if (aug_index == invaug::InvAugInvalid)
+	if (aug_index == invaug::SOCKET_INVALID)
 		return "Invalid Augment";
 
-	if ((size_t)aug_index >= invaug::ItemAugSize)
+	if (aug_index >= invaug::SOCKET_COUNT)
 		return "Unknown Augment";
 
 	static std::string ret_str;

common/patches/rof_limits.h

@@ -27,115 +27,189 @@
 
 namespace RoF
 {
-	enum : int { Invalid = -1, Null, Safety };
+	const int16 IINVALID = -1;
+	const int16 INULL = 0;
 
-	enum : bool { False = false, True = true };
-
-	// pre-declarations
 	namespace inventory {
 		inline EQEmu::versions::ClientVersion GetInventoryRef() { return EQEmu::versions::ClientVersion::RoF; }
 
+		const bool ConcatenateInvTypeLimbo = false;
+
+		const bool AllowOverLevelEquipment = true;
+
+		const bool AllowEmptyBagInBag = true;
+		const bool AllowClickCastFromBag = true;
+
 	} /*inventory*/
 
 	namespace invtype {
 		inline EQEmu::versions::ClientVersion GetInvTypeRef() { return EQEmu::versions::ClientVersion::RoF; }
 
-		enum : int { InvTypeInvalid = -1, InvTypeBegin };
+		namespace enum_ {
+			enum InventoryTypes : int16 {
+				typePossessions = INULL,
+				typeBank,
+				typeSharedBank,
+				typeTrade,
+				typeWorld,
+				typeLimbo,
+				typeTribute,
+				typeTrophyTribute,
+				typeGuildTribute,
+				typeMerchant,
+				typeDeleted,
+				typeCorpse,
+				typeBazaar,
+				typeInspect,
+				typeRealEstate,
+				typeViewMODPC,
+				typeViewMODBank,
+				typeViewMODSharedBank,
+				typeViewMODLimbo,
+				typeAltStorage,
+				typeArchived,
+				typeMail,
+				typeGuildTrophyTribute,
+				typeOther
+			};
 
-		enum InventoryType : int {
-			InvTypePossessions = InvTypeBegin,
-			InvTypeBank,
-			InvTypeSharedBank,
-			InvTypeTrade,
-			InvTypeWorld,
-			InvTypeLimbo,
-			InvTypeTribute,
-			InvTypeTrophyTribute,
-			InvTypeGuildTribute,
-			InvTypeMerchant,
-			InvTypeDeleted,
-			InvTypeCorpse,
-			InvTypeBazaar,
-			InvTypeInspect,
-			InvTypeRealEstate,
-			InvTypeViewMODPC,
-			InvTypeViewMODBank,
-			InvTypeViewMODSharedBank,
-			InvTypeViewMODLimbo,
-			InvTypeAltStorage,
-			InvTypeArchived,
-			InvTypeMail,
-			InvTypeGuildTrophyTribute,
-			InvTypeOther,
-			InvTypeCount
-		};
+		} // namespace enum_
+		using namespace enum_;
+
+		const int16 POSSESSIONS_SIZE = 34;
+		const int16 BANK_SIZE = 24;
+		const int16 SHARED_BANK_SIZE = 2;
+		const int16 TRADE_SIZE = 8;
+		const int16 WORLD_SIZE = 10;
+		const int16 LIMBO_SIZE = 36;
+		const int16 TRIBUTE_SIZE = 5;
+		const int16 TROPHY_TRIBUTE_SIZE = 0;//unknown
+		const int16 GUILD_TRIBUTE_SIZE = 2;//unverified
+		const int16 MERCHANT_SIZE = 200;
+		const int16 DELETED_SIZE = 0;//unknown - "Recovery Tab"
+		const int16 CORPSE_SIZE = POSSESSIONS_SIZE;
+		const int16 BAZAAR_SIZE = 200;
+		const int16 INSPECT_SIZE = 23;
+		const int16 REAL_ESTATE_SIZE = 0;//unknown
+		const int16 VIEW_MOD_PC_SIZE = POSSESSIONS_SIZE;
+		const int16 VIEW_MOD_BANK_SIZE = BANK_SIZE;
+		const int16 VIEW_MOD_SHARED_BANK_SIZE = SHARED_BANK_SIZE;
+		const int16 VIEW_MOD_LIMBO_SIZE = LIMBO_SIZE;
+		const int16 ALT_STORAGE_SIZE = 0;//unknown - "Shroud Bank"
+		const int16 ARCHIVED_SIZE = 0;//unknown
+		const int16 MAIL_SIZE = 0;//unknown
+		const int16 GUILD_TROPHY_TRIBUTE_SIZE = 0;//unknown
+		const int16 OTHER_SIZE = 0;//unknown
+
+		const int16 TRADE_NPC_SIZE = 4; // defined by implication
+
+		const int16 TYPE_INVALID = IINVALID;
+		const int16 TYPE_BEGIN = typePossessions;
+		const int16 TYPE_END = typeOther;
+		const int16 TYPE_COUNT = (TYPE_END - TYPE_BEGIN) + 1;
+
+		int16 GetInvTypeSize(int16 inv_type);
+		const char* GetInvTypeName(int16 inv_type);
+
+		bool IsInvTypePersistent(int16 inv_type);
 
 	} /*invtype*/
 
 	namespace invslot {
 		inline EQEmu::versions::ClientVersion GetInvSlotRef() { return EQEmu::versions::ClientVersion::RoF; }
 
-		enum : int { InvSlotInvalid = -1, InvSlotBegin };
+		namespace enum_ {
+			enum InventorySlots : int16 {
+				slotCharm = INULL,
+				slotEar1,
+				slotHead,
+				slotFace,
+				slotEar2,
+				slotNeck,
+				slotShoulders,
+				slotArms,
+				slotBack,
+				slotWrist1,
+				slotWrist2,
+				slotRange,
+				slotHands,
+				slotPrimary,
+				slotSecondary,
+				slotFinger1,
+				slotFinger2,
+				slotChest,
+				slotLegs,
+				slotFeet,
+				slotWaist,
+				slotPowerSource,
+				slotAmmo,
+				slotGeneral1,
+				slotGeneral2,
+				slotGeneral3,
+				slotGeneral4,
+				slotGeneral5,
+				slotGeneral6,
+				slotGeneral7,
+				slotGeneral8,
+				slotGeneral9,
+				slotGeneral10,
+				slotCursor
+			};
 
-		enum PossessionsSlot : int {
-			PossessionsCharm = InvSlotBegin,
-			PossessionsEar1,
-			PossessionsHead,
-			PossessionsFace,
-			PossessionsEar2,
-			PossessionsNeck,
-			PossessionsShoulders,
-			PossessionsArms,
-			PossessionsBack,
-			PossessionsWrist1,
-			PossessionsWrist2,
-			PossessionsRange,
-			PossessionsHands,
-			PossessionsPrimary,
-			PossessionsSecondary,
-			PossessionsFinger1,
-			PossessionsFinger2,
-			PossessionsChest,
-			PossessionsLegs,
-			PossessionsFeet,
-			PossessionsWaist,
-			PossessionsPowerSource,
-			PossessionsAmmo,
-			PossessionsGeneral1,
-			PossessionsGeneral2,
-			PossessionsGeneral3,
-			PossessionsGeneral4,
-			PossessionsGeneral5,
-			PossessionsGeneral6,
-			PossessionsGeneral7,
-			PossessionsGeneral8,
-			PossessionsGeneral9,
-			PossessionsGeneral10,
-			PossessionsCursor,
-			PossessionsCount
-		};
+		} // namespace enum_
+		using namespace enum_;
 
-		const int EquipmentBegin = PossessionsCharm;
-		const int EquipmentEnd = PossessionsAmmo;
-		const int EquipmentCount = (EquipmentEnd - EquipmentBegin + 1);
+		const int16 SLOT_INVALID = IINVALID;
+		const int16 SLOT_BEGIN = INULL;
 
-		const int GeneralBegin = PossessionsGeneral1;
-		const int GeneralEnd = PossessionsGeneral10;
-		const int GeneralCount = (GeneralEnd - GeneralBegin + 1);
+		const int16 POSSESSIONS_BEGIN = slotCharm;
+		const int16 POSSESSIONS_END = slotCursor;
+		const int16 POSSESSIONS_COUNT = (POSSESSIONS_END - POSSESSIONS_BEGIN) + 1;
+
+		const int16 EQUIPMENT_BEGIN = slotCharm;
+		const int16 EQUIPMENT_END = slotAmmo;
+		const int16 EQUIPMENT_COUNT = (EQUIPMENT_END - EQUIPMENT_BEGIN + 1);
+
+		const int16 GENERAL_BEGIN = slotGeneral1;
+		const int16 GENERAL_END = slotGeneral10;
+		const int16 GENERAL_COUNT = (GENERAL_END - GENERAL_BEGIN + 1);
+
+		const int16 BONUS_BEGIN = invslot::slotCharm;
+		const int16 BONUS_STAT_END = invslot::slotPowerSource;
+		const int16 BONUS_SKILL_END = invslot::slotAmmo;
+
+		const int16 CORPSE_BEGIN = invslot::slotGeneral1;
+		const int16 CORPSE_END = invslot::slotGeneral1 + invslot::slotCursor;
+
+		const uint64 POSSESSIONS_BITMASK = 0x00000003FFFFFFFF; // based on 34-slot count (RoF+)
+		const uint64 CORPSE_BITMASK = 0x01FFFFFFFF800000; // based on 34-slot count (RoF+)
+
+		const char* GetInvPossessionsSlotName(int16 inv_slot);
+		const char* GetInvSlotName(int16 inv_type, int16 inv_slot);
 
 	} /*invslot*/
 
 	namespace invbag {
 		inline EQEmu::versions::ClientVersion GetInvBagRef() { return EQEmu::versions::ClientVersion::RoF; }
 
-		enum : int { InvBagInvalid = -1, InvBagBegin };
+		const int16 SLOT_INVALID = IINVALID;
+		const int16 SLOT_BEGIN = INULL;
+		const int16 SLOT_END = 9; //254;
+		const int16 SLOT_COUNT = 10; //255; // server Size will be 255..unsure what actual client is (test)
+
+		const char* GetInvBagIndexName(int16 bag_index);
 
 	} /*invbag*/
 
 	namespace invaug {
 		inline EQEmu::versions::ClientVersion GetInvAugRef() { return EQEmu::versions::ClientVersion::RoF; }
 
-		enum : int { InvAugInvalid = -1, InvAugBegin };
+		const int16 SOCKET_INVALID = IINVALID;
+		const int16 SOCKET_BEGIN = INULL;
+		const int16 SOCKET_END = 5;
+		const int16 SOCKET_COUNT = 6;
+
+		const char* GetInvAugIndexName(int16 aug_index);
 
 	} /*invaug*/
 
@@ -164,109 +238,21 @@ namespace RoF
 	namespace profile {
 		inline EQEmu::versions::ClientVersion GetProfileRef() { return EQEmu::versions::ClientVersion::RoF; }
 
+		const int16 BANDOLIERS_SIZE = 20;		// number of bandolier instances
+		const int16 BANDOLIER_ITEM_COUNT = 4;	// number of equipment slots in bandolier instance
+
+		const int16 POTION_BELT_SIZE = 5;
+
+		const int16 SKILL_ARRAY_SIZE = 100;
+
 	} /*profile*/
 
 	namespace constants {
 		inline EQEmu::versions::ClientVersion GetConstantsRef() { return EQEmu::versions::ClientVersion::RoF; }
 
-	} /*constants*/
+		const size_t CHARACTER_CREATION_LIMIT = 12;
 
-	namespace behavior {
-		inline EQEmu::versions::ClientVersion GetBehaviorRef() { return EQEmu::versions::ClientVersion::RoF; }
-
-	} /*behavior*/
-
-	namespace skills {
-		inline EQEmu::versions::ClientVersion GetSkillsRef() { return EQEmu::versions::ClientVersion::RoF; }
-
-	} /*skills*/
-
-
-	// declarations
-	namespace inventory {
-		const bool ConcatenateInvTypeLimbo = false;
-
-		const bool AllowOverLevelEquipment = true;
-
-		const bool AllowEmptyBagInBag = true;
-		const bool AllowClickCastFromBag = true;
-
-	} /*inventory*/
-
-	namespace invtype {
-		const size_t InvTypePossessionsSize = invslot::PossessionsCount;
-		const size_t InvTypeBankSize = 24;
-		const size_t InvTypeSharedBankSize = 2;
-		const size_t InvTypeTradeSize = 8;
-		const size_t InvTypeWorldSize = 10;
-		const size_t InvTypeLimboSize = 36;
-		const size_t InvTypeTributeSize = 5;
-		const size_t InvTypeTrophyTributeSize = 0;//unknown
-		const size_t InvTypeGuildTributeSize = 2;//unverified
-		const size_t InvTypeMerchantSize = 200;
-		const size_t InvTypeDeletedSize = 0;//unknown - "Recovery Tab"
-		const size_t InvTypeCorpseSize = InvTypePossessionsSize;
-		const size_t InvTypeBazaarSize = 200;
-		const size_t InvTypeInspectSize = invslot::EquipmentCount;
-		const size_t InvTypeRealEstateSize = 0;//unknown
-		const size_t InvTypeViewMODPCSize = InvTypePossessionsSize;
-		const size_t InvTypeViewMODBankSize = InvTypeBankSize;
-		const size_t InvTypeViewMODSharedBankSize = InvTypeSharedBankSize;
-		const size_t InvTypeViewMODLimboSize = InvTypeLimboSize;
-		const size_t InvTypeAltStorageSize = 0;//unknown - "Shroud Bank"
-		const size_t InvTypeArchivedSize = 0;//unknown
-		const size_t InvTypeMailSize = 0;//unknown
-		const size_t InvTypeGuildTrophyTributeSize = 0;//unknown
-		const size_t InvTypeOtherSize = 0;//unknown
-
-		extern size_t GetInvTypeSize(int inv_type);
-		extern const char* GetInvTypeName(int inv_type);
-
-		extern bool IsInvTypePersistent(int inv_type);
-
-	} /*invtype*/
-
-	namespace invslot {
-		extern const char* GetInvPossessionsSlotName(int inv_slot);
-		extern const char* GetInvSlotName(int inv_type, int inv_slot);
-
-	} /*invslot*/
-
-	namespace invbag {
-		const size_t ItemBagSize = 255; // server Size will be 255..unsure what actual client is (test)
-
-		extern const char* GetInvBagIndexName(int bag_index);
-
-	} /*invbag*/
-
-	namespace invaug {
-		const size_t ItemAugSize = 6;
-
-		extern const char* GetInvAugIndexName(int aug_index);
-
-	} /*invaug*/
-
-	namespace item {
-
-	} /*item*/
-
-	namespace profile {
-		const size_t TributeSize = invtype::InvTypeTributeSize;
-		const size_t GuildTributeSize = invtype::InvTypeGuildTributeSize;
-
-		const size_t BandoliersSize = 20;		// number of bandolier instances
-		const size_t BandolierItemCount = 4;	// number of equipment slots in bandolier instance
-
-		const size_t PotionBeltSize = 5;
-
-		const size_t SkillArraySize = 100;
-
-	} /*profile*/
-
-	namespace constants {
-		const size_t CharacterCreationLimit = 12;
-
-		const size_t SayLinkBodySize = 55;
+		const size_t SAY_LINK_BODY_SIZE = 55;
 
 		const int LongBuffs = 42;
 		const int ShortBuffs = 20;
@@ -279,11 +265,15 @@ namespace RoF
 	} /*constants*/
 
 	namespace behavior {
+		inline EQEmu::versions::ClientVersion GetBehaviorRef() { return EQEmu::versions::ClientVersion::RoF; }
+
 		const bool CoinHasWeight = false;
 
 	} /*behavior*/
 
 	namespace skills {
+		inline EQEmu::versions::ClientVersion GetSkillsRef() { return EQEmu::versions::ClientVersion::RoF; }
+
 		const size_t LastUsableSkill = EQEmu::skills::SkillTripleAttack;
 
 	} /*skills*/

common/patches/rof_ops.h

@@ -83,7 +83,6 @@ E(OP_MoveItem)
 E(OP_NewSpawn)
 E(OP_NewZone)
 E(OP_OnLevelMessage)
-//E(OP_OpenNewTasksWindow)
 E(OP_PetBuffWindow)
 E(OP_PlayerProfile)
 E(OP_RaidJoin)

common/patches/rof_structs.h

@@ -898,13 +898,13 @@ struct BandolierItem_Struct_Old
 struct Bandolier_Struct
 {
 	char Name[1];	// Variable Length
-	BandolierItem_Struct Items[profile::BandolierItemCount];
+	BandolierItem_Struct Items[profile::BANDOLIER_ITEM_COUNT];
 };
 
 struct Bandolier_Struct_Old
 {
 	char Name[32];
-	BandolierItem_Struct Items[profile::BandolierItemCount];
+	BandolierItem_Struct Items[profile::BANDOLIER_ITEM_COUNT];
 };
 
 struct PotionBeltItem_Struct
@@ -924,12 +924,12 @@ struct PotionBeltItem_Struct_Old
 
 struct PotionBelt_Struct
 {
-	PotionBeltItem_Struct Items[profile::PotionBeltSize];
+	PotionBeltItem_Struct Items[profile::POTION_BELT_SIZE];
 };
 
 struct PotionBelt_Struct_Old
 {
-	PotionBeltItem_Struct_Old Items[profile::PotionBeltSize];
+	PotionBeltItem_Struct_Old Items[profile::POTION_BELT_SIZE];
 };
 
 struct GroupLeadershipAA_Struct {
@@ -1139,7 +1139,7 @@ union
 /*12949*/ uint32 aapoints;				// Unspent AA points - Seen 1
 /*12953*/ uint16 unknown_rof20;			//
 /*12955*/ uint32 bandolier_count;		// Seen 20
-/*12959*/ Bandolier_Struct bandoliers[profile::BandoliersSize]; // [20] 740 bytes (Variable Name Sizes) - bandolier contents
+/*12959*/ Bandolier_Struct bandoliers[profile::BANDOLIERS_SIZE]; // [20] 740 bytes (Variable Name Sizes) - bandolier contents
 /*13699*/ uint32 potionbelt_count;		// Seen 5
 /*13703*/ PotionBelt_Struct potionbelt;	// [5] 45 bytes potion belt - (Variable Name Sizes)
 /*13748*/ int32 unknown_rof21;			// Seen -1

common/patches/sod.cpp

@@ -1383,114 +1383,6 @@ namespace SoD
 		FINISH_ENCODE();
 	}
 
-	ENCODE(OP_OpenNewTasksWindow)
-	{
-		AvailableTaskHeader_Struct*	__emu_AvailableTaskHeader;
-		AvailableTaskData1_Struct* 	__emu_AvailableTaskData1;
-		AvailableTaskData2_Struct* 	__emu_AvailableTaskData2;
-		AvailableTaskTrailer_Struct* 	__emu_AvailableTaskTrailer;
-
-		structs::AvailableTaskHeader_Struct*	__eq_AvailableTaskHeader;
-		structs::AvailableTaskData1_Struct* 	__eq_AvailableTaskData1;
-		structs::AvailableTaskData2_Struct* 	__eq_AvailableTaskData2;
-		structs::AvailableTaskTrailer_Struct* 	__eq_AvailableTaskTrailer;
-
-		EQApplicationPacket *in = *p;
-		*p = nullptr;
-
-		unsigned char *__emu_buffer = in->pBuffer;
-
-		__emu_AvailableTaskHeader = (AvailableTaskHeader_Struct*)__emu_buffer;
-
-		// For each task, SoF has an extra uint32 and what appears to be space for a null terminated string.
-		//
-		in->size = in->size + (__emu_AvailableTaskHeader->TaskCount * 5);
-		in->pBuffer = new unsigned char[in->size];
-		unsigned char *__eq_buffer = in->pBuffer;
-		__eq_AvailableTaskHeader = (structs::AvailableTaskHeader_Struct*)__eq_buffer;
-		char *__eq_ptr, *__emu_Ptr;
-
-		// Copy Header
-		//
-		//
-
-		__eq_AvailableTaskHeader->TaskCount = __emu_AvailableTaskHeader->TaskCount;
-		__eq_AvailableTaskHeader->unknown1 = __emu_AvailableTaskHeader->unknown1;
-		__eq_AvailableTaskHeader->TaskGiver = __emu_AvailableTaskHeader->TaskGiver;
-
-		__emu_Ptr = (char *)__emu_AvailableTaskHeader + sizeof(AvailableTaskHeader_Struct);
-		__eq_ptr = (char *)__eq_AvailableTaskHeader + sizeof(structs::AvailableTaskHeader_Struct);
-
-		for (uint32 i = 0; i<__emu_AvailableTaskHeader->TaskCount; i++) {
-
-			__emu_AvailableTaskData1 = (AvailableTaskData1_Struct*)__emu_Ptr;
-			__eq_AvailableTaskData1 = (structs::AvailableTaskData1_Struct*)__eq_ptr;
-
-			__eq_AvailableTaskData1->TaskID = __emu_AvailableTaskData1->TaskID;
-			// This next unknown seems to affect the colour of the task title. 0x3f80000 is what I have seen
-			// in Live packets. Changing it to 0x3f000000 makes the title red.
-			__eq_AvailableTaskData1->unknown1 = 0x3f800000;
-			__eq_AvailableTaskData1->TimeLimit = __emu_AvailableTaskData1->TimeLimit;
-			__eq_AvailableTaskData1->unknown2 = __emu_AvailableTaskData1->unknown2;
-
-			__emu_Ptr += sizeof(AvailableTaskData1_Struct);
-			__eq_ptr += sizeof(structs::AvailableTaskData1_Struct);
-
-			strcpy(__eq_ptr, __emu_Ptr); // Title
-
-			__emu_Ptr += strlen(__emu_Ptr) + 1;
-			__eq_ptr += strlen(__eq_ptr) + 1;
-
-			strcpy(__eq_ptr, __emu_Ptr); // Description
-
-			__emu_Ptr += strlen(__emu_Ptr) + 1;
-			__eq_ptr += strlen(__eq_ptr) + 1;
-
-			__eq_ptr[0] = 0;
-			__eq_ptr += strlen(__eq_ptr) + 1;
-
-			__emu_AvailableTaskData2 = (AvailableTaskData2_Struct*)__emu_Ptr;
-			__eq_AvailableTaskData2 = (structs::AvailableTaskData2_Struct*)__eq_ptr;
-
-			__eq_AvailableTaskData2->unknown1 = __emu_AvailableTaskData2->unknown1;
-			__eq_AvailableTaskData2->unknown2 = __emu_AvailableTaskData2->unknown2;
-			__eq_AvailableTaskData2->unknown3 = __emu_AvailableTaskData2->unknown3;
-			__eq_AvailableTaskData2->unknown4 = __emu_AvailableTaskData2->unknown4;
-
-			__emu_Ptr += sizeof(AvailableTaskData2_Struct);
-			__eq_ptr += sizeof(structs::AvailableTaskData2_Struct);
-
-			strcpy(__eq_ptr, __emu_Ptr); // Unknown string
-
-			__emu_Ptr += strlen(__emu_Ptr) + 1;
-			__eq_ptr += strlen(__eq_ptr) + 1;
-
-			strcpy(__eq_ptr, __emu_Ptr); // Unknown string
-
-			__emu_Ptr += strlen(__emu_Ptr) + 1;
-			__eq_ptr += strlen(__eq_ptr) + 1;
-
-			__emu_AvailableTaskTrailer = (AvailableTaskTrailer_Struct*)__emu_Ptr;
-			__eq_AvailableTaskTrailer = (structs::AvailableTaskTrailer_Struct*)__eq_ptr;
-
-			__eq_AvailableTaskTrailer->ItemCount = __emu_AvailableTaskTrailer->ItemCount;
-			__eq_AvailableTaskTrailer->unknown1 = __emu_AvailableTaskTrailer->unknown1;
-			__eq_AvailableTaskTrailer->unknown2 = __emu_AvailableTaskTrailer->unknown2;
-			__eq_AvailableTaskTrailer->StartZone = __emu_AvailableTaskTrailer->StartZone;
-
-			__emu_Ptr += sizeof(AvailableTaskTrailer_Struct);
-			__eq_ptr += sizeof(structs::AvailableTaskTrailer_Struct);
-
-			strcpy(__eq_ptr, __emu_Ptr); // Unknown string
-
-			__emu_Ptr += strlen(__emu_Ptr) + 1;
-			__eq_ptr += strlen(__eq_ptr) + 1;
-		}
-
-		delete[] __emu_buffer;
-		dest->FastQueuePacket(&in, ack_req);
-	}
-
 	ENCODE(OP_PetBuffWindow)
 	{
 		EQApplicationPacket *in = *p;
@@ -1632,18 +1524,18 @@ namespace SoD
 		//	OUT(unknown06160[4]);
 
 		// Copy bandoliers where server and client indexes converge
-		for (r = 0; r < EQEmu::legacy::BANDOLIERS_SIZE && r < profile::BandoliersSize; ++r) {
+		for (r = 0; r < EQEmu::profile::BANDOLIERS_SIZE && r < profile::BANDOLIERS_SIZE; ++r) {
 			OUT_str(bandoliers[r].Name);
-			for (uint32 k = 0; k < profile::BandolierItemCount; ++k) { // Will need adjusting if 'server != client' is ever true
+			for (uint32 k = 0; k < profile::BANDOLIER_ITEM_COUNT; ++k) { // Will need adjusting if 'server != client' is ever true
 				OUT(bandoliers[r].Items[k].ID);
 				OUT(bandoliers[r].Items[k].Icon);
 				OUT_str(bandoliers[r].Items[k].Name);
 			}
 		}
 		// Nullify bandoliers where server and client indexes diverge, with a client bias
-		for (r = EQEmu::legacy::BANDOLIERS_SIZE; r < profile::BandoliersSize; ++r) {
+		for (r = EQEmu::profile::BANDOLIERS_SIZE; r < profile::BANDOLIERS_SIZE; ++r) {
 			eq->bandoliers[r].Name[0] = '\0';
-			for (uint32 k = 0; k < profile::BandolierItemCount; ++k) { // Will need adjusting if 'server != client' is ever true
+			for (uint32 k = 0; k < profile::BANDOLIER_ITEM_COUNT; ++k) { // Will need adjusting if 'server != client' is ever true
 				eq->bandoliers[r].Items[k].ID = 0;
 				eq->bandoliers[r].Items[k].Icon = 0;
 				eq->bandoliers[r].Items[k].Name[0] = '\0';
@@ -1653,13 +1545,13 @@ namespace SoD
 		//	OUT(unknown07444[5120]);
 
 		// Copy potion belt where server and client indexes converge
-		for (r = 0; r < EQEmu::legacy::POTION_BELT_ITEM_COUNT && r < profile::PotionBeltSize; ++r) {
+		for (r = 0; r < EQEmu::profile::POTION_BELT_SIZE && r < profile::POTION_BELT_SIZE; ++r) {
 			OUT(potionbelt.Items[r].ID);
 			OUT(potionbelt.Items[r].Icon);
 			OUT_str(potionbelt.Items[r].Name);
 		}
 		// Nullify potion belt where server and client indexes diverge, with a client bias
-		for (r = EQEmu::legacy::POTION_BELT_ITEM_COUNT; r < profile::PotionBeltSize; ++r) {
+		for (r = EQEmu::profile::POTION_BELT_SIZE; r < profile::POTION_BELT_SIZE; ++r) {
 			eq->potionbelt.Items[r].ID = 0;
 			eq->potionbelt.Items[r].Icon = 0;
 			eq->potionbelt.Items[r].Name[0] = '\0';
@@ -1947,8 +1839,8 @@ namespace SoD
 			eq->CharCount = emu->CharCount;
 			eq->TotalChars = emu->TotalChars;
 
-			if (eq->TotalChars > constants::CharacterCreationLimit)
-				eq->TotalChars = constants::CharacterCreationLimit;
+			if (eq->TotalChars > constants::CHARACTER_CREATION_LIMIT)
+				eq->TotalChars = constants::CHARACTER_CREATION_LIMIT;
 
 			FINISH_ENCODE();
 			return;
@@ -1960,7 +1852,7 @@ namespace SoD
 
 		size_t names_length = 0;
 		size_t character_count = 0;
-		for (; character_count < emu->CharCount && character_count < constants::CharacterCreationLimit; ++character_count) {
+		for (; character_count < emu->CharCount && character_count < constants::CHARACTER_CREATION_LIMIT; ++character_count) {
 			emu_cse = (CharacterSelectEntry_Struct *)emu_ptr;
 			names_length += strlen(emu_cse->Name);
 			emu_ptr += sizeof(CharacterSelectEntry_Struct);
@@ -1976,8 +1868,8 @@ namespace SoD
 		eq->CharCount = character_count;
 		eq->TotalChars = emu->TotalChars;
 
-		if (eq->TotalChars > constants::CharacterCreationLimit)
-			eq->TotalChars = constants::CharacterCreationLimit;
+		if (eq->TotalChars > constants::CHARACTER_CREATION_LIMIT)
+			eq->TotalChars = constants::CHARACTER_CREATION_LIMIT;
 
 		emu_ptr = __emu_buffer;
 		emu_ptr += sizeof(CharacterSelect_Struct);
@@ -2249,13 +2141,16 @@ namespace SoD
 		InBuffer += description_size;
 		InBuffer += sizeof(TaskDescriptionData2_Struct);
 
-		std::string old_message = InBuffer; // start 'Reward' as string
+		uint32 reward_size = strlen(InBuffer) + 1;
+		InBuffer += reward_size;
+
+		std::string old_message = InBuffer; // start item link string
 		std::string new_message;
 		ServerToSoDSayLink(new_message, old_message);
 
 		in->size = sizeof(TaskDescriptionHeader_Struct) + sizeof(TaskDescriptionData1_Struct)+
 			sizeof(TaskDescriptionData2_Struct) + sizeof(TaskDescriptionTrailer_Struct)+
-			title_size + description_size + new_message.length() + 1;
+			title_size + description_size + reward_size + new_message.length() + 1;
 
 		in->pBuffer = new unsigned char[in->size];
 
@@ -3578,7 +3473,7 @@ namespace SoD
 		ibs.nodrop = item->NoDrop;
 		ibs.attune = item->Attuneable;
 		ibs.size = item->Size;
-		ibs.slots = SwapBits21and22(item->Slots);
+		ibs.slots = SwapBits21And22(item->Slots);
 		ibs.price = item->Price;
 		ibs.icon = item->Icon;
 		ibs.unknown1 = 1;
@@ -3668,7 +3563,7 @@ namespace SoD
 		isbs.augtype = item->AugType;
 		isbs.augrestrict = item->AugRestrict;
 
-		for (int index = 0; index < invaug::ItemAugSize; ++index) {
+		for (int index = invaug::SOCKET_BEGIN; index <= invaug::SOCKET_END; ++index) {
 			isbs.augslots[index].type = item->AugSlotType[index];
 			isbs.augslots[index].visible = item->AugSlotVisible[index];
 			isbs.augslots[index].unknown = item->AugSlotUnk2[index];
@@ -3841,18 +3736,18 @@ namespace SoD
 
 		ob.write((const char*)&subitem_count, sizeof(uint32));
 
-		for (uint32 index = EQEmu::inventory::containerBegin; index < EQEmu::inventory::ContainerCount; ++index) {
+		for (uint32 index = EQEmu::invbag::SLOT_BEGIN; index <= EQEmu::invbag::SLOT_END; ++index) {
 			EQEmu::ItemInstance* sub = inst->GetItem(index);
 			if (!sub)
 				continue;
 
 			int SubSlotNumber = INVALID_INDEX;
-			if (slot_id_in >= EQEmu::legacy::GENERAL_BEGIN && slot_id_in <= EQEmu::legacy::GENERAL_END)
-				SubSlotNumber = (((slot_id_in + 3) * EQEmu::inventory::ContainerCount) + index + 1);
-			else if (slot_id_in >= EQEmu::legacy::BANK_BEGIN && slot_id_in <= EQEmu::legacy::BANK_END)
-				SubSlotNumber = (((slot_id_in - EQEmu::legacy::BANK_BEGIN) * EQEmu::inventory::ContainerCount) + EQEmu::legacy::BANK_BAGS_BEGIN + index);
-			else if (slot_id_in >= EQEmu::legacy::SHARED_BANK_BEGIN && slot_id_in <= EQEmu::legacy::SHARED_BANK_END)
-				SubSlotNumber = (((slot_id_in - EQEmu::legacy::SHARED_BANK_BEGIN) * EQEmu::inventory::ContainerCount) + EQEmu::legacy::SHARED_BANK_BAGS_BEGIN + index);
+			if (slot_id_in >= EQEmu::invslot::GENERAL_BEGIN && slot_id_in <= EQEmu::invslot::GENERAL_END)
+				SubSlotNumber = (((slot_id_in + 3) * EQEmu::invbag::SLOT_COUNT) + index + 1);
+			else if (slot_id_in >= EQEmu::invslot::BANK_BEGIN && slot_id_in <= EQEmu::invslot::BANK_END)
+				SubSlotNumber = (((slot_id_in - EQEmu::invslot::BANK_BEGIN) * EQEmu::invbag::SLOT_COUNT) + EQEmu::invbag::BANK_BAGS_BEGIN + index);
+			else if (slot_id_in >= EQEmu::invslot::SHARED_BANK_BEGIN && slot_id_in <= EQEmu::invslot::SHARED_BANK_END)
+				SubSlotNumber = (((slot_id_in - EQEmu::invslot::SHARED_BANK_BEGIN) * EQEmu::invbag::SLOT_COUNT) + EQEmu::invbag::SHARED_BANK_BAGS_BEGIN + index);
 			else
 				SubSlotNumber = slot_id_in;
 
@@ -3870,16 +3765,16 @@ namespace SoD
 	{
 		uint32 SoDSlot = 0;
 
-		if (serverSlot >= EQEmu::inventory::slotAmmo && serverSlot <= 53) // Cursor/Ammo/Power Source and Normal Inventory Slots
+		if (serverSlot >= EQEmu::invslot::slotAmmo && serverSlot <= 53) // Cursor/Ammo/Power Source and Normal Inventory Slots
 			SoDSlot = serverSlot + 1;
-		else if (serverSlot >= EQEmu::legacy::GENERAL_BAGS_BEGIN && serverSlot <= EQEmu::legacy::CURSOR_BAG_END)
+		else if (serverSlot >= EQEmu::invbag::GENERAL_BAGS_BEGIN && serverSlot <= EQEmu::invbag::CURSOR_BAG_END)
 			SoDSlot = serverSlot + 11;
-		else if (serverSlot >= EQEmu::legacy::BANK_BAGS_BEGIN && serverSlot <= EQEmu::legacy::BANK_BAGS_END)
+		else if (serverSlot >= EQEmu::invbag::BANK_BAGS_BEGIN && serverSlot <= EQEmu::invbag::BANK_BAGS_END)
 			SoDSlot = serverSlot + 1;
-		else if (serverSlot >= EQEmu::legacy::SHARED_BANK_BAGS_BEGIN && serverSlot <= EQEmu::legacy::SHARED_BANK_BAGS_END)
+		else if (serverSlot >= EQEmu::invbag::SHARED_BANK_BAGS_BEGIN && serverSlot <= EQEmu::invbag::SHARED_BANK_BAGS_END)
 			SoDSlot = serverSlot + 1;
-		else if (serverSlot == EQEmu::inventory::slotPowerSource)
-			SoDSlot = invslot::PossessionsPowerSource;
+		else if (serverSlot == EQEmu::invslot::SLOT_POWER_SOURCE)
+			SoDSlot = invslot::slotPowerSource;
 		else
 			SoDSlot = serverSlot;
 		return SoDSlot;
@@ -3895,16 +3790,16 @@ namespace SoD
 	{
 		uint32 ServerSlot = 0;
 
-		if (sodSlot >= invslot::PossessionsAmmo && sodSlot <= invslot::CorpseEnd) // Cursor/Ammo/Power Source and Normal Inventory Slots
+		if (sodSlot >= invslot::slotAmmo && sodSlot <= invslot::CORPSE_END) // Cursor/Ammo/Power Source and Normal Inventory Slots
 			ServerSlot = sodSlot - 1;
-		else if (sodSlot >= invbag::GeneralBagsBegin && sodSlot <= invbag::CursorBagEnd)
+		else if (sodSlot >= invbag::GENERAL_BAGS_BEGIN && sodSlot <= invbag::CURSOR_BAG_END)
 			ServerSlot = sodSlot - 11;
-		else if (sodSlot >= invbag::BankBagsBegin && sodSlot <= invbag::BankBagsEnd)
+		else if (sodSlot >= invbag::BANK_BAGS_BEGIN && sodSlot <= invbag::BANK_BAGS_END)
 			ServerSlot = sodSlot - 1;
-		else if (sodSlot >= invbag::SharedBankBagsBegin && sodSlot <= invbag::SharedBankBagsEnd)
+		else if (sodSlot >= invbag::SHARED_BANK_BAGS_BEGIN && sodSlot <= invbag::SHARED_BANK_BAGS_END)
 			ServerSlot = sodSlot - 1;
-		else if (sodSlot == invslot::PossessionsPowerSource)
-			ServerSlot = EQEmu::inventory::slotPowerSource;
+		else if (sodSlot == invslot::slotPowerSource)
+			ServerSlot = EQEmu::invslot::SLOT_POWER_SOURCE;
 		else
 			ServerSlot = sodSlot;
 		return ServerSlot;
@@ -3918,7 +3813,7 @@ namespace SoD
 
 	static inline void ServerToSoDSayLink(std::string& sodSayLink, const std::string& serverSayLink)
 	{
-		if ((constants::SayLinkBodySize == EQEmu::constants::SayLinkBodySize) || (serverSayLink.find('\x12') == std::string::npos)) {
+		if ((constants::SAY_LINK_BODY_SIZE == EQEmu::constants::SAY_LINK_BODY_SIZE) || (serverSayLink.find('\x12') == std::string::npos)) {
 			sodSayLink = serverSayLink;
 			return;
 		}
@@ -3927,7 +3822,7 @@ namespace SoD
 
 		for (size_t segment_iter = 0; segment_iter < segments.size(); ++segment_iter) {
 			if (segment_iter & 1) {
-				if (segments[segment_iter].length() <= EQEmu::constants::SayLinkBodySize) {
+				if (segments[segment_iter].length() <= EQEmu::constants::SAY_LINK_BODY_SIZE) {
 					sodSayLink.append(segments[segment_iter]);
 					// TODO: log size mismatch error
 					continue;
@@ -3958,7 +3853,7 @@ namespace SoD
 
 	static inline void SoDToServerSayLink(std::string& serverSayLink, const std::string& sodSayLink)
 	{
-		if ((EQEmu::constants::SayLinkBodySize == constants::SayLinkBodySize) || (sodSayLink.find('\x12') == std::string::npos)) {
+		if ((EQEmu::constants::SAY_LINK_BODY_SIZE == constants::SAY_LINK_BODY_SIZE) || (sodSayLink.find('\x12') == std::string::npos)) {
 			serverSayLink = sodSayLink;
 			return;
 		}
@@ -3967,7 +3862,7 @@ namespace SoD
 
 		for (size_t segment_iter = 0; segment_iter < segments.size(); ++segment_iter) {
 			if (segment_iter & 1) {
-				if (segments[segment_iter].length() <= constants::SayLinkBodySize) {
+				if (segments[segment_iter].length() <= constants::SAY_LINK_BODY_SIZE) {
 					serverSayLink.append(segments[segment_iter]);
 					// TODO: log size mismatch error
 					continue;

common/patches/sod_limits.cpp

@@ -22,198 +22,198 @@
 #include "../string_util.h"
 
 
-size_t SoD::invtype::GetInvTypeSize(int inv_type)
+int16 SoD::invtype::GetInvTypeSize(int16 inv_type)
 {
 	switch (inv_type) {
-	case invtype::InvTypePossessions:
-		return invtype::InvTypePossessionsSize;
-	case invtype::InvTypeBank:
-		return invtype::InvTypeBankSize;
-	case invtype::InvTypeSharedBank:
-		return invtype::InvTypeSharedBankSize;
-	case invtype::InvTypeTrade:
-		return invtype::InvTypeTradeSize;
-	case invtype::InvTypeWorld:
-		return invtype::InvTypeWorldSize;
-	case invtype::InvTypeLimbo:
-		return invtype::InvTypeLimboSize;
-	case invtype::InvTypeTribute:
-		return invtype::InvTypeTributeSize;
-	case invtype::InvTypeGuildTribute:
-		return invtype::InvTypeGuildTributeSize;
-	case invtype::InvTypeMerchant:
-		return invtype::InvTypeMerchantSize;
-	case invtype::InvTypeCorpse:
-		return invtype::InvTypeCorpseSize;
-	case invtype::InvTypeBazaar:
-		return invtype::InvTypeBazaarSize;
-	case invtype::InvTypeInspect:
-		return invtype::InvTypeInspectSize;
-	case invtype::InvTypeViewMODPC:
-		return invtype::InvTypeViewMODPCSize;
-	case invtype::InvTypeViewMODBank:
-		return invtype::InvTypeViewMODBankSize;
-	case invtype::InvTypeViewMODSharedBank:
-		return invtype::InvTypeViewMODSharedBankSize;
-	case invtype::InvTypeViewMODLimbo:
-		return invtype::InvTypeViewMODLimboSize;
-	case invtype::InvTypeAltStorage:
-		return invtype::InvTypeAltStorageSize;
-	case invtype::InvTypeArchived:
-		return invtype::InvTypeArchivedSize;
-	case invtype::InvTypeOther:
-		return invtype::InvTypeOtherSize;
+	case invtype::typePossessions:
+		return invtype::POSSESSIONS_SIZE;
+	case invtype::typeBank:
+		return invtype::BANK_SIZE;
+	case invtype::typeSharedBank:
+		return invtype::SHARED_BANK_SIZE;
+	case invtype::typeTrade:
+		return invtype::TRADE_SIZE;
+	case invtype::typeWorld:
+		return invtype::WORLD_SIZE;
+	case invtype::typeLimbo:
+		return invtype::LIMBO_SIZE;
+	case invtype::typeTribute:
+		return invtype::TRIBUTE_SIZE;
+	case invtype::typeGuildTribute:
+		return invtype::GUILD_TRIBUTE_SIZE;
+	case invtype::typeMerchant:
+		return invtype::MERCHANT_SIZE;
+	case invtype::typeCorpse:
+		return invtype::CORPSE_SIZE;
+	case invtype::typeBazaar:
+		return invtype::BAZAAR_SIZE;
+	case invtype::typeInspect:
+		return invtype::INSPECT_SIZE;
+	case invtype::typeViewMODPC:
+		return invtype::VIEW_MOD_PC_SIZE;
+	case invtype::typeViewMODBank:
+		return invtype::VIEW_MOD_BANK_SIZE;
+	case invtype::typeViewMODSharedBank:
+		return invtype::VIEW_MOD_SHARED_BANK_SIZE;
+	case invtype::typeViewMODLimbo:
+		return invtype::VIEW_MOD_LIMBO_SIZE;
+	case invtype::typeAltStorage:
+		return invtype::ALT_STORAGE_SIZE;
+	case invtype::typeArchived:
+		return invtype::ARCHIVED_SIZE;
+	case invtype::typeOther:
+		return invtype::OTHER_SIZE;
 	default:
-		return 0;
+		return INULL;
 	}
 }
 
-const char* SoD::invtype::GetInvTypeName(int inv_type)
+const char* SoD::invtype::GetInvTypeName(int16 inv_type)
 {
 	switch (inv_type) {
-	case invtype::InvTypeInvalid:
+	case invtype::TYPE_INVALID:
 		return "Invalid Type";
-	case invtype::InvTypePossessions:
+	case invtype::typePossessions:
 		return "Possessions";
-	case invtype::InvTypeBank:
+	case invtype::typeBank:
 		return "Bank";
-	case invtype::InvTypeSharedBank:
+	case invtype::typeSharedBank:
 		return "Shared Bank";
-	case invtype::InvTypeTrade:
+	case invtype::typeTrade:
 		return "Trade";
-	case invtype::InvTypeWorld:
+	case invtype::typeWorld:
 		return "World";
-	case invtype::InvTypeLimbo:
+	case invtype::typeLimbo:
 		return "Limbo";
-	case invtype::InvTypeTribute:
+	case invtype::typeTribute:
 		return "Tribute";
-	case invtype::InvTypeGuildTribute:
+	case invtype::typeGuildTribute:
 		return "Guild Tribute";
-	case invtype::InvTypeMerchant:
+	case invtype::typeMerchant:
 		return "Merchant";
-	case invtype::InvTypeCorpse:
+	case invtype::typeCorpse:
 		return "Corpse";
-	case invtype::InvTypeBazaar:
+	case invtype::typeBazaar:
 		return "Bazaar";
-	case invtype::InvTypeInspect:
+	case invtype::typeInspect:
 		return "Inspect";
-	case invtype::InvTypeViewMODPC:
+	case invtype::typeViewMODPC:
 		return "View MOD PC";
-	case invtype::InvTypeViewMODBank:
+	case invtype::typeViewMODBank:
 		return "View MOD Bank";
-	case invtype::InvTypeViewMODSharedBank:
+	case invtype::typeViewMODSharedBank:
 		return "View MOD Shared Bank";
-	case invtype::InvTypeViewMODLimbo:
+	case invtype::typeViewMODLimbo:
 		return "View MOD Limbo";
-	case invtype::InvTypeAltStorage:
+	case invtype::typeAltStorage:
 		return "Alt Storage";
-	case invtype::InvTypeArchived:
+	case invtype::typeArchived:
 		return "Archived";
-	case invtype::InvTypeOther:
+	case invtype::typeOther:
 		return "Other";
 	default:
 		return "Unknown Type";
 	}
 }
 
-bool SoD::invtype::IsInvTypePersistent(int inv_type)
+bool SoD::invtype::IsInvTypePersistent(int16 inv_type)
 {
 	switch (inv_type) {
-	case invtype::InvTypePossessions:
-	case invtype::InvTypeBank:
-	case invtype::InvTypeSharedBank:
-	case invtype::InvTypeTrade:
-	case invtype::InvTypeWorld:
-	case invtype::InvTypeLimbo:
-	case invtype::InvTypeTribute:
-	case invtype::InvTypeGuildTribute:
+	case invtype::typePossessions:
+	case invtype::typeBank:
+	case invtype::typeSharedBank:
+	case invtype::typeTrade:
+	case invtype::typeWorld:
+	case invtype::typeLimbo:
+	case invtype::typeTribute:
+	case invtype::typeGuildTribute:
 		return true;
 	default:
 		return false;
 	}
 }
 
-const char* SoD::invslot::GetInvPossessionsSlotName(int inv_slot)
+const char* SoD::invslot::GetInvPossessionsSlotName(int16 inv_slot)
 {
 	switch (inv_slot) {
-	case invslot::InvSlotInvalid:
+	case invslot::SLOT_INVALID:
 		return "Invalid Slot";
-	case invslot::PossessionsCharm:
+	case invslot::slotCharm:
 		return "Charm";
-	case invslot::PossessionsEar1:
+	case invslot::slotEar1:
 		return "Ear 1";
-	case invslot::PossessionsHead:
+	case invslot::slotHead:
 		return "Head";
-	case invslot::PossessionsFace:
+	case invslot::slotFace:
 		return "Face";
-	case invslot::PossessionsEar2:
+	case invslot::slotEar2:
 		return "Ear 2";
-	case invslot::PossessionsNeck:
+	case invslot::slotNeck:
 		return "Neck";
-	case invslot::PossessionsShoulders:
+	case invslot::slotShoulders:
 		return "Shoulders";
-	case invslot::PossessionsArms:
+	case invslot::slotArms:
 		return "Arms";
-	case invslot::PossessionsBack:
+	case invslot::slotBack:
 		return "Back";
-	case invslot::PossessionsWrist1:
+	case invslot::slotWrist1:
 		return "Wrist 1";
-	case invslot::PossessionsWrist2:
+	case invslot::slotWrist2:
 		return "Wrist 2";
-	case invslot::PossessionsRange:
+	case invslot::slotRange:
 		return "Range";
-	case invslot::PossessionsHands:
+	case invslot::slotHands:
 		return "Hands";
-	case invslot::PossessionsPrimary:
+	case invslot::slotPrimary:
 		return "Primary";
-	case invslot::PossessionsSecondary:
+	case invslot::slotSecondary:
 		return "Secondary";
-	case invslot::PossessionsFinger1:
+	case invslot::slotFinger1:
 		return "Finger 1";
-	case invslot::PossessionsFinger2:
+	case invslot::slotFinger2:
 		return "Finger 2";
-	case invslot::PossessionsChest:
+	case invslot::slotChest:
 		return "Chest";
-	case invslot::PossessionsLegs:
+	case invslot::slotLegs:
 		return "Legs";
-	case invslot::PossessionsFeet:
+	case invslot::slotFeet:
 		return "Feet";
-	case invslot::PossessionsWaist:
+	case invslot::slotWaist:
 		return "Waist";
-	case invslot::PossessionsPowerSource:
+	case invslot::slotPowerSource:
 		return "Power Source";
-	case invslot::PossessionsAmmo:
+	case invslot::slotAmmo:
 		return "Ammo";
-	case invslot::PossessionsGeneral1:
+	case invslot::slotGeneral1:
 		return "General 1";
-	case invslot::PossessionsGeneral2:
+	case invslot::slotGeneral2:
 		return "General 2";
-	case invslot::PossessionsGeneral3:
+	case invslot::slotGeneral3:
 		return "General 3";
-	case invslot::PossessionsGeneral4:
+	case invslot::slotGeneral4:
 		return "General 4";
-	case invslot::PossessionsGeneral5:
+	case invslot::slotGeneral5:
 		return "General 5";
-	case invslot::PossessionsGeneral6:
+	case invslot::slotGeneral6:
 		return "General 6";
-	case invslot::PossessionsGeneral7:
+	case invslot::slotGeneral7:
 		return "General 7";
-	case invslot::PossessionsGeneral8:
+	case invslot::slotGeneral8:
 		return "General 8";
-	case invslot::PossessionsCursor:
+	case invslot::slotCursor:
 		return "Cursor";
 	default:
 		return "Unknown Slot";
 	}
 }
 
-const char* SoD::invslot::GetInvCorpseSlotName(int inv_slot)
+const char* SoD::invslot::GetInvCorpseSlotName(int16 inv_slot)
 {
-	if (!invtype::GetInvTypeSize(invtype::InvTypeCorpse) || inv_slot == invslot::InvSlotInvalid)
+	if (!invtype::GetInvTypeSize(invtype::typeCorpse) || inv_slot == invslot::SLOT_INVALID)
 		return "Invalid Slot";
 
 	// needs work
-	if ((size_t)(inv_slot + 1) < invslot::CorpseBegin || (size_t)(inv_slot + 1) >= invslot::CorpseEnd)
+	if ((inv_slot + 1) < invslot::CORPSE_BEGIN || (inv_slot + 1) >= invslot::CORPSE_END)
 		return "Unknown Slot";
 
 	static std::string ret_str;
@@ -222,19 +222,19 @@ const char* SoD::invslot::GetInvCorpseSlotName(int inv_slot)
 	return ret_str.c_str();
 }
 
-const char* SoD::invslot::GetInvSlotName(int inv_type, int inv_slot)
+const char* SoD::invslot::GetInvSlotName(int16 inv_type, int16 inv_slot)
 {
-	if (inv_type == invtype::InvTypePossessions)
+	if (inv_type == invtype::typePossessions)
 		return invslot::GetInvPossessionsSlotName(inv_slot);
-	else if (inv_type == invtype::InvTypeCorpse)
+	else if (inv_type == invtype::typeCorpse)
 		return invslot::GetInvCorpseSlotName(inv_slot);
 
-	size_t type_size = invtype::GetInvTypeSize(inv_type);
+	int16 type_size = invtype::GetInvTypeSize(inv_type);
 
-	if (!type_size || inv_slot == invslot::InvSlotInvalid)
+	if (!type_size || inv_slot == invslot::SLOT_INVALID)
 		return "Invalid Slot";
 
-	if ((size_t)(inv_slot + 1) >= type_size)
+	if ((inv_slot + 1) >= type_size)
 		return "Unknown Slot";
 
 	static std::string ret_str;
@@ -243,12 +243,12 @@ const char* SoD::invslot::GetInvSlotName(int inv_type, int inv_slot)
 	return ret_str.c_str();
 }
 
-const char* SoD::invbag::GetInvBagIndexName(int bag_index)
+const char* SoD::invbag::GetInvBagIndexName(int16 bag_index)
 {
-	if (bag_index == invbag::InvBagInvalid)
+	if (bag_index == invbag::SLOT_INVALID)
 		return "Invalid Bag";
 
-	if ((size_t)bag_index >= invbag::ItemBagSize)
+	if (bag_index >= invbag::SLOT_COUNT)
 		return "Unknown Bag";
 
 	static std::string ret_str;
@@ -257,12 +257,12 @@ const char* SoD::invbag::GetInvBagIndexName(int bag_index)
 	return ret_str.c_str();
 }
 
-const char* SoD::invaug::GetInvAugIndexName(int aug_index)
+const char* SoD::invaug::GetInvAugIndexName(int16 aug_index)
 {
-	if (aug_index == invaug::InvAugInvalid)
+	if (aug_index == invaug::SOCKET_INVALID)
 		return "Invalid Augment";
 
-	if ((size_t)aug_index >= invaug::ItemAugSize)
+	if (aug_index >= invaug::SOCKET_COUNT)
 		return "Unknown Augment";
 
 	static std::string ret_str;

common/patches/sod_limits.h

@@ -27,108 +27,218 @@
 
 namespace SoD
 {
-	enum : int { Invalid = -1, Null, Safety };
+	const int16 IINVALID = -1;
+	const int16 INULL = 0;
 
-	enum : bool { False = false, True = true };
-
-	// pre-declarations
 	namespace inventory {
 		inline EQEmu::versions::ClientVersion GetInventoryRef() { return EQEmu::versions::ClientVersion::SoD; }
 
+		const bool ConcatenateInvTypeLimbo = true;
+
+		const bool AllowOverLevelEquipment = false;
+
+		const bool AllowEmptyBagInBag = false;
+		const bool AllowClickCastFromBag = false;
+
 	} /*inventory*/
 
 	namespace invtype {
 		inline EQEmu::versions::ClientVersion GetInvTypeRef() { return EQEmu::versions::ClientVersion::SoD; }
 
-		enum : int { InvTypeInvalid = -1, InvTypeBegin };
+		namespace enum_ {
+			enum InventoryTypes : int16 {
+				typePossessions = INULL,
+				typeBank,
+				typeSharedBank,
+				typeTrade,
+				typeWorld,
+				typeLimbo,
+				typeTribute,
+				typeGuildTribute,
+				typeMerchant,
+				typeCorpse,
+				typeBazaar,
+				typeInspect,
+				typeViewMODPC,
+				typeViewMODBank,
+				typeViewMODSharedBank,
+				typeViewMODLimbo,
+				typeAltStorage,
+				typeArchived,
+				typeOther
+			};
 
-		enum InventoryType : int {
-			InvTypePossessions = InvTypeBegin,
-			InvTypeBank,
-			InvTypeSharedBank,
-			InvTypeTrade,
-			InvTypeWorld,
-			InvTypeLimbo,
-			InvTypeTribute,
-			InvTypeGuildTribute,
-			InvTypeMerchant,
-			InvTypeCorpse,
-			InvTypeBazaar,
-			InvTypeInspect,
-			InvTypeViewMODPC,
-			InvTypeViewMODBank,
-			InvTypeViewMODSharedBank,
-			InvTypeViewMODLimbo,
-			InvTypeAltStorage,
-			InvTypeArchived,
-			InvTypeOther,
-			InvTypeCount
-		};
+		} // namespace enum_
+		using namespace enum_;
+
+		const int16 POSSESSIONS_SIZE = 32;
+		const int16 BANK_SIZE = 24;
+		const int16 SHARED_BANK_SIZE = 2;
+		const int16 TRADE_SIZE = 8;
+		const int16 WORLD_SIZE = 10;
+		const int16 LIMBO_SIZE = 36;
+		const int16 TRIBUTE_SIZE = 5;
+		const int16 GUILD_TRIBUTE_SIZE = 2;
+		const int16 MERCHANT_SIZE = 80;
+		const int16 CORPSE_SIZE = POSSESSIONS_SIZE;
+		const int16 BAZAAR_SIZE = 80;
+		const int16 INSPECT_SIZE = 23;
+		const int16 VIEW_MOD_PC_SIZE = POSSESSIONS_SIZE;
+		const int16 VIEW_MOD_BANK_SIZE = BANK_SIZE;
+		const int16 VIEW_MOD_SHARED_BANK_SIZE = SHARED_BANK_SIZE;
+		const int16 VIEW_MOD_LIMBO_SIZE = LIMBO_SIZE;
+		const int16 ALT_STORAGE_SIZE = 0;//unknown - "Shroud Bank"
+		const int16 ARCHIVED_SIZE = 0;//unknown
+		const int16 OTHER_SIZE = 0;//unknown
+
+		const int16 TRADE_NPC_SIZE = 4; // defined by implication
+
+		const int16 TYPE_INVALID = IINVALID;
+		const int16 TYPE_BEGIN = typePossessions;
+		const int16 TYPE_END = typeOther;
+		const int16 TYPE_COUNT = (TYPE_END - TYPE_BEGIN) + 1;
+
+		int16 GetInvTypeSize(int16 inv_type);
+		const char* GetInvTypeName(int16 inv_type);
+
+		bool IsInvTypePersistent(int16 inv_type);
 
 	} /*invtype*/
 
 	namespace invslot {
 		inline EQEmu::versions::ClientVersion GetInvSlotRef() { return EQEmu::versions::ClientVersion::SoD; }
 
-		enum : int { InvSlotInvalid = -1, InvSlotBegin };
+		namespace enum_ {
+			enum InventorySlots : int16 {
+				slotCharm = INULL,
+				slotEar1,
+				slotHead,
+				slotFace,
+				slotEar2,
+				slotNeck,
+				slotShoulders,
+				slotArms,
+				slotBack,
+				slotWrist1,
+				slotWrist2,
+				slotRange,
+				slotHands,
+				slotPrimary,
+				slotSecondary,
+				slotFinger1,
+				slotFinger2,
+				slotChest,
+				slotLegs,
+				slotFeet,
+				slotWaist,
+				slotPowerSource,
+				slotAmmo,
+				slotGeneral1,
+				slotGeneral2,
+				slotGeneral3,
+				slotGeneral4,
+				slotGeneral5,
+				slotGeneral6,
+				slotGeneral7,
+				slotGeneral8,
+				slotCursor
+			};
 
-		enum PossessionsSlot : int {
-			PossessionsCharm = InvSlotBegin,
-			PossessionsEar1,
-			PossessionsHead,
-			PossessionsFace,
-			PossessionsEar2,
-			PossessionsNeck,
-			PossessionsShoulders,
-			PossessionsArms,
-			PossessionsBack,
-			PossessionsWrist1,
-			PossessionsWrist2,
-			PossessionsRange,
-			PossessionsHands,
-			PossessionsPrimary,
-			PossessionsSecondary,
-			PossessionsFinger1,
-			PossessionsFinger2,
-			PossessionsChest,
-			PossessionsLegs,
-			PossessionsFeet,
-			PossessionsWaist,
-			PossessionsPowerSource,
-			PossessionsAmmo,
-			PossessionsGeneral1,
-			PossessionsGeneral2,
-			PossessionsGeneral3,
-			PossessionsGeneral4,
-			PossessionsGeneral5,
-			PossessionsGeneral6,
-			PossessionsGeneral7,
-			PossessionsGeneral8,
-			PossessionsCursor,
-			PossessionsCount
-		};
+		} // namespace enum_
+		using namespace enum_;
 
-		const int EquipmentBegin = PossessionsCharm;
-		const int EquipmentEnd = PossessionsAmmo;
-		const int EquipmentCount = (EquipmentEnd - EquipmentBegin + 1);
+		const int16 SLOT_INVALID = IINVALID;
+		const int16 SLOT_BEGIN = INULL;
 
-		const int GeneralBegin = PossessionsGeneral1;
-		const int GeneralEnd = PossessionsGeneral8;
-		const int GeneralCount = (GeneralEnd - GeneralBegin + 1);
+		const int16 POSSESSIONS_BEGIN = slotCharm;
+		const int16 POSSESSIONS_END = slotCursor;
+		const int16 POSSESSIONS_COUNT = (POSSESSIONS_END - POSSESSIONS_BEGIN) + 1;
+
+		const int16 EQUIPMENT_BEGIN = slotCharm;
+		const int16 EQUIPMENT_END = slotAmmo;
+		const int16 EQUIPMENT_COUNT = (EQUIPMENT_END - EQUIPMENT_BEGIN + 1);
+
+		const int16 GENERAL_BEGIN = slotGeneral1;
+		const int16 GENERAL_END = slotGeneral8;
+		const int16 GENERAL_COUNT = (GENERAL_END - GENERAL_BEGIN + 1);
+
+		const int16 BONUS_BEGIN = invslot::slotCharm;
+		const int16 BONUS_STAT_END = invslot::slotPowerSource;
+		const int16 BONUS_SKILL_END = invslot::slotAmmo;
+
+		const int16 BANK_BEGIN = 2000;
+		const int16 BANK_END = (BANK_BEGIN + invtype::BANK_SIZE) - 1;
+
+		const int16 SHARED_BANK_BEGIN = 2500;
+		const int16 SHARED_BANK_END = (SHARED_BANK_BEGIN + invtype::SHARED_BANK_SIZE) - 1;
+
+		const int16 TRADE_BEGIN = 3000;
+		const int16 TRADE_END = (TRADE_BEGIN + invtype::TRADE_SIZE) - 1;
+
+		const int16 TRADE_NPC_END = (TRADE_BEGIN + invtype::TRADE_NPC_SIZE) - 1; // defined by implication
+
+		const int16 WORLD_BEGIN = 4000;
+		const int16 WORLD_END = (WORLD_BEGIN + invtype::WORLD_SIZE) - 1;
+
+		const int16 TRIBUTE_BEGIN = 400;
+		const int16 TRIBUTE_END = (TRIBUTE_BEGIN + invtype::TRIBUTE_SIZE) - 1;
+
+		const int16 GUILD_TRIBUTE_BEGIN = 450;
+		const int16 GUILD_TRIBUTE_END = (GUILD_TRIBUTE_BEGIN + invtype::GUILD_TRIBUTE_SIZE) - 1;
+
+		const int16 CORPSE_BEGIN = invslot::slotGeneral1;
+		const int16 CORPSE_END = invslot::slotGeneral1 + invslot::slotCursor;
+
+		const uint64 POSSESSIONS_BITMASK = 0x000000027FFFFFFF; // based on 34-slot count (RoF+)
+		const uint64 CORPSE_BITMASK = 0x01FFFFFE7F800000; // based on 34-slot count (RoF+)
+
+		const char* GetInvPossessionsSlotName(int16 inv_slot);
+		const char* GetInvCorpseSlotName(int16 inv_slot);
+		const char* GetInvSlotName(int16 inv_type, int16 inv_slot);
 
 	} /*invslot*/
 
 	namespace invbag {
 		inline EQEmu::versions::ClientVersion GetInvBagRef() { return EQEmu::versions::ClientVersion::SoD; }
 
-		enum : int { InvBagInvalid = -1, InvBagBegin };
+		const int16 SLOT_INVALID = IINVALID;
+		const int16 SLOT_BEGIN = INULL;
+		const int16 SLOT_END = 9;
+		const int16 SLOT_COUNT = 10;
+
+		const int16 GENERAL_BAGS_BEGIN = 262;
+		const int16 GENERAL_BAGS_COUNT = invslot::GENERAL_COUNT * SLOT_COUNT;
+		const int16 GENERAL_BAGS_END = (GENERAL_BAGS_BEGIN + GENERAL_BAGS_COUNT) - 1;
+
+		const int16 CURSOR_BAG_BEGIN = 342;
+		const int16 CURSOR_BAG_COUNT = SLOT_COUNT;
+		const int16 CURSOR_BAG_END = (CURSOR_BAG_BEGIN + CURSOR_BAG_COUNT) - 1;
+
+		const int16 BANK_BAGS_BEGIN = 2032;
+		const int16 BANK_BAGS_COUNT = (invtype::BANK_SIZE * SLOT_COUNT);
+		const int16 BANK_BAGS_END = (BANK_BAGS_BEGIN + BANK_BAGS_COUNT) - 1;
+
+		const int16 SHARED_BANK_BAGS_BEGIN = 2532;
+		const int16 SHARED_BANK_BAGS_COUNT = invtype::SHARED_BANK_SIZE * SLOT_COUNT;
+		const int16 SHARED_BANK_BAGS_END = (SHARED_BANK_BAGS_BEGIN + SHARED_BANK_BAGS_COUNT) - 1;
+
+		const int16 TRADE_BAGS_BEGIN = 3031;
+		const int16 TRADE_BAGS_COUNT = invtype::TRADE_SIZE * SLOT_COUNT;
+		const int16 TRADE_BAGS_END = (TRADE_BAGS_BEGIN + TRADE_BAGS_COUNT) - 1;
+
+		const char* GetInvBagIndexName(int16 bag_index);
 
 	} /*invbag*/
 
 	namespace invaug {
 		inline EQEmu::versions::ClientVersion GetInvAugRef() { return EQEmu::versions::ClientVersion::SoD; }
 
-		enum : int { InvAugInvalid = -1, InvAugBegin };
+		const int16 SOCKET_INVALID = IINVALID;
+		const int16 SOCKET_BEGIN = INULL;
+		const int16 SOCKET_END = 4;
+		const int16 SOCKET_COUNT = 5;
+
+		const char* GetInvAugIndexName(int16 aug_index);
 
 	} /*invaug*/
 
@@ -153,147 +263,21 @@ namespace SoD
 	namespace profile {
 		inline EQEmu::versions::ClientVersion GetProfileRef() { return EQEmu::versions::ClientVersion::SoD; }
 
+		const int16 BANDOLIERS_SIZE = 20;		// number of bandolier instances
+		const int16 BANDOLIER_ITEM_COUNT = 4;	// number of equipment slots in bandolier instance
+
+		const int16 POTION_BELT_SIZE = 5;
+
+		const int16 SKILL_ARRAY_SIZE = 100;
+
 	} /*profile*/
 
 	namespace constants {
 		inline EQEmu::versions::ClientVersion GetConstantsRef() { return EQEmu::versions::ClientVersion::SoD; }
 
-	} /*constants*/
+		const size_t CHARACTER_CREATION_LIMIT = 12;
 
-	namespace behavior {
-		inline EQEmu::versions::ClientVersion GetBehaviorRef() { return EQEmu::versions::ClientVersion::SoD; }
-
-	} /*behavior*/
-
-	namespace skills {
-		inline EQEmu::versions::ClientVersion GetSkillsRef() { return EQEmu::versions::ClientVersion::SoD; }
-
-	} /*skills*/
-
-
-	// declarations
-	namespace inventory {
-		const bool ConcatenateInvTypeLimbo = true;
-
-		const bool AllowOverLevelEquipment = false;
-
-		const bool AllowEmptyBagInBag = false;
-		const bool AllowClickCastFromBag = false;
-
-	} /*inventory*/
-
-	namespace invtype {
-		const size_t InvTypePossessionsSize = invslot::PossessionsCount;
-		const size_t InvTypeBankSize = 24;
-		const size_t InvTypeSharedBankSize = 2;
-		const size_t InvTypeTradeSize = 8;
-		const size_t InvTypeWorldSize = 10;
-		const size_t InvTypeLimboSize = 36;
-		const size_t InvTypeTributeSize = 5;
-		const size_t InvTypeGuildTributeSize = 2;
-		const size_t InvTypeMerchantSize = 80;
-		const size_t InvTypeCorpseSize = InvTypePossessionsSize;
-		const size_t InvTypeBazaarSize = 80;
-		const size_t InvTypeInspectSize = invslot::EquipmentCount;
-		const size_t InvTypeViewMODPCSize = InvTypePossessionsSize;
-		const size_t InvTypeViewMODBankSize = InvTypeBankSize;
-		const size_t InvTypeViewMODSharedBankSize = InvTypeSharedBankSize;
-		const size_t InvTypeViewMODLimboSize = InvTypeLimboSize;
-		const size_t InvTypeAltStorageSize = 0;//unknown - "Shroud Bank"
-		const size_t InvTypeArchivedSize = 0;//unknown
-		const size_t InvTypeOtherSize = 0;//unknown
-
-		extern size_t GetInvTypeSize(int inv_type);
-		extern const char* GetInvTypeName(int inv_type);
-
-		extern bool IsInvTypePersistent(int inv_type);
-
-	} /*invtype*/
-
-	namespace invslot {
-		const int BankBegin = 2000;
-		const int BankEnd = (BankBegin + invtype::InvTypeBankSize) - 1;
-
-		const int SharedBankBegin = 2500;
-		const int SharedBankEnd = (SharedBankBegin + invtype::InvTypeSharedBankSize) - 1;
-
-		const int TradeBegin = 3000;
-		const int TradeEnd = (TradeBegin + invtype::InvTypeTradeSize) - 1;
-		const int TradeNPCEnd = 3003;
-
-		const int WorldBegin = 4000;
-		const int WorldEnd = (WorldBegin + invtype::InvTypeWorldSize) - 1;
-
-		const int TributeBegin = 400;
-		const int TributeEnd = (TributeBegin + invtype::InvTypeTributeSize) - 1;
-
-		const int GuildTributeBegin = 450;
-		const int GuildTributeEnd = (GuildTributeBegin + invtype::InvTypeGuildTributeSize) - 1;
-
-		const int CorpseBegin = invslot::PossessionsGeneral1;
-		const int CorpseEnd = invslot::PossessionsGeneral1 + invslot::PossessionsCursor;
-
-		extern const char* GetInvPossessionsSlotName(int inv_slot);
-		extern const char* GetInvCorpseSlotName(int inv_slot);
-		extern const char* GetInvSlotName(int inv_type, int inv_slot);
-
-	} /*invslot*/
-
-	namespace invbag {
-		const size_t ItemBagSize = 10;
-
-		const int GeneralBagsBegin = 262;
-		const int GeneralBagsSize = invslot::GeneralCount * ItemBagSize;
-		const int GeneralBagsEnd = (GeneralBagsBegin + GeneralBagsSize) - 1;
-
-		const int CursorBagBegin = 342;
-		const int CursorBagSize = ItemBagSize;
-		const int CursorBagEnd = (CursorBagBegin + CursorBagSize) - 1;
-
-		const int BankBagsBegin = 2032;
-		const int BankBagsSize = (invtype::InvTypeBankSize * ItemBagSize);
-		const int BankBagsEnd = (BankBagsBegin + BankBagsSize) - 1;
-
-		const int SharedBankBagsBegin = 2532;
-		const int SharedBankBagsSize = invtype::InvTypeSharedBankSize * ItemBagSize;
-		const int SharedBankBagsEnd = (SharedBankBagsBegin + SharedBankBagsSize) - 1;
-
-		const int TradeBagsBegin = 3031;
-		const int TradeBagsSize = invtype::InvTypeTradeSize * ItemBagSize;
-		const int TradeBagsEnd = (TradeBagsBegin + TradeBagsSize) - 1;
-
-		extern const char* GetInvBagIndexName(int bag_index);
-
-	} /*invbag*/
-
-	namespace invaug {
-		const size_t ItemAugSize = 5;
-
-		extern const char* GetInvAugIndexName(int aug_index);
-
-	} /*invaug*/
-
-	namespace item {
-
-	} /*item*/
-
-	namespace profile {
-		const size_t TributeSize = invtype::InvTypeTributeSize;
-		const size_t GuildTributeSize = invtype::InvTypeGuildTributeSize;
-
-		const size_t BandoliersSize = 20;		// number of bandolier instances
-		const size_t BandolierItemCount = 4;	// number of equipment slots in bandolier instance
-
-		const size_t PotionBeltSize = 5;
-
-		const size_t SkillArraySize = 100;
-
-	} /*profile*/
-
-	namespace constants {
-		const size_t CharacterCreationLimit = 12;
-
-		const size_t SayLinkBodySize = 50;
+		const size_t SAY_LINK_BODY_SIZE = 50;
 
 		const int LongBuffs = 25;
 		const int ShortBuffs = 15;
@@ -306,11 +290,15 @@ namespace SoD
 	} /*constants*/
 
 	namespace behavior {
+		inline EQEmu::versions::ClientVersion GetBehaviorRef() { return EQEmu::versions::ClientVersion::SoD; }
+
 		const bool CoinHasWeight = false;
 
 	} /*behavior*/
 
 	namespace skills {
+		inline EQEmu::versions::ClientVersion GetSkillsRef() { return EQEmu::versions::ClientVersion::SoD; }
+
 		const size_t LastUsableSkill = EQEmu::skills::SkillTripleAttack;
 
 	} /*skills*/

common/patches/sod_ops.h

@@ -67,7 +67,6 @@ E(OP_MoveItem)
 E(OP_NewSpawn)
 E(OP_NewZone)
 E(OP_OnLevelMessage)
-E(OP_OpenNewTasksWindow)
 E(OP_PetBuffWindow)
 E(OP_PlayerProfile)
 E(OP_RaidJoin)

common/patches/sod_structs.h

@@ -716,7 +716,7 @@ struct BandolierItem_Struct
 struct Bandolier_Struct
 {
 	char Name[32];
-	BandolierItem_Struct Items[profile::BandolierItemCount];
+	BandolierItem_Struct Items[profile::BANDOLIER_ITEM_COUNT];
 };
 
 //len = 72
@@ -730,7 +730,7 @@ struct PotionBeltItem_Struct
 //len = 288
 struct PotionBelt_Struct
 {
-	PotionBeltItem_Struct Items[profile::PotionBeltSize];
+	PotionBeltItem_Struct Items[profile::POTION_BELT_SIZE];
 };
 
 static const uint32 MAX_GROUP_LEADERSHIP_AA_ARRAY = 16;
@@ -937,7 +937,7 @@ struct PlayerProfile_Struct
 /*08288*/ uint32  aapoints_spent;		// Number of spent AA points
 /*08292*/ uint32  aapoints;				// Unspent AA points
 /*08296*/ uint8 unknown06160[4];
-/*08300*/ Bandolier_Struct bandoliers[profile::BandoliersSize]; // [6400] bandolier contents
+/*08300*/ Bandolier_Struct bandoliers[profile::BANDOLIERS_SIZE]; // [6400] bandolier contents
 /*14700*/ PotionBelt_Struct  potionbelt;	// [360] potion belt 72 extra octets by adding 1 more belt slot
 /*15060*/ uint8 unknown12852[8];
 /*15068*/ uint32 available_slots;

common/patches/sof.cpp

@@ -1060,118 +1060,6 @@ namespace SoF
 		FINISH_ENCODE();
 	}
 
-	ENCODE(OP_OpenNewTasksWindow)
-	{
-		AvailableTaskHeader_Struct*	__emu_AvailableTaskHeader;
-		AvailableTaskData1_Struct* 	__emu_AvailableTaskData1;
-		AvailableTaskData2_Struct* 	__emu_AvailableTaskData2;
-		AvailableTaskTrailer_Struct* 	__emu_AvailableTaskTrailer;
-
-		structs::AvailableTaskHeader_Struct*	__eq_AvailableTaskHeader;
-		structs::AvailableTaskData1_Struct* 	__eq_AvailableTaskData1;
-		structs::AvailableTaskData2_Struct* 	__eq_AvailableTaskData2;
-		structs::AvailableTaskTrailer_Struct* 	__eq_AvailableTaskTrailer;
-
-		EQApplicationPacket *in = *p;
-		*p = nullptr;
-
-		unsigned char *__emu_buffer = in->pBuffer;
-
-		__emu_AvailableTaskHeader = (AvailableTaskHeader_Struct*)__emu_buffer;
-
-		// For each task, SoF has an extra uint32 and what appears to be space for a null terminated string.
-		//
-		in->size = in->size + (__emu_AvailableTaskHeader->TaskCount * 5);
-
-		in->pBuffer = new unsigned char[in->size];
-
-		unsigned char *__eq_buffer = in->pBuffer;
-
-		__eq_AvailableTaskHeader = (structs::AvailableTaskHeader_Struct*)__eq_buffer;
-
-		char *__eq_ptr, *__emu_Ptr;
-
-		// Copy Header
-		//
-		//
-
-		__eq_AvailableTaskHeader->TaskCount = __emu_AvailableTaskHeader->TaskCount;
-		__eq_AvailableTaskHeader->unknown1 = __emu_AvailableTaskHeader->unknown1;
-		__eq_AvailableTaskHeader->TaskGiver = __emu_AvailableTaskHeader->TaskGiver;
-
-		__emu_Ptr = (char *)__emu_AvailableTaskHeader + sizeof(AvailableTaskHeader_Struct);
-		__eq_ptr = (char *)__eq_AvailableTaskHeader + sizeof(structs::AvailableTaskHeader_Struct);
-
-		for (uint32 i = 0; i<__emu_AvailableTaskHeader->TaskCount; i++) {
-
-			__emu_AvailableTaskData1 = (AvailableTaskData1_Struct*)__emu_Ptr;
-			__eq_AvailableTaskData1 = (structs::AvailableTaskData1_Struct*)__eq_ptr;
-
-			__eq_AvailableTaskData1->TaskID = __emu_AvailableTaskData1->TaskID;
-			// This next unknown seems to affect the colour of the task title. 0x3f80000 is what I have seen
-			// in Live packets. Changing it to 0x3f000000 makes the title red.
-			__eq_AvailableTaskData1->unknown1 = 0x3f800000;
-			__eq_AvailableTaskData1->TimeLimit = __emu_AvailableTaskData1->TimeLimit;
-			__eq_AvailableTaskData1->unknown2 = __emu_AvailableTaskData1->unknown2;
-
-			__emu_Ptr += sizeof(AvailableTaskData1_Struct);
-			__eq_ptr += sizeof(structs::AvailableTaskData1_Struct);
-
-			strcpy(__eq_ptr, __emu_Ptr); // Title
-
-			__emu_Ptr += strlen(__emu_Ptr) + 1;
-			__eq_ptr += strlen(__eq_ptr) + 1;
-
-			strcpy(__eq_ptr, __emu_Ptr); // Description
-
-			__emu_Ptr += strlen(__emu_Ptr) + 1;
-			__eq_ptr += strlen(__eq_ptr) + 1;
-
-			__eq_ptr[0] = 0;
-			__eq_ptr += strlen(__eq_ptr) + 1;
-
-			__emu_AvailableTaskData2 = (AvailableTaskData2_Struct*)__emu_Ptr;
-			__eq_AvailableTaskData2 = (structs::AvailableTaskData2_Struct*)__eq_ptr;
-
-			__eq_AvailableTaskData2->unknown1 = __emu_AvailableTaskData2->unknown1;
-			__eq_AvailableTaskData2->unknown2 = __emu_AvailableTaskData2->unknown2;
-			__eq_AvailableTaskData2->unknown3 = __emu_AvailableTaskData2->unknown3;
-			__eq_AvailableTaskData2->unknown4 = __emu_AvailableTaskData2->unknown4;
-
-			__emu_Ptr += sizeof(AvailableTaskData2_Struct);
-			__eq_ptr += sizeof(structs::AvailableTaskData2_Struct);
-
-			strcpy(__eq_ptr, __emu_Ptr); // Unknown string
-
-			__emu_Ptr += strlen(__emu_Ptr) + 1;
-			__eq_ptr += strlen(__eq_ptr) + 1;
-
-			strcpy(__eq_ptr, __emu_Ptr); // Unknown string
-
-			__emu_Ptr += strlen(__emu_Ptr) + 1;
-			__eq_ptr += strlen(__eq_ptr) + 1;
-
-			__emu_AvailableTaskTrailer = (AvailableTaskTrailer_Struct*)__emu_Ptr;
-			__eq_AvailableTaskTrailer = (structs::AvailableTaskTrailer_Struct*)__eq_ptr;
-
-			__eq_AvailableTaskTrailer->ItemCount = __emu_AvailableTaskTrailer->ItemCount;
-			__eq_AvailableTaskTrailer->unknown1 = __emu_AvailableTaskTrailer->unknown1;
-			__eq_AvailableTaskTrailer->unknown2 = __emu_AvailableTaskTrailer->unknown2;
-			__eq_AvailableTaskTrailer->StartZone = __emu_AvailableTaskTrailer->StartZone;
-
-			__emu_Ptr += sizeof(AvailableTaskTrailer_Struct);
-			__eq_ptr += sizeof(structs::AvailableTaskTrailer_Struct);
-
-			strcpy(__eq_ptr, __emu_Ptr); // Unknown string
-
-			__emu_Ptr += strlen(__emu_Ptr) + 1;
-			__eq_ptr += strlen(__eq_ptr) + 1;
-		}
-
-		delete[] __emu_buffer;
-		dest->FastQueuePacket(&in, ack_req);
-	}
-
 	ENCODE(OP_PetBuffWindow)
 	{
 		ENCODE_LENGTH_EXACT(PetBuff_Struct);
@@ -1303,18 +1191,18 @@ namespace SoF
 		//	OUT(unknown06160[4]);
 
 		// Copy bandoliers where server and client indexes converge
-		for (r = 0; r < EQEmu::legacy::BANDOLIERS_SIZE && r < profile::BandoliersSize; ++r) {
+		for (r = 0; r < EQEmu::profile::BANDOLIERS_SIZE && r < profile::BANDOLIERS_SIZE; ++r) {
 			OUT_str(bandoliers[r].Name);
-			for (uint32 k = 0; k < profile::BandolierItemCount; ++k) { // Will need adjusting if 'server != client' is ever true
+			for (uint32 k = 0; k < profile::BANDOLIER_ITEM_COUNT; ++k) { // Will need adjusting if 'server != client' is ever true
 				OUT(bandoliers[r].Items[k].ID);
 				OUT(bandoliers[r].Items[k].Icon);
 				OUT_str(bandoliers[r].Items[k].Name);
 			}
 		}
 		// Nullify bandoliers where server and client indexes diverge, with a client bias
-		for (r = EQEmu::legacy::BANDOLIERS_SIZE; r < profile::BandoliersSize; ++r) {
+		for (r = EQEmu::profile::BANDOLIERS_SIZE; r < profile::BANDOLIERS_SIZE; ++r) {
 			eq->bandoliers[r].Name[0] = '\0';
-			for (uint32 k = 0; k < profile::BandolierItemCount; ++k) { // Will need adjusting if 'server != client' is ever true
+			for (uint32 k = 0; k < profile::BANDOLIER_ITEM_COUNT; ++k) { // Will need adjusting if 'server != client' is ever true
 				eq->bandoliers[r].Items[k].ID = 0;
 				eq->bandoliers[r].Items[k].Icon = 0;
 				eq->bandoliers[r].Items[k].Name[0] = '\0';
@@ -1324,13 +1212,13 @@ namespace SoF
 		//	OUT(unknown07444[5120]);
 
 		// Copy potion belt where server and client indexes converge
-		for (r = 0; r < EQEmu::legacy::POTION_BELT_ITEM_COUNT && r < profile::PotionBeltSize; ++r) {
+		for (r = 0; r < EQEmu::profile::POTION_BELT_SIZE && r < profile::POTION_BELT_SIZE; ++r) {
 			OUT(potionbelt.Items[r].ID);
 			OUT(potionbelt.Items[r].Icon);
 			OUT_str(potionbelt.Items[r].Name);
 		}
 		// Nullify potion belt where server and client indexes diverge, with a client bias
-		for (r = EQEmu::legacy::POTION_BELT_ITEM_COUNT; r < profile::PotionBeltSize; ++r) {
+		for (r = EQEmu::profile::POTION_BELT_SIZE; r < profile::POTION_BELT_SIZE; ++r) {
 			eq->potionbelt.Items[r].ID = 0;
 			eq->potionbelt.Items[r].Icon = 0;
 			eq->potionbelt.Items[r].Name[0] = '\0';
@@ -1618,8 +1506,8 @@ namespace SoF
 			eq->CharCount = emu->CharCount;
 			eq->TotalChars = emu->TotalChars;
 
-			if (eq->TotalChars > constants::CharacterCreationLimit)
-				eq->TotalChars = constants::CharacterCreationLimit;
+			if (eq->TotalChars > constants::CHARACTER_CREATION_LIMIT)
+				eq->TotalChars = constants::CHARACTER_CREATION_LIMIT;
 
 			FINISH_ENCODE();
 			return;
@@ -1631,7 +1519,7 @@ namespace SoF
 
 		size_t names_length = 0;
 		size_t character_count = 0;
-		for (; character_count < emu->CharCount && character_count < constants::CharacterCreationLimit; ++character_count) {
+		for (; character_count < emu->CharCount && character_count < constants::CHARACTER_CREATION_LIMIT; ++character_count) {
 			emu_cse = (CharacterSelectEntry_Struct *)emu_ptr;
 			names_length += strlen(emu_cse->Name);
 			emu_ptr += sizeof(CharacterSelectEntry_Struct);
@@ -1647,8 +1535,8 @@ namespace SoF
 		eq->CharCount = character_count;
 		eq->TotalChars = emu->TotalChars;
 
-		if (eq->TotalChars > constants::CharacterCreationLimit)
-			eq->TotalChars = constants::CharacterCreationLimit;
+		if (eq->TotalChars > constants::CHARACTER_CREATION_LIMIT)
+			eq->TotalChars = constants::CHARACTER_CREATION_LIMIT;
 
 		emu_ptr = __emu_buffer;
 		emu_ptr += sizeof(CharacterSelect_Struct);
@@ -1879,13 +1767,16 @@ namespace SoF
 		InBuffer += description_size;
 		InBuffer += sizeof(TaskDescriptionData2_Struct);
 
-		std::string old_message = InBuffer; // start 'Reward' as string
+		uint32 reward_size = strlen(InBuffer) + 1;
+		InBuffer += reward_size;
+
+		std::string old_message = InBuffer; // start item link string
 		std::string new_message;
 		ServerToSoFSayLink(new_message, old_message);
 
 		in->size = sizeof(TaskDescriptionHeader_Struct) + sizeof(TaskDescriptionData1_Struct)+
 			sizeof(TaskDescriptionData2_Struct) + sizeof(TaskDescriptionTrailer_Struct)+
-			title_size + description_size + new_message.length() + 1;
+			title_size + description_size + reward_size + new_message.length() + 1;
 
 		in->pBuffer = new unsigned char[in->size];
 
@@ -2976,7 +2867,7 @@ namespace SoF
 		ibs.nodrop = item->NoDrop;
 		ibs.attune = item->Attuneable;
 		ibs.size = item->Size;
-		ibs.slots = SwapBits21and22(item->Slots);
+		ibs.slots = SwapBits21And22(item->Slots);
 		ibs.price = item->Price;
 		ibs.icon = item->Icon;
 		ibs.unknown1 = 1;
@@ -3066,7 +2957,7 @@ namespace SoF
 		isbs.augtype = item->AugType;
 		isbs.augrestrict = item->AugRestrict;
 
-		for (int index = 0; index < invaug::ItemAugSize; ++index) {
+		for (int index = invaug::SOCKET_BEGIN; index <= invaug::SOCKET_END; ++index) {
 			isbs.augslots[index].type = item->AugSlotType[index];
 			isbs.augslots[index].visible = item->AugSlotVisible[index];
 			isbs.augslots[index].unknown = item->AugSlotUnk2[index];
@@ -3238,18 +3129,18 @@ namespace SoF
 
 		ob.write((const char*)&subitem_count, sizeof(uint32));
 
-		for (uint32 index = EQEmu::inventory::containerBegin; index < EQEmu::inventory::ContainerCount; ++index) {
+		for (uint32 index = EQEmu::invbag::SLOT_BEGIN; index <= EQEmu::invbag::SLOT_END; ++index) {
 			EQEmu::ItemInstance* sub = inst->GetItem(index);
 			if (!sub)
 				continue;
 
 			int SubSlotNumber = INVALID_INDEX;
-			if (slot_id_in >= EQEmu::legacy::GENERAL_BEGIN && slot_id_in <= EQEmu::legacy::GENERAL_END)
-				SubSlotNumber = (((slot_id_in + 3) * EQEmu::inventory::ContainerCount) + index + 1);
-			else if (slot_id_in >= EQEmu::legacy::BANK_BEGIN && slot_id_in <= EQEmu::legacy::BANK_END)
-				SubSlotNumber = (((slot_id_in - EQEmu::legacy::BANK_BEGIN) * EQEmu::inventory::ContainerCount) + EQEmu::legacy::BANK_BAGS_BEGIN + index);
-			else if (slot_id_in >= EQEmu::legacy::SHARED_BANK_BEGIN && slot_id_in <= EQEmu::legacy::SHARED_BANK_END)
-				SubSlotNumber = (((slot_id_in - EQEmu::legacy::SHARED_BANK_BEGIN) * EQEmu::inventory::ContainerCount) + EQEmu::legacy::SHARED_BANK_BAGS_BEGIN + index);
+			if (slot_id_in >= EQEmu::invslot::GENERAL_BEGIN && slot_id_in <= EQEmu::invslot::GENERAL_END)
+				SubSlotNumber = (((slot_id_in + 3) * EQEmu::invbag::SLOT_COUNT) + index + 1);
+			else if (slot_id_in >= EQEmu::invslot::BANK_BEGIN && slot_id_in <= EQEmu::invslot::BANK_END)
+				SubSlotNumber = (((slot_id_in - EQEmu::invslot::BANK_BEGIN) * EQEmu::invbag::SLOT_COUNT) + EQEmu::invbag::BANK_BAGS_BEGIN + index);
+			else if (slot_id_in >= EQEmu::invslot::SHARED_BANK_BEGIN && slot_id_in <= EQEmu::invslot::SHARED_BANK_END)
+				SubSlotNumber = (((slot_id_in - EQEmu::invslot::SHARED_BANK_BEGIN) * EQEmu::invbag::SLOT_COUNT) + EQEmu::invbag::SHARED_BANK_BAGS_BEGIN + index);
 			else
 				SubSlotNumber = slot_id_in;
 
@@ -3267,16 +3158,16 @@ namespace SoF
 	{
 		uint32 SoFSlot = 0;
 
-		if (serverSlot >= EQEmu::inventory::slotAmmo && serverSlot <= 53) // Cursor/Ammo/Power Source and Normal Inventory Slots
+		if (serverSlot >= EQEmu::invslot::slotAmmo && serverSlot <= 53) // Cursor/Ammo/Power Source and Normal Inventory Slots
 			SoFSlot = serverSlot + 1;
-		else if (serverSlot >= EQEmu::legacy::GENERAL_BAGS_BEGIN && serverSlot <= EQEmu::legacy::CURSOR_BAG_END)
+		else if (serverSlot >= EQEmu::invbag::GENERAL_BAGS_BEGIN && serverSlot <= EQEmu::invbag::CURSOR_BAG_END)
 			SoFSlot = serverSlot + 11;
-		else if (serverSlot >= EQEmu::legacy::BANK_BAGS_BEGIN && serverSlot <= EQEmu::legacy::BANK_BAGS_END)
+		else if (serverSlot >= EQEmu::invbag::BANK_BAGS_BEGIN && serverSlot <= EQEmu::invbag::BANK_BAGS_END)
 			SoFSlot = serverSlot + 1;
-		else if (serverSlot >= EQEmu::legacy::SHARED_BANK_BAGS_BEGIN && serverSlot <= EQEmu::legacy::SHARED_BANK_BAGS_END)
+		else if (serverSlot >= EQEmu::invbag::SHARED_BANK_BAGS_BEGIN && serverSlot <= EQEmu::invbag::SHARED_BANK_BAGS_END)
 			SoFSlot = serverSlot + 1;
-		else if (serverSlot == EQEmu::inventory::slotPowerSource)
-			SoFSlot = invslot::PossessionsPowerSource;
+		else if (serverSlot == EQEmu::invslot::SLOT_POWER_SOURCE)
+			SoFSlot = invslot::slotPowerSource;
 		else
 			SoFSlot = serverSlot;
 
@@ -3293,16 +3184,16 @@ namespace SoF
 	{
 		uint32 ServerSlot = 0;
 
-		if (sofSlot >= invslot::PossessionsAmmo && sofSlot <= invslot::CorpseEnd) // Cursor/Ammo/Power Source and Normal Inventory Slots
+		if (sofSlot >= invslot::slotAmmo && sofSlot <= invslot::CORPSE_END) // Cursor/Ammo/Power Source and Normal Inventory Slots
 			ServerSlot = sofSlot - 1;
-		else if (sofSlot >= invbag::GeneralBagsBegin && sofSlot <= invbag::CursorBagEnd)
+		else if (sofSlot >= invbag::GENERAL_BAGS_BEGIN && sofSlot <= invbag::CURSOR_BAG_END)
 			ServerSlot = sofSlot - 11;
-		else if (sofSlot >= invbag::BankBagsBegin && sofSlot <= invbag::BankBagsEnd)
+		else if (sofSlot >= invbag::BANK_BAGS_BEGIN && sofSlot <= invbag::BANK_BAGS_END)
 			ServerSlot = sofSlot - 1;
-		else if (sofSlot >= invbag::SharedBankBagsBegin && sofSlot <= invbag::SharedBankBagsEnd)
+		else if (sofSlot >= invbag::SHARED_BANK_BAGS_BEGIN && sofSlot <= invbag::SHARED_BANK_BAGS_END)
 			ServerSlot = sofSlot - 1;
-		else if (sofSlot == invslot::PossessionsPowerSource)
-			ServerSlot = EQEmu::inventory::slotPowerSource;
+		else if (sofSlot == invslot::slotPowerSource)
+			ServerSlot = EQEmu::invslot::SLOT_POWER_SOURCE;
 		else
 			ServerSlot = sofSlot;
 
@@ -3317,7 +3208,7 @@ namespace SoF
 
 	static inline void ServerToSoFSayLink(std::string& sofSayLink, const std::string& serverSayLink)
 	{
-		if ((constants::SayLinkBodySize == EQEmu::constants::SayLinkBodySize) || (serverSayLink.find('\x12') == std::string::npos)) {
+		if ((constants::SAY_LINK_BODY_SIZE == EQEmu::constants::SAY_LINK_BODY_SIZE) || (serverSayLink.find('\x12') == std::string::npos)) {
 			sofSayLink = serverSayLink;
 			return;
 		}
@@ -3326,7 +3217,7 @@ namespace SoF
 
 		for (size_t segment_iter = 0; segment_iter < segments.size(); ++segment_iter) {
 			if (segment_iter & 1) {
-				if (segments[segment_iter].length() <= EQEmu::constants::SayLinkBodySize) {
+				if (segments[segment_iter].length() <= EQEmu::constants::SAY_LINK_BODY_SIZE) {
 					sofSayLink.append(segments[segment_iter]);
 					// TODO: log size mismatch error
 					continue;
@@ -3357,7 +3248,7 @@ namespace SoF
 
 	static inline void SoFToServerSayLink(std::string& serverSayLink, const std::string& sofSayLink)
 	{
-		if ((EQEmu::constants::SayLinkBodySize == constants::SayLinkBodySize) || (sofSayLink.find('\x12') == std::string::npos)) {
+		if ((EQEmu::constants::SAY_LINK_BODY_SIZE == constants::SAY_LINK_BODY_SIZE) || (sofSayLink.find('\x12') == std::string::npos)) {
 			serverSayLink = sofSayLink;
 			return;
 		}
@@ -3366,7 +3257,7 @@ namespace SoF
 
 		for (size_t segment_iter = 0; segment_iter < segments.size(); ++segment_iter) {
 			if (segment_iter & 1) {
-				if (segments[segment_iter].length() <= constants::SayLinkBodySize) {
+				if (segments[segment_iter].length() <= constants::SAY_LINK_BODY_SIZE) {
 					serverSayLink.append(segments[segment_iter]);
 					// TODO: log size mismatch error
 					continue;

common/patches/sof_limits.cpp

@@ -22,198 +22,198 @@
 #include "../string_util.h"
 
 
-size_t SoF::invtype::GetInvTypeSize(int inv_type)
+int16 SoF::invtype::GetInvTypeSize(int16 inv_type)
 {
 	switch (inv_type) {
-	case invtype::InvTypePossessions:
-		return invtype::InvTypePossessionsSize;
-	case invtype::InvTypeBank:
-		return invtype::InvTypeBankSize;
-	case invtype::InvTypeSharedBank:
-		return invtype::InvTypeSharedBankSize;
-	case invtype::InvTypeTrade:
-		return invtype::InvTypeTradeSize;
-	case invtype::InvTypeWorld:
-		return invtype::InvTypeWorldSize;
-	case invtype::InvTypeLimbo:
-		return invtype::InvTypeLimboSize;
-	case invtype::InvTypeTribute:
-		return invtype::InvTypeTributeSize;
-	case invtype::InvTypeGuildTribute:
-		return invtype::InvTypeGuildTributeSize;
-	case invtype::InvTypeMerchant:
-		return invtype::InvTypeMerchantSize;
-	case invtype::InvTypeCorpse:
-		return invtype::InvTypeCorpseSize;
-	case invtype::InvTypeBazaar:
-		return invtype::InvTypeBazaarSize;
-	case invtype::InvTypeInspect:
-		return invtype::InvTypeInspectSize;
-	case invtype::InvTypeViewMODPC:
-		return invtype::InvTypeViewMODPCSize;
-	case invtype::InvTypeViewMODBank:
-		return invtype::InvTypeViewMODBankSize;
-	case invtype::InvTypeViewMODSharedBank:
-		return invtype::InvTypeViewMODSharedBankSize;
-	case invtype::InvTypeViewMODLimbo:
-		return invtype::InvTypeViewMODLimboSize;
-	case invtype::InvTypeAltStorage:
-		return invtype::InvTypeAltStorageSize;
-	case invtype::InvTypeArchived:
-		return invtype::InvTypeArchivedSize;
-	case invtype::InvTypeOther:
-		return invtype::InvTypeOtherSize;
+	case invtype::typePossessions:
+		return invtype::POSSESSIONS_SIZE;
+	case invtype::typeBank:
+		return invtype::BANK_SIZE;
+	case invtype::typeSharedBank:
+		return invtype::SHARED_BANK_SIZE;
+	case invtype::typeTrade:
+		return invtype::TRADE_SIZE;
+	case invtype::typeWorld:
+		return invtype::WORLD_SIZE;
+	case invtype::typeLimbo:
+		return invtype::LIMBO_SIZE;
+	case invtype::typeTribute:
+		return invtype::TRIBUTE_SIZE;
+	case invtype::typeGuildTribute:
+		return invtype::GUILD_TRIBUTE_SIZE;
+	case invtype::typeMerchant:
+		return invtype::MERCHANT_SIZE;
+	case invtype::typeCorpse:
+		return invtype::CORPSE_SIZE;
+	case invtype::typeBazaar:
+		return invtype::BAZAAR_SIZE;
+	case invtype::typeInspect:
+		return invtype::INSPECT_SIZE;
+	case invtype::typeViewMODPC:
+		return invtype::VIEW_MOD_PC_SIZE;
+	case invtype::typeViewMODBank:
+		return invtype::VIEW_MOD_BANK_SIZE;
+	case invtype::typeViewMODSharedBank:
+		return invtype::VIEW_MOD_SHARED_BANK_SIZE;
+	case invtype::typeViewMODLimbo:
+		return invtype::VIEW_MOD_LIMBO_SIZE;
+	case invtype::typeAltStorage:
+		return invtype::ALT_STORAGE_SIZE;
+	case invtype::typeArchived:
+		return invtype::ARCHIVED_SIZE;
+	case invtype::typeOther:
+		return invtype::OTHER_SIZE;
 	default:
-		return 0;
+		return INULL;
 	}
 }
 
-const char* SoF::invtype::GetInvTypeName(int inv_type)
+const char* SoF::invtype::GetInvTypeName(int16 inv_type)
 {
 	switch (inv_type) {
-	case invtype::InvTypeInvalid:
+	case invtype::TYPE_INVALID:
 		return "Invalid Type";
-	case invtype::InvTypePossessions:
+	case invtype::typePossessions:
 		return "Possessions";
-	case invtype::InvTypeBank:
+	case invtype::typeBank:
 		return "Bank";
-	case invtype::InvTypeSharedBank:
+	case invtype::typeSharedBank:
 		return "Shared Bank";
-	case invtype::InvTypeTrade:
+	case invtype::typeTrade:
 		return "Trade";
-	case invtype::InvTypeWorld:
+	case invtype::typeWorld:
 		return "World";
-	case invtype::InvTypeLimbo:
+	case invtype::typeLimbo:
 		return "Limbo";
-	case invtype::InvTypeTribute:
+	case invtype::typeTribute:
 		return "Tribute";
-	case invtype::InvTypeGuildTribute:
+	case invtype::typeGuildTribute:
 		return "Guild Tribute";
-	case invtype::InvTypeMerchant:
+	case invtype::typeMerchant:
 		return "Merchant";
-	case invtype::InvTypeCorpse:
+	case invtype::typeCorpse:
 		return "Corpse";
-	case invtype::InvTypeBazaar:
+	case invtype::typeBazaar:
 		return "Bazaar";
-	case invtype::InvTypeInspect:
+	case invtype::typeInspect:
 		return "Inspect";
-	case invtype::InvTypeViewMODPC:
+	case invtype::typeViewMODPC:
 		return "View MOD PC";
-	case invtype::InvTypeViewMODBank:
+	case invtype::typeViewMODBank:
 		return "View MOD Bank";
-	case invtype::InvTypeViewMODSharedBank:
+	case invtype::typeViewMODSharedBank:
 		return "View MOD Shared Bank";
-	case invtype::InvTypeViewMODLimbo:
+	case invtype::typeViewMODLimbo:
 		return "View MOD Limbo";
-	case invtype::InvTypeAltStorage:
+	case invtype::typeAltStorage:
 		return "Alt Storage";
-	case invtype::InvTypeArchived:
+	case invtype::typeArchived:
 		return "Archived";
-	case invtype::InvTypeOther:
+	case invtype::typeOther:
 		return "Other";
 	default:
 		return "Unknown Type";
 	}
 }
 
-bool SoF::invtype::IsInvTypePersistent(int inv_type)
+bool SoF::invtype::IsInvTypePersistent(int16 inv_type)
 {
 	switch (inv_type) {
-	case invtype::InvTypePossessions:
-	case invtype::InvTypeBank:
-	case invtype::InvTypeSharedBank:
-	case invtype::InvTypeTrade:
-	case invtype::InvTypeWorld:
-	case invtype::InvTypeLimbo:
-	case invtype::InvTypeTribute:
-	case invtype::InvTypeGuildTribute:
+	case invtype::typePossessions:
+	case invtype::typeBank:
+	case invtype::typeSharedBank:
+	case invtype::typeTrade:
+	case invtype::typeWorld:
+	case invtype::typeLimbo:
+	case invtype::typeTribute:
+	case invtype::typeGuildTribute:
 		return true;
 	default:
 		return false;
 	}
 }
 
-const char* SoF::invslot::GetInvPossessionsSlotName(int inv_slot)
+const char* SoF::invslot::GetInvPossessionsSlotName(int16 inv_slot)
 {
 	switch (inv_slot) {
-	case invslot::InvSlotInvalid:
+	case invslot::SLOT_INVALID:
 		return "Invalid Slot";
-	case invslot::PossessionsCharm:
+	case invslot::slotCharm:
 		return "Charm";
-	case invslot::PossessionsEar1:
+	case invslot::slotEar1:
 		return "Ear 1";
-	case invslot::PossessionsHead:
+	case invslot::slotHead:
 		return "Head";
-	case invslot::PossessionsFace:
+	case invslot::slotFace:
 		return "Face";
-	case invslot::PossessionsEar2:
+	case invslot::slotEar2:
 		return "Ear 2";
-	case invslot::PossessionsNeck:
+	case invslot::slotNeck:
 		return "Neck";
-	case invslot::PossessionsShoulders:
+	case invslot::slotShoulders:
 		return "Shoulders";
-	case invslot::PossessionsArms:
+	case invslot::slotArms:
 		return "Arms";
-	case invslot::PossessionsBack:
+	case invslot::slotBack:
 		return "Back";
-	case invslot::PossessionsWrist1:
+	case invslot::slotWrist1:
 		return "Wrist 1";
-	case invslot::PossessionsWrist2:
+	case invslot::slotWrist2:
 		return "Wrist 2";
-	case invslot::PossessionsRange:
+	case invslot::slotRange:
 		return "Range";
-	case invslot::PossessionsHands:
+	case invslot::slotHands:
 		return "Hands";
-	case invslot::PossessionsPrimary:
+	case invslot::slotPrimary:
 		return "Primary";
-	case invslot::PossessionsSecondary:
+	case invslot::slotSecondary:
 		return "Secondary";
-	case invslot::PossessionsFinger1:
+	case invslot::slotFinger1:
 		return "Finger 1";
-	case invslot::PossessionsFinger2:
+	case invslot::slotFinger2:
 		return "Finger 2";
-	case invslot::PossessionsChest:
+	case invslot::slotChest:
 		return "Chest";
-	case invslot::PossessionsLegs:
+	case invslot::slotLegs:
 		return "Legs";
-	case invslot::PossessionsFeet:
+	case invslot::slotFeet:
 		return "Feet";
-	case invslot::PossessionsWaist:
+	case invslot::slotWaist:
 		return "Waist";
-	case invslot::PossessionsPowerSource:
+	case invslot::slotPowerSource:
 		return "Power Source";
-	case invslot::PossessionsAmmo:
+	case invslot::slotAmmo:
 		return "Ammo";
-	case invslot::PossessionsGeneral1:
+	case invslot::slotGeneral1:
 		return "General 1";
-	case invslot::PossessionsGeneral2:
+	case invslot::slotGeneral2:
 		return "General 2";
-	case invslot::PossessionsGeneral3:
+	case invslot::slotGeneral3:
 		return "General 3";
-	case invslot::PossessionsGeneral4:
+	case invslot::slotGeneral4:
 		return "General 4";
-	case invslot::PossessionsGeneral5:
+	case invslot::slotGeneral5:
 		return "General 5";
-	case invslot::PossessionsGeneral6:
+	case invslot::slotGeneral6:
 		return "General 6";
-	case invslot::PossessionsGeneral7:
+	case invslot::slotGeneral7:
 		return "General 7";
-	case invslot::PossessionsGeneral8:
+	case invslot::slotGeneral8:
 		return "General 8";
-	case invslot::PossessionsCursor:
+	case invslot::slotCursor:
 		return "Cursor";
 	default:
 		return "Unknown Slot";
 	}
 }
 
-const char* SoF::invslot::GetInvCorpseSlotName(int inv_slot)
+const char* SoF::invslot::GetInvCorpseSlotName(int16 inv_slot)
 {
-	if (!invtype::GetInvTypeSize(invtype::InvTypeCorpse) || inv_slot == invslot::InvSlotInvalid)
+	if (!invtype::GetInvTypeSize(invtype::typeCorpse) || inv_slot == invslot::SLOT_INVALID)
 		return "Invalid Slot";
 
 	// needs work
-	if ((size_t)(inv_slot + 1) < invslot::CorpseBegin || (size_t)(inv_slot + 1) >= invslot::CorpseEnd)
+	if ((inv_slot + 1) < invslot::CORPSE_BEGIN || (inv_slot + 1) >= invslot::CORPSE_END)
 		return "Unknown Slot";
 
 	static std::string ret_str;
@@ -222,19 +222,19 @@ const char* SoF::invslot::GetInvCorpseSlotName(int inv_slot)
 	return ret_str.c_str();
 }
 
-const char* SoF::invslot::GetInvSlotName(int inv_type, int inv_slot)
+const char* SoF::invslot::GetInvSlotName(int16 inv_type, int16 inv_slot)
 {
-	if (inv_type == invtype::InvTypePossessions)
+	if (inv_type == invtype::typePossessions)
 		return invslot::GetInvPossessionsSlotName(inv_slot);
-	else if (inv_type == invtype::InvTypeCorpse)
+	else if (inv_type == invtype::typeCorpse)
 		return invslot::GetInvCorpseSlotName(inv_slot);
 
-	size_t type_size = invtype::GetInvTypeSize(inv_type);
+	int16 type_size = invtype::GetInvTypeSize(inv_type);
 
-	if (!type_size || inv_slot == invslot::InvSlotInvalid)
+	if (!type_size || inv_slot == invslot::SLOT_INVALID)
 		return "Invalid Slot";
 
-	if ((size_t)(inv_slot + 1) >= type_size)
+	if ((inv_slot + 1) >= type_size)
 		return "Unknown Slot";
 
 	static std::string ret_str;
@@ -243,12 +243,12 @@ const char* SoF::invslot::GetInvSlotName(int inv_type, int inv_slot)
 	return ret_str.c_str();
 }
 
-const char* SoF::invbag::GetInvBagIndexName(int bag_index)
+const char* SoF::invbag::GetInvBagIndexName(int16 bag_index)
 {
-	if (bag_index == invbag::InvBagInvalid)
+	if (bag_index == invbag::SLOT_INVALID)
 		return "Invalid Bag";
 
-	if ((size_t)bag_index >= invbag::ItemBagSize)
+	if (bag_index >= invbag::SLOT_COUNT)
 		return "Unknown Bag";
 
 	static std::string ret_str;
@@ -257,12 +257,12 @@ const char* SoF::invbag::GetInvBagIndexName(int bag_index)
 	return ret_str.c_str();
 }
 
-const char* SoF::invaug::GetInvAugIndexName(int aug_index)
+const char* SoF::invaug::GetInvAugIndexName(int16 aug_index)
 {
-	if (aug_index == invaug::InvAugInvalid)
+	if (aug_index == invaug::SOCKET_INVALID)
 		return "Invalid Augment";
 
-	if ((size_t)aug_index >= invaug::ItemAugSize)
+	if (aug_index >= invaug::SOCKET_COUNT)
 		return "Unknown Augment";
 
 	static std::string ret_str;

common/patches/sof_limits.h

@@ -27,108 +27,218 @@
 
 namespace SoF
 {
-	enum : int { Invalid = -1, Null, Safety };
+	const int16 IINVALID = -1;
+	const int16 INULL = 0;
 
-	enum : bool { False = false, True = true };
-
-	// pre-declarations
 	namespace inventory {
 		inline EQEmu::versions::ClientVersion GetInventoryRef() { return EQEmu::versions::ClientVersion::SoF; }
 
+		const bool ConcatenateInvTypeLimbo = true;
+
+		const bool AllowOverLevelEquipment = false;
+
+		const bool AllowEmptyBagInBag = false;
+		const bool AllowClickCastFromBag = false;
+
 	} /*inventory*/
 
 	namespace invtype {
 		inline EQEmu::versions::ClientVersion GetInvTypeRef() { return EQEmu::versions::ClientVersion::SoF; }
 
-		enum : int { InvTypeInvalid = -1, InvTypeBegin };
+		namespace enum_ {
+			enum InventoryTypes : int16 {
+				typePossessions = INULL,
+				typeBank,
+				typeSharedBank,
+				typeTrade,
+				typeWorld,
+				typeLimbo,
+				typeTribute,
+				typeGuildTribute,
+				typeMerchant,
+				typeCorpse,
+				typeBazaar,
+				typeInspect,
+				typeViewMODPC,
+				typeViewMODBank,
+				typeViewMODSharedBank,
+				typeViewMODLimbo,
+				typeAltStorage,
+				typeArchived,
+				typeOther
+			};
 
-		enum InventoryType : int {
-			InvTypePossessions = InvTypeBegin,
-			InvTypeBank,
-			InvTypeSharedBank,
-			InvTypeTrade,
-			InvTypeWorld,
-			InvTypeLimbo,
-			InvTypeTribute,
-			InvTypeGuildTribute,
-			InvTypeMerchant,
-			InvTypeCorpse,
-			InvTypeBazaar,
-			InvTypeInspect,
-			InvTypeViewMODPC,
-			InvTypeViewMODBank,
-			InvTypeViewMODSharedBank,
-			InvTypeViewMODLimbo,
-			InvTypeAltStorage,
-			InvTypeArchived,
-			InvTypeOther,
-			InvTypeCount
-		};
+		} // namespace enum_
+		using namespace enum_;
+
+		const int16 POSSESSIONS_SIZE = 32;
+		const int16 BANK_SIZE = 24;
+		const int16 SHARED_BANK_SIZE = 2;
+		const int16 TRADE_SIZE = 8;
+		const int16 WORLD_SIZE = 10;
+		const int16 LIMBO_SIZE = 36;
+		const int16 TRIBUTE_SIZE = 5;
+		const int16 GUILD_TRIBUTE_SIZE = 2;
+		const int16 MERCHANT_SIZE = 80;
+		const int16 CORPSE_SIZE = POSSESSIONS_SIZE;
+		const int16 BAZAAR_SIZE = 80;
+		const int16 INSPECT_SIZE = 23;
+		const int16 VIEW_MOD_PC_SIZE = POSSESSIONS_SIZE;
+		const int16 VIEW_MOD_BANK_SIZE = BANK_SIZE;
+		const int16 VIEW_MOD_SHARED_BANK_SIZE = SHARED_BANK_SIZE;
+		const int16 VIEW_MOD_LIMBO_SIZE = LIMBO_SIZE;
+		const int16 ALT_STORAGE_SIZE = 0;//unknown - "Shroud Bank"
+		const int16 ARCHIVED_SIZE = 0;//unknown
+		const int16 OTHER_SIZE = 0;//unknown
+
+		const int16 TRADE_NPC_SIZE = 4; // defined by implication
+
+		const int16 TYPE_INVALID = IINVALID;
+		const int16 TYPE_BEGIN = typePossessions;
+		const int16 TYPE_END = typeOther;
+		const int16 TYPE_COUNT = (TYPE_END - TYPE_BEGIN) + 1;
+
+		int16 GetInvTypeSize(int16 inv_type);
+		const char* GetInvTypeName(int16 inv_type);
+
+		bool IsInvTypePersistent(int16 inv_type);
 
 	} /*invtype*/
 
 	namespace invslot {
 		inline EQEmu::versions::ClientVersion GetInvSlotRef() { return EQEmu::versions::ClientVersion::SoF; }
 
-		enum : int { InvSlotInvalid = -1, InvSlotBegin };
+		namespace enum_ {
+			enum InventorySlots : int16 {
+				slotCharm = INULL,
+				slotEar1,
+				slotHead,
+				slotFace,
+				slotEar2,
+				slotNeck,
+				slotShoulders,
+				slotArms,
+				slotBack,
+				slotWrist1,
+				slotWrist2,
+				slotRange,
+				slotHands,
+				slotPrimary,
+				slotSecondary,
+				slotFinger1,
+				slotFinger2,
+				slotChest,
+				slotLegs,
+				slotFeet,
+				slotWaist,
+				slotPowerSource,
+				slotAmmo,
+				slotGeneral1,
+				slotGeneral2,
+				slotGeneral3,
+				slotGeneral4,
+				slotGeneral5,
+				slotGeneral6,
+				slotGeneral7,
+				slotGeneral8,
+				slotCursor
+			};
 
-		enum PossessionsSlot : int {
-			PossessionsCharm = InvSlotBegin,
-			PossessionsEar1,
-			PossessionsHead,
-			PossessionsFace,
-			PossessionsEar2,
-			PossessionsNeck,
-			PossessionsShoulders,
-			PossessionsArms,
-			PossessionsBack,
-			PossessionsWrist1,
-			PossessionsWrist2,
-			PossessionsRange,
-			PossessionsHands,
-			PossessionsPrimary,
-			PossessionsSecondary,
-			PossessionsFinger1,
-			PossessionsFinger2,
-			PossessionsChest,
-			PossessionsLegs,
-			PossessionsFeet,
-			PossessionsWaist,
-			PossessionsPowerSource,
-			PossessionsAmmo,
-			PossessionsGeneral1,
-			PossessionsGeneral2,
-			PossessionsGeneral3,
-			PossessionsGeneral4,
-			PossessionsGeneral5,
-			PossessionsGeneral6,
-			PossessionsGeneral7,
-			PossessionsGeneral8,
-			PossessionsCursor,
-			PossessionsCount
-		};
+		} // namespace enum_
+		using namespace enum_;
 
-		const int EquipmentBegin = PossessionsCharm;
-		const int EquipmentEnd = PossessionsAmmo;
-		const int EquipmentCount = (EquipmentEnd - EquipmentBegin + 1);
+		const int16 SLOT_INVALID = IINVALID;
+		const int16 SLOT_BEGIN = INULL;
 
-		const int GeneralBegin = PossessionsGeneral1;
-		const int GeneralEnd = PossessionsGeneral8;
-		const int GeneralCount = (GeneralEnd - GeneralBegin + 1);
+		const int16 POSSESSIONS_BEGIN = slotCharm;
+		const int16 POSSESSIONS_END = slotCursor;
+		const int16 POSSESSIONS_COUNT = (POSSESSIONS_END - POSSESSIONS_BEGIN) + 1;
+
+		const int16 EQUIPMENT_BEGIN = slotCharm;
+		const int16 EQUIPMENT_END = slotAmmo;
+		const int16 EQUIPMENT_COUNT = (EQUIPMENT_END - EQUIPMENT_BEGIN + 1);
+
+		const int16 GENERAL_BEGIN = slotGeneral1;
+		const int16 GENERAL_END = slotGeneral8;
+		const int16 GENERAL_COUNT = (GENERAL_END - GENERAL_BEGIN + 1);
+
+		const int16 BONUS_BEGIN = invslot::slotCharm;
+		const int16 BONUS_STAT_END = invslot::slotPowerSource;
+		const int16 BONUS_SKILL_END = invslot::slotAmmo;
+
+		const int16 BANK_BEGIN = 2000;
+		const int16 BANK_END = (BANK_BEGIN + invtype::BANK_SIZE) - 1;
+
+		const int16 SHARED_BANK_BEGIN = 2500;
+		const int16 SHARED_BANK_END = (SHARED_BANK_BEGIN + invtype::SHARED_BANK_SIZE) - 1;
+
+		const int16 TRADE_BEGIN = 3000;
+		const int16 TRADE_END = (TRADE_BEGIN + invtype::TRADE_SIZE) - 1;
+
+		const int16 TRADE_NPC_END = (TRADE_BEGIN + invtype::TRADE_NPC_SIZE) - 1; // defined by implication
+
+		const int16 WORLD_BEGIN = 4000;
+		const int16 WORLD_END = (WORLD_BEGIN + invtype::WORLD_SIZE) - 1;
+
+		const int16 TRIBUTE_BEGIN = 400;
+		const int16 TRIBUTE_END = (TRIBUTE_BEGIN + invtype::TRIBUTE_SIZE) - 1;
+
+		const int16 GUILD_TRIBUTE_BEGIN = 450;
+		const int16 GUILD_TRIBUTE_END = (GUILD_TRIBUTE_BEGIN + invtype::GUILD_TRIBUTE_SIZE) - 1;
+
+		const int16 CORPSE_BEGIN = invslot::slotGeneral1;
+		const int16 CORPSE_END = invslot::slotGeneral1 + invslot::slotCursor;
+
+		const uint64 POSSESSIONS_BITMASK = 0x000000027FFFFFFF; // based on 34-slot count (RoF+)
+		const uint64 CORPSE_BITMASK = 0x01FFFFFE7F800000; // based on 34-slot count (RoF+)
+
+		const char* GetInvPossessionsSlotName(int16 inv_slot);
+		const char* GetInvCorpseSlotName(int16 inv_slot);
+		const char* GetInvSlotName(int16 inv_type, int16 inv_slot);
 
 	} /*invslot*/
 
 	namespace invbag {
 		inline EQEmu::versions::ClientVersion GetInvBagRef() { return EQEmu::versions::ClientVersion::SoF; }
 
-		enum : int { InvBagInvalid = -1, InvBagBegin };
+		const int16 SLOT_INVALID = IINVALID;
+		const int16 SLOT_BEGIN = INULL;
+		const int16 SLOT_END = 9;
+		const int16 SLOT_COUNT = 10;
+
+		const int16 GENERAL_BAGS_BEGIN = 262;
+		const int16 GENERAL_BAGS_COUNT = invslot::GENERAL_COUNT * SLOT_COUNT;
+		const int16 GENERAL_BAGS_END = (GENERAL_BAGS_BEGIN + GENERAL_BAGS_COUNT) - 1;
+
+		const int16 CURSOR_BAG_BEGIN = 342;
+		const int16 CURSOR_BAG_COUNT = SLOT_COUNT;
+		const int16 CURSOR_BAG_END = (CURSOR_BAG_BEGIN + CURSOR_BAG_COUNT) - 1;
+
+		const int16 BANK_BAGS_BEGIN = 2032;
+		const int16 BANK_BAGS_COUNT = (invtype::BANK_SIZE * SLOT_COUNT);
+		const int16 BANK_BAGS_END = (BANK_BAGS_BEGIN + BANK_BAGS_COUNT) - 1;
+
+		const int16 SHARED_BANK_BAGS_BEGIN = 2532;
+		const int16 SHARED_BANK_BAGS_COUNT = invtype::SHARED_BANK_SIZE * SLOT_COUNT;
+		const int16 SHARED_BANK_BAGS_END = (SHARED_BANK_BAGS_BEGIN + SHARED_BANK_BAGS_COUNT) - 1;
+
+		const int16 TRADE_BAGS_BEGIN = 3031;
+		const int16 TRADE_BAGS_COUNT = invtype::TRADE_SIZE * SLOT_COUNT;
+		const int16 TRADE_BAGS_END = (TRADE_BAGS_BEGIN + TRADE_BAGS_COUNT) - 1;
+
+		const char* GetInvBagIndexName(int16 bag_index);
 
 	} /*invbag*/
 
 	namespace invaug {
 		inline EQEmu::versions::ClientVersion GetInvAugRef() { return EQEmu::versions::ClientVersion::SoF; }
 
-		enum : int { InvAugInvalid = -1, InvAugBegin };
+		const int16 SOCKET_INVALID = IINVALID;
+		const int16 SOCKET_BEGIN = INULL;
+		const int16 SOCKET_END = 4;
+		const int16 SOCKET_COUNT = 5;
+
+		const char* GetInvAugIndexName(int16 aug_index);
 
 	} /*invaug*/
 
@@ -153,147 +263,21 @@ namespace SoF
 	namespace profile {
 		inline EQEmu::versions::ClientVersion GetProfileRef() { return EQEmu::versions::ClientVersion::SoF; }
 
+		const int16 BANDOLIERS_SIZE = 20;		// number of bandolier instances
+		const int16 BANDOLIER_ITEM_COUNT = 4;	// number of equipment slots in bandolier instance
+
+		const int16 POTION_BELT_SIZE = 5;
+
+		const int16 SKILL_ARRAY_SIZE = 100;
+
 	} /*profile*/
 
 	namespace constants {
 		inline EQEmu::versions::ClientVersion GetConstantsRef() { return EQEmu::versions::ClientVersion::SoF; }
 
-	} /*constants*/
+		const size_t CHARACTER_CREATION_LIMIT = 12;
 
-	namespace behavior {
-		inline EQEmu::versions::ClientVersion GetBehaviorRef() { return EQEmu::versions::ClientVersion::SoF; }
-
-	} /*behavior*/
-
-	namespace skills {
-		inline EQEmu::versions::ClientVersion GetSkillsRef() { return EQEmu::versions::ClientVersion::SoF; }
-
-	} /*skills*/
-
-
-	// declarations
-	namespace inventory {
-		const bool ConcatenateInvTypeLimbo = true;
-
-		const bool AllowOverLevelEquipment = false;
-
-		const bool AllowEmptyBagInBag = false;
-		const bool AllowClickCastFromBag = false;
-
-	} /*inventory*/
-
-	namespace invtype {
-		const size_t InvTypePossessionsSize = invslot::PossessionsCount;
-		const size_t InvTypeBankSize = 24;
-		const size_t InvTypeSharedBankSize = 2;
-		const size_t InvTypeTradeSize = 8;
-		const size_t InvTypeWorldSize = 10;
-		const size_t InvTypeLimboSize = 36;
-		const size_t InvTypeTributeSize = 5;
-		const size_t InvTypeGuildTributeSize = 2;
-		const size_t InvTypeMerchantSize = 80;
-		const size_t InvTypeCorpseSize = InvTypePossessionsSize;
-		const size_t InvTypeBazaarSize = 80;
-		const size_t InvTypeInspectSize = invslot::EquipmentCount;
-		const size_t InvTypeViewMODPCSize = InvTypePossessionsSize;
-		const size_t InvTypeViewMODBankSize = InvTypeBankSize;
-		const size_t InvTypeViewMODSharedBankSize = InvTypeSharedBankSize;
-		const size_t InvTypeViewMODLimboSize = InvTypeLimboSize;
-		const size_t InvTypeAltStorageSize = 0;//unknown - "Shroud Bank"
-		const size_t InvTypeArchivedSize = 0;//unknown
-		const size_t InvTypeOtherSize = 0;//unknown
-
-		extern size_t GetInvTypeSize(int inv_type);
-		extern const char* GetInvTypeName(int inv_type);
-
-		extern bool IsInvTypePersistent(int inv_type);
-
-	} /*invtype*/
-
-	namespace invslot {
-		const int BankBegin = 2000;
-		const int BankEnd = (BankBegin + invtype::InvTypeBankSize) - 1;
-
-		const int SharedBankBegin = 2500;
-		const int SharedBankEnd = (SharedBankBegin + invtype::InvTypeSharedBankSize) - 1;
-
-		const int TradeBegin = 3000;
-		const int TradeEnd = (TradeBegin + invtype::InvTypeTradeSize) - 1;
-		const int TradeNPCEnd = 3003;
-
-		const int WorldBegin = 4000;
-		const int WorldEnd = (WorldBegin + invtype::InvTypeWorldSize) - 1;
-
-		const int TributeBegin = 400;
-		const int TributeEnd = (TributeBegin + invtype::InvTypeTributeSize) - 1;
-
-		const int GuildTributeBegin = 450;
-		const int GuildTributeEnd = (GuildTributeBegin + invtype::InvTypeGuildTributeSize) - 1;
-
-		const int CorpseBegin = PossessionsGeneral1;
-		const int CorpseEnd = PossessionsGeneral1 + PossessionsCursor;
-
-		extern const char* GetInvPossessionsSlotName(int inv_slot);
-		extern const char* GetInvCorpseSlotName(int inv_slot);
-		extern const char* GetInvSlotName(int inv_type, int inv_slot);
-
-	} /*invslot*/
-
-	namespace invbag {
-		const size_t ItemBagSize = 10;
-
-		const int GeneralBagsBegin = 262;
-		const int GeneralBagsSize = invslot::GeneralCount * ItemBagSize;
-		const int GeneralBagsEnd = (GeneralBagsBegin + GeneralBagsSize) - 1;
-
-		const int CursorBagBegin = 342;
-		const int CursorBagSize = ItemBagSize;
-		const int CursorBagEnd = (CursorBagBegin + CursorBagSize) - 1;
-
-		const int BankBagsBegin = 2032;
-		const int BankBagsSize = (invtype::InvTypeBankSize * ItemBagSize);
-		const int BankBagsEnd = (BankBagsBegin + BankBagsSize) - 1;
-
-		const int SharedBankBagsBegin = 2532;
-		const int SharedBankBagsSize = invtype::InvTypeSharedBankSize * ItemBagSize;
-		const int SharedBankBagsEnd = (SharedBankBagsBegin + SharedBankBagsSize) - 1;
-
-		const int TradeBagsBegin = 3031;
-		const int TradeBagsSize = invtype::InvTypeTradeSize * ItemBagSize;
-		const int TradeBagsEnd = (TradeBagsBegin + TradeBagsSize) - 1;
-
-		extern const char* GetInvBagIndexName(int bag_index);
-
-	} /*invbag*/
-
-	namespace invaug {
-		const size_t ItemAugSize = 5;
-
-		extern const char* GetInvAugIndexName(int aug_index);
-
-	} /*invaug*/
-
-	namespace item {
-
-	} /*item*/
-
-	namespace profile {
-		const size_t TributeSize = invtype::InvTypeTributeSize;
-		const size_t GuildTributeSize = invtype::InvTypeGuildTributeSize;
-
-		const size_t BandoliersSize = 20;		// number of bandolier instances
-		const size_t BandolierItemCount = 4;	// number of equipment slots in bandolier instance
-
-		const size_t PotionBeltSize = 5;
-
-		const size_t SkillArraySize = 100;
-
-	} /*profile*/
-
-	namespace constants {
-		const size_t CharacterCreationLimit = 12;
-
-		const size_t SayLinkBodySize = 50;
+		const size_t SAY_LINK_BODY_SIZE = 50;
 
 		const int LongBuffs = 25;
 		const int ShortBuffs = 15;
@@ -306,11 +290,15 @@ namespace SoF
 	} /*constants*/
 
 	namespace behavior {
+		inline EQEmu::versions::ClientVersion GetBehaviorRef() { return EQEmu::versions::ClientVersion::SoF; }
+
 		const bool CoinHasWeight = true;
 
 	} /*behavior*/
 
 	namespace skills {
+		inline EQEmu::versions::ClientVersion GetSkillsRef() { return EQEmu::versions::ClientVersion::SoF; }
+
 		const size_t LastUsableSkill = EQEmu::skills::SkillTripleAttack;
 
 	} /*skills*/

common/patches/sof_ops.h

@@ -62,7 +62,6 @@ E(OP_MoveItem)
 E(OP_NewSpawn)
 E(OP_NewZone)
 E(OP_OnLevelMessage)
-E(OP_OpenNewTasksWindow)
 E(OP_PetBuffWindow)
 E(OP_PlayerProfile)
 E(OP_RaidJoin)

common/patches/sof_structs.h

@@ -717,7 +717,7 @@ struct BandolierItem_Struct
 struct Bandolier_Struct
 {
 	char Name[32];
-	BandolierItem_Struct Items[profile::BandolierItemCount];
+	BandolierItem_Struct Items[profile::BANDOLIER_ITEM_COUNT];
 };
 
 //len = 72
@@ -731,7 +731,7 @@ struct PotionBeltItem_Struct
 //len = 288
 struct PotionBelt_Struct
 {
-	PotionBeltItem_Struct Items[profile::PotionBeltSize];
+	PotionBeltItem_Struct Items[profile::POTION_BELT_SIZE];
 };
 
 static const uint32 MAX_GROUP_LEADERSHIP_AA_ARRAY = 16;
@@ -937,7 +937,7 @@ struct PlayerProfile_Struct //23576 Octets
 /*08288*/ uint32  aapoints_spent;		// Number of spent AA points
 /*08292*/ uint32  aapoints;				// Unspent AA points
 /*08296*/ uint8 unknown06160[4];
-/*08300*/ Bandolier_Struct bandoliers[profile::BandoliersSize]; // [6400] bandolier contents
+/*08300*/ Bandolier_Struct bandoliers[profile::BANDOLIERS_SIZE]; // [6400] bandolier contents
 /*14700*/ PotionBelt_Struct  potionbelt;	// [360] potion belt 72 extra octets by adding 1 more belt slot
 /*15060*/ uint8 unknown12852[8];
 /*15068*/ uint32 available_slots;

common/patches/titanium.cpp

@@ -1051,18 +1051,18 @@ namespace Titanium
 		//	OUT(unknown06160[4]);
 
 		// Copy bandoliers where server and client indexes converge
-		for (r = 0; r < EQEmu::legacy::BANDOLIERS_SIZE && r < profile::BandoliersSize; ++r) {
+		for (r = 0; r < EQEmu::profile::BANDOLIERS_SIZE && r < profile::BANDOLIERS_SIZE; ++r) {
 			OUT_str(bandoliers[r].Name);
-			for (uint32 k = 0; k < profile::BandolierItemCount; ++k) { // Will need adjusting if 'server != client' is ever true
+			for (uint32 k = 0; k < profile::BANDOLIER_ITEM_COUNT; ++k) { // Will need adjusting if 'server != client' is ever true
 				OUT(bandoliers[r].Items[k].ID);
 				OUT(bandoliers[r].Items[k].Icon);
 				OUT_str(bandoliers[r].Items[k].Name);
 			}
 		}
 		// Nullify bandoliers where server and client indexes diverge, with a client bias
-		for (r = EQEmu::legacy::BANDOLIERS_SIZE; r < profile::BandoliersSize; ++r) {
+		for (r = EQEmu::profile::BANDOLIERS_SIZE; r < profile::BANDOLIERS_SIZE; ++r) {
 			eq->bandoliers[r].Name[0] = '\0';
-			for (uint32 k = 0; k < profile::BandolierItemCount; ++k) { // Will need adjusting if 'server != client' is ever true
+			for (uint32 k = 0; k < profile::BANDOLIER_ITEM_COUNT; ++k) { // Will need adjusting if 'server != client' is ever true
 				eq->bandoliers[r].Items[k].ID = 0;
 				eq->bandoliers[r].Items[k].Icon = 0;
 				eq->bandoliers[r].Items[k].Name[0] = '\0';
@@ -1072,13 +1072,13 @@ namespace Titanium
 		//	OUT(unknown07444[5120]);
 
 		// Copy potion belt where server and client indexes converge
-		for (r = 0; r < EQEmu::legacy::POTION_BELT_ITEM_COUNT && r < profile::PotionBeltSize; ++r) {
+		for (r = 0; r < EQEmu::profile::POTION_BELT_SIZE && r < profile::POTION_BELT_SIZE; ++r) {
 			OUT(potionbelt.Items[r].ID);
 			OUT(potionbelt.Items[r].Icon);
 			OUT_str(potionbelt.Items[r].Name);
 		}
 		// Nullify potion belt where server and client indexes diverge, with a client bias
-		for (r = EQEmu::legacy::POTION_BELT_ITEM_COUNT; r < profile::PotionBeltSize; ++r) {
+		for (r = EQEmu::profile::POTION_BELT_SIZE; r < profile::POTION_BELT_SIZE; ++r) {
 			eq->potionbelt.Items[r].ID = 0;
 			eq->potionbelt.Items[r].Icon = 0;
 			eq->potionbelt.Items[r].Name[0] = '\0';
@@ -1459,13 +1459,16 @@ namespace Titanium
 		InBuffer += description_size;
 		InBuffer += sizeof(TaskDescriptionData2_Struct);
 
-		std::string old_message = InBuffer; // start 'Reward' as string
+		uint32 reward_size = strlen(InBuffer) + 1;
+		InBuffer += reward_size;
+
+		std::string old_message = InBuffer; // start item link string
 		std::string new_message;
 		ServerToTitaniumSayLink(new_message, old_message);
 
 		in->size = sizeof(TaskDescriptionHeader_Struct) + sizeof(TaskDescriptionData1_Struct) +
 			sizeof(TaskDescriptionData2_Struct) + sizeof(TaskDescriptionTrailer_Struct) +
-			title_size + description_size + new_message.length() + 1;
+			title_size + description_size + reward_size + new_message.length() + 1;
 
 		in->pBuffer = new unsigned char[in->size];
 
@@ -1479,6 +1482,7 @@ namespace Titanium
 		InBuffer += strlen(InBuffer) + 1;
 
 		memcpy(OutBuffer, InBuffer, sizeof(TaskDescriptionTrailer_Struct));
+		// we have an extra DWORD in the trailer struct, client should ignore it so w/e
 
 		delete[] __emu_buffer;
 		dest->FastQueuePacket(&in, ack_req);
@@ -2442,7 +2446,7 @@ namespace Titanium
 		ob << StringFormat("%.*s\"", depth, protection); // Quotes (and protection, if needed) around static data
 
 		// Sub data
-		for (int index = EQEmu::inventory::containerBegin; index < invbag::ItemBagSize; ++index) {
+		for (int index = EQEmu::invbag::SLOT_BEGIN; index <= invbag::SLOT_END; ++index) {
 			ob << '|';
 
 			EQEmu::ItemInstance* sub = inst->GetItem(index);
@@ -2490,7 +2494,7 @@ namespace Titanium
 
 	static inline void ServerToTitaniumSayLink(std::string& titaniumSayLink, const std::string& serverSayLink)
 	{
-		if ((constants::SayLinkBodySize == EQEmu::constants::SayLinkBodySize) || (serverSayLink.find('\x12') == std::string::npos)) {
+		if ((constants::SAY_LINK_BODY_SIZE == EQEmu::constants::SAY_LINK_BODY_SIZE) || (serverSayLink.find('\x12') == std::string::npos)) {
 			titaniumSayLink = serverSayLink;
 			return;
 		}
@@ -2499,7 +2503,7 @@ namespace Titanium
 
 		for (size_t segment_iter = 0; segment_iter < segments.size(); ++segment_iter) {
 			if (segment_iter & 1) {
-				if (segments[segment_iter].length() <= EQEmu::constants::SayLinkBodySize) {
+				if (segments[segment_iter].length() <= EQEmu::constants::SAY_LINK_BODY_SIZE) {
 					titaniumSayLink.append(segments[segment_iter]);
 					// TODO: log size mismatch error
 					continue;
@@ -2530,7 +2534,7 @@ namespace Titanium
 
 	static inline void TitaniumToServerSayLink(std::string& serverSayLink, const std::string& titaniumSayLink)
 	{
-		if ((EQEmu::constants::SayLinkBodySize == constants::SayLinkBodySize) || (titaniumSayLink.find('\x12') == std::string::npos)) {
+		if ((EQEmu::constants::SAY_LINK_BODY_SIZE == constants::SAY_LINK_BODY_SIZE) || (titaniumSayLink.find('\x12') == std::string::npos)) {
 			serverSayLink = titaniumSayLink;
 			return;
 		}
@@ -2539,7 +2543,7 @@ namespace Titanium
 
 		for (size_t segment_iter = 0; segment_iter < segments.size(); ++segment_iter) {
 			if (segment_iter & 1) {
-				if (segments[segment_iter].length() <= constants::SayLinkBodySize) {
+				if (segments[segment_iter].length() <= constants::SAY_LINK_BODY_SIZE) {
 					serverSayLink.append(segments[segment_iter]);
 					// TODO: log size mismatch error
 					continue;

common/patches/titanium_limits.cpp

@@ -22,196 +22,196 @@
 #include "../string_util.h"
 
 
-size_t Titanium::invtype::GetInvTypeSize(int inv_type)
+int16 Titanium::invtype::GetInvTypeSize(int16 inv_type)
 {
 	switch (inv_type) {
-	case invtype::InvTypePossessions:
-		return invtype::InvTypePossessionsSize;
-	case invtype::InvTypeBank:
-		return invtype::InvTypeBankSize;
-	case invtype::InvTypeSharedBank:
-		return invtype::InvTypeSharedBankSize;
-	case invtype::InvTypeTrade:
-		return invtype::InvTypeTradeSize;
-	case invtype::InvTypeWorld:
-		return invtype::InvTypeWorldSize;
-	case invtype::InvTypeLimbo:
-		return invtype::InvTypeLimboSize;
-	case invtype::InvTypeTribute:
-		return invtype::InvTypeTributeSize;
-	case invtype::InvTypeGuildTribute:
-		return invtype::InvTypeGuildTributeSize;
-	case invtype::InvTypeMerchant:
-		return invtype::InvTypeMerchantSize;
-	case invtype::InvTypeCorpse:
-		return invtype::InvTypeCorpseSize;
-	case invtype::InvTypeBazaar:
-		return invtype::InvTypeBazaarSize;
-	case invtype::InvTypeInspect:
-		return invtype::InvTypeInspectSize;
-	case invtype::InvTypeViewMODPC:
-		return invtype::InvTypeViewMODPCSize;
-	case invtype::InvTypeViewMODBank:
-		return invtype::InvTypeViewMODBankSize;
-	case invtype::InvTypeViewMODSharedBank:
-		return invtype::InvTypeViewMODSharedBankSize;
-	case invtype::InvTypeViewMODLimbo:
-		return invtype::InvTypeViewMODLimboSize;
-	case invtype::InvTypeAltStorage:
-		return invtype::InvTypeAltStorageSize;
-	case invtype::InvTypeArchived:
-		return invtype::InvTypeArchivedSize;
-	case invtype::InvTypeOther:
-		return invtype::InvTypeOtherSize;
+	case invtype::typePossessions:
+		return invtype::POSSESSIONS_SIZE;
+	case invtype::typeBank:
+		return invtype::BANK_SIZE;
+	case invtype::typeSharedBank:
+		return invtype::SHARED_BANK_SIZE;
+	case invtype::typeTrade:
+		return invtype::TRADE_SIZE;
+	case invtype::typeWorld:
+		return invtype::WORLD_SIZE;
+	case invtype::typeLimbo:
+		return invtype::LIMBO_SIZE;
+	case invtype::typeTribute:
+		return invtype::TRIBUTE_SIZE;
+	case invtype::typeGuildTribute:
+		return invtype::GUILD_TRIBUTE_SIZE;
+	case invtype::typeMerchant:
+		return invtype::MERCHANT_SIZE;
+	case invtype::typeCorpse:
+		return invtype::CORPSE_SIZE;
+	case invtype::typeBazaar:
+		return invtype::BAZAAR_SIZE;
+	case invtype::typeInspect:
+		return invtype::INSPECT_SIZE;
+	case invtype::typeViewMODPC:
+		return invtype::VIEW_MOD_PC_SIZE;
+	case invtype::typeViewMODBank:
+		return invtype::VIEW_MOD_BANK_SIZE;
+	case invtype::typeViewMODSharedBank:
+		return invtype::VIEW_MOD_SHARED_BANK_SIZE;
+	case invtype::typeViewMODLimbo:
+		return invtype::VIEW_MOD_LIMBO_SIZE;
+	case invtype::typeAltStorage:
+		return invtype::ALT_STORAGE_SIZE;
+	case invtype::typeArchived:
+		return invtype::ARCHIVED_SIZE;
+	case invtype::typeOther:
+		return invtype::OTHER_SIZE;
 	default:
-		return 0;
+		return INULL;
 	}
 }
 
-const char* Titanium::invtype::GetInvTypeName(int inv_type)
+const char* Titanium::invtype::GetInvTypeName(int16 inv_type)
 {
 	switch (inv_type) {
-	case invtype::InvTypeInvalid:
+	case invtype::TYPE_INVALID:
 		return "Invalid Type";
-	case invtype::InvTypePossessions:
+	case invtype::typePossessions:
 		return "Possessions";
-	case invtype::InvTypeBank:
+	case invtype::typeBank:
 		return "Bank";
-	case invtype::InvTypeSharedBank:
+	case invtype::typeSharedBank:
 		return "Shared Bank";
-	case invtype::InvTypeTrade:
+	case invtype::typeTrade:
 		return "Trade";
-	case invtype::InvTypeWorld:
+	case invtype::typeWorld:
 		return "World";
-	case invtype::InvTypeLimbo:
+	case invtype::typeLimbo:
 		return "Limbo";
-	case invtype::InvTypeTribute:
+	case invtype::typeTribute:
 		return "Tribute";
-	case invtype::InvTypeGuildTribute:
+	case invtype::typeGuildTribute:
 		return "Guild Tribute";
-	case invtype::InvTypeMerchant:
+	case invtype::typeMerchant:
 		return "Merchant";
-	case invtype::InvTypeCorpse:
+	case invtype::typeCorpse:
 		return "Corpse";
-	case invtype::InvTypeBazaar:
+	case invtype::typeBazaar:
 		return "Bazaar";
-	case invtype::InvTypeInspect:
+	case invtype::typeInspect:
 		return "Inspect";
-	case invtype::InvTypeViewMODPC:
+	case invtype::typeViewMODPC:
 		return "View MOD PC";
-	case invtype::InvTypeViewMODBank:
+	case invtype::typeViewMODBank:
 		return "View MOD Bank";
-	case invtype::InvTypeViewMODSharedBank:
+	case invtype::typeViewMODSharedBank:
 		return "View MOD Shared Bank";
-	case invtype::InvTypeViewMODLimbo:
+	case invtype::typeViewMODLimbo:
 		return "View MOD Limbo";
-	case invtype::InvTypeAltStorage:
+	case invtype::typeAltStorage:
 		return "Alt Storage";
-	case invtype::InvTypeArchived:
+	case invtype::typeArchived:
 		return "Archived";
-	case invtype::InvTypeOther:
+	case invtype::typeOther:
 		return "Other";
 	default:
 		return "Unknown Type";
 	}
 }
 
-bool Titanium::invtype::IsInvTypePersistent(int inv_type)
+bool Titanium::invtype::IsInvTypePersistent(int16 inv_type)
 {
 	switch (inv_type) {
-	case invtype::InvTypePossessions:
-	case invtype::InvTypeBank:
-	case invtype::InvTypeSharedBank:
-	case invtype::InvTypeTrade:
-	case invtype::InvTypeWorld:
-	case invtype::InvTypeLimbo:
-	case invtype::InvTypeTribute:
-	case invtype::InvTypeGuildTribute:
+	case invtype::typePossessions:
+	case invtype::typeBank:
+	case invtype::typeSharedBank:
+	case invtype::typeTrade:
+	case invtype::typeWorld:
+	case invtype::typeLimbo:
+	case invtype::typeTribute:
+	case invtype::typeGuildTribute:
 		return true;
 	default:
 		return false;
 	}
 }
 
-const char* Titanium::invslot::GetInvPossessionsSlotName(int inv_slot)
+const char* Titanium::invslot::GetInvPossessionsSlotName(int16 inv_slot)
 {
 	switch (inv_slot) {
-	case invslot::InvSlotInvalid:
+	case invslot::SLOT_INVALID:
 		return "Invalid Slot";
-	case invslot::PossessionsCharm:
+	case invslot::slotCharm:
 		return "Charm";
-	case invslot::PossessionsEar1:
+	case invslot::slotEar1:
 		return "Ear 1";
-	case invslot::PossessionsHead:
+	case invslot::slotHead:
 		return "Head";
-	case invslot::PossessionsFace:
+	case invslot::slotFace:
 		return "Face";
-	case invslot::PossessionsEar2:
+	case invslot::slotEar2:
 		return "Ear 2";
-	case invslot::PossessionsNeck:
+	case invslot::slotNeck:
 		return "Neck";
-	case invslot::PossessionsShoulders:
+	case invslot::slotShoulders:
 		return "Shoulders";
-	case invslot::PossessionsArms:
+	case invslot::slotArms:
 		return "Arms";
-	case invslot::PossessionsBack:
+	case invslot::slotBack:
 		return "Back";
-	case invslot::PossessionsWrist1:
+	case invslot::slotWrist1:
 		return "Wrist 1";
-	case invslot::PossessionsWrist2:
+	case invslot::slotWrist2:
 		return "Wrist 2";
-	case invslot::PossessionsRange:
+	case invslot::slotRange:
 		return "Range";
-	case invslot::PossessionsHands:
+	case invslot::slotHands:
 		return "Hands";
-	case invslot::PossessionsPrimary:
+	case invslot::slotPrimary:
 		return "Primary";
-	case invslot::PossessionsSecondary:
+	case invslot::slotSecondary:
 		return "Secondary";
-	case invslot::PossessionsFinger1:
+	case invslot::slotFinger1:
 		return "Finger 1";
-	case invslot::PossessionsFinger2:
+	case invslot::slotFinger2:
 		return "Finger 2";
-	case invslot::PossessionsChest:
+	case invslot::slotChest:
 		return "Chest";
-	case invslot::PossessionsLegs:
+	case invslot::slotLegs:
 		return "Legs";
-	case invslot::PossessionsFeet:
+	case invslot::slotFeet:
 		return "Feet";
-	case invslot::PossessionsWaist:
+	case invslot::slotWaist:
 		return "Waist";
-	case invslot::PossessionsAmmo:
+	case invslot::slotAmmo:
 		return "Ammo";
-	case invslot::PossessionsGeneral1:
+	case invslot::slotGeneral1:
 		return "General 1";
-	case invslot::PossessionsGeneral2:
+	case invslot::slotGeneral2:
 		return "General 2";
-	case invslot::PossessionsGeneral3:
+	case invslot::slotGeneral3:
 		return "General 3";
-	case invslot::PossessionsGeneral4:
+	case invslot::slotGeneral4:
 		return "General 4";
-	case invslot::PossessionsGeneral5:
+	case invslot::slotGeneral5:
 		return "General 5";
-	case invslot::PossessionsGeneral6:
+	case invslot::slotGeneral6:
 		return "General 6";
-	case invslot::PossessionsGeneral7:
+	case invslot::slotGeneral7:
 		return "General 7";
-	case invslot::PossessionsGeneral8:
+	case invslot::slotGeneral8:
 		return "General 8";
-	case invslot::PossessionsCursor:
+	case invslot::slotCursor:
 		return "Cursor";
 	default:
 		return "Unknown Slot";
 	}
 }
 
-const char* Titanium::invslot::GetInvCorpseSlotName(int inv_slot)
+const char* Titanium::invslot::GetInvCorpseSlotName(int16 inv_slot)
 {
-	if (!invtype::GetInvTypeSize(invtype::InvTypeCorpse) || inv_slot == invslot::InvSlotInvalid)
+	if (!invtype::GetInvTypeSize(invtype::typeCorpse) || inv_slot == invslot::SLOT_INVALID)
 		return "Invalid Slot";
 
 	// needs work
-	if ((size_t)(inv_slot + 1) < invslot::CorpseBegin || (size_t)(inv_slot + 1) >= invslot::CorpseEnd)
+	if ((inv_slot + 1) < invslot::CORPSE_BEGIN || (inv_slot + 1) >= invslot::CORPSE_END)
 		return "Unknown Slot";
 
 	static std::string ret_str;
@@ -220,19 +220,19 @@ const char* Titanium::invslot::GetInvCorpseSlotName(int inv_slot)
 	return ret_str.c_str();
 }
 
-const char* Titanium::invslot::GetInvSlotName(int inv_type, int inv_slot)
+const char* Titanium::invslot::GetInvSlotName(int16 inv_type, int16 inv_slot)
 {
-	if (inv_type == invtype::InvTypePossessions)
+	if (inv_type == invtype::typePossessions)
 		return invslot::GetInvPossessionsSlotName(inv_slot);
-	else if (inv_type == invtype::InvTypeCorpse)
+	else if (inv_type == invtype::typeCorpse)
 		return invslot::GetInvCorpseSlotName(inv_slot);
 
-	size_t type_size = invtype::GetInvTypeSize(inv_type);
+	int16 type_size = invtype::GetInvTypeSize(inv_type);
 
-	if (!type_size || inv_slot == invslot::InvSlotInvalid)
+	if (!type_size || inv_slot == invslot::SLOT_INVALID)
 		return "Invalid Slot";
 
-	if ((size_t)(inv_slot + 1) >= type_size)
+	if ((inv_slot + 1) >= type_size)
 		return "Unknown Slot";
 
 	static std::string ret_str;
@@ -241,12 +241,12 @@ const char* Titanium::invslot::GetInvSlotName(int inv_type, int inv_slot)
 	return ret_str.c_str();
 }
 
-const char* Titanium::invbag::GetInvBagIndexName(int bag_index)
+const char* Titanium::invbag::GetInvBagIndexName(int16 bag_index)
 {
-	if (bag_index == invbag::InvBagInvalid)
+	if (bag_index == invbag::SLOT_INVALID)
 		return "Invalid Bag";
 
-	if ((size_t)bag_index >= invbag::ItemBagSize)
+	if (bag_index >= invbag::SLOT_COUNT)
 		return "Unknown Bag";
 
 	static std::string ret_str;
@@ -255,12 +255,12 @@ const char* Titanium::invbag::GetInvBagIndexName(int bag_index)
 	return ret_str.c_str();
 }
 
-const char* Titanium::invaug::GetInvAugIndexName(int aug_index)
+const char* Titanium::invaug::GetInvAugIndexName(int16 aug_index)
 {
-	if (aug_index == invaug::InvAugInvalid)
+	if (aug_index == invaug::SOCKET_INVALID)
 		return "Invalid Augment";
 
-	if ((size_t)aug_index >= invaug::ItemAugSize)
+	if (aug_index >= invaug::SOCKET_COUNT)
 		return "Unknown Augment";
 
 	static std::string ret_str;

common/patches/titanium_limits.h

@@ -27,107 +27,217 @@
 
 namespace Titanium
 {
-	enum : int { Invalid = -1, Null, Safety };
+	const int16 IINVALID = -1;
+	const int16 INULL = 0;
 
-	enum : bool { False = false, True = true };
-	
-	// pre-declarations
 	namespace inventory {
 		inline EQEmu::versions::ClientVersion GetInventoryRef() { return EQEmu::versions::ClientVersion::Titanium; }
 
+		const bool ConcatenateInvTypeLimbo = true;
+
+		const bool AllowOverLevelEquipment = false;
+
+		const bool AllowEmptyBagInBag = false;
+		const bool AllowClickCastFromBag = false;
+
 	} /*inventory*/
 
 	namespace invtype {
 		inline EQEmu::versions::ClientVersion GetInvTypeRef() { return EQEmu::versions::ClientVersion::Titanium; }
 
-		enum : int { InvTypeInvalid = -1, InvTypeBegin };
+		namespace enum_ {
+			enum InventoryTypes : int16 {
+				typePossessions = INULL,
+				typeBank,
+				typeSharedBank,
+				typeTrade,
+				typeWorld,
+				typeLimbo,
+				typeTribute,
+				typeGuildTribute,
+				typeMerchant,
+				typeCorpse,
+				typeBazaar,
+				typeInspect,
+				typeViewMODPC,
+				typeViewMODBank,
+				typeViewMODSharedBank,
+				typeViewMODLimbo,
+				typeAltStorage,
+				typeArchived,
+				typeOther
+			};
 
-		enum InventoryType : int {
-			InvTypePossessions = InvTypeBegin,
-			InvTypeBank,
-			InvTypeSharedBank,
-			InvTypeTrade,
-			InvTypeWorld,
-			InvTypeLimbo,
-			InvTypeTribute,
-			InvTypeGuildTribute,
-			InvTypeMerchant,
-			InvTypeCorpse,
-			InvTypeBazaar,
-			InvTypeInspect,
-			InvTypeViewMODPC,
-			InvTypeViewMODBank,
-			InvTypeViewMODSharedBank,
-			InvTypeViewMODLimbo,
-			InvTypeAltStorage,
-			InvTypeArchived,
-			InvTypeOther,
-			InvTypeCount
-		};
+		} // namespace enum_
+		using namespace enum_;
+
+		const int16 POSSESSIONS_SIZE = 31;
+		const int16 BANK_SIZE = 16;
+		const int16 SHARED_BANK_SIZE = 2;
+		const int16 TRADE_SIZE = 8;
+		const int16 WORLD_SIZE = 10;
+		const int16 LIMBO_SIZE = 36;
+		const int16 TRIBUTE_SIZE = 5;
+		const int16 GUILD_TRIBUTE_SIZE = 2;
+		const int16 MERCHANT_SIZE = 80;
+		const int16 CORPSE_SIZE = POSSESSIONS_SIZE;
+		const int16 BAZAAR_SIZE = 80;
+		const int16 INSPECT_SIZE = 22;
+		const int16 VIEW_MOD_PC_SIZE = POSSESSIONS_SIZE;
+		const int16 VIEW_MOD_BANK_SIZE = BANK_SIZE;
+		const int16 VIEW_MOD_SHARED_BANK_SIZE = SHARED_BANK_SIZE;
+		const int16 VIEW_MOD_LIMBO_SIZE = LIMBO_SIZE;
+		const int16 ALT_STORAGE_SIZE = 0;//unknown - "Shroud Bank"
+		const int16 ARCHIVED_SIZE = 0;//unknown
+		const int16 OTHER_SIZE = 0;//unknown
+
+		const int16 TRADE_NPC_SIZE = 4; // defined by implication
+
+		const int16 TYPE_INVALID = IINVALID;
+		const int16 TYPE_BEGIN = typePossessions;
+		const int16 TYPE_END = typeOther;
+		const int16 TYPE_COUNT = (TYPE_END - TYPE_BEGIN) + 1;
+
+		int16 GetInvTypeSize(int16 inv_type);
+		const char* GetInvTypeName(int16 inv_type);
+
+		bool IsInvTypePersistent(int16 inv_type);
 
 	} /*invtype*/
 
 	namespace invslot {
 		inline EQEmu::versions::ClientVersion GetInvSlotRef() { return EQEmu::versions::ClientVersion::Titanium; }
 
-		enum : int { InvSlotInvalid = -1, InvSlotBegin };
+		namespace enum_ {
+			enum InventorySlots : int16 {
+				slotCharm = INULL,
+				slotEar1,
+				slotHead,
+				slotFace,
+				slotEar2,
+				slotNeck,
+				slotShoulders,
+				slotArms,
+				slotBack,
+				slotWrist1,
+				slotWrist2,
+				slotRange,
+				slotHands,
+				slotPrimary,
+				slotSecondary,
+				slotFinger1,
+				slotFinger2,
+				slotChest,
+				slotLegs,
+				slotFeet,
+				slotWaist,
+				slotAmmo,
+				slotGeneral1,
+				slotGeneral2,
+				slotGeneral3,
+				slotGeneral4,
+				slotGeneral5,
+				slotGeneral6,
+				slotGeneral7,
+				slotGeneral8,
+				slotCursor
+			};
 
-		enum PossessionsSlot : int {
-			PossessionsCharm = InvSlotBegin,
-			PossessionsEar1,
-			PossessionsHead,
-			PossessionsFace,
-			PossessionsEar2,
-			PossessionsNeck,
-			PossessionsShoulders,
-			PossessionsArms,
-			PossessionsBack,
-			PossessionsWrist1,
-			PossessionsWrist2,
-			PossessionsRange,
-			PossessionsHands,
-			PossessionsPrimary,
-			PossessionsSecondary,
-			PossessionsFinger1,
-			PossessionsFinger2,
-			PossessionsChest,
-			PossessionsLegs,
-			PossessionsFeet,
-			PossessionsWaist,
-			PossessionsAmmo,
-			PossessionsGeneral1,
-			PossessionsGeneral2,
-			PossessionsGeneral3,
-			PossessionsGeneral4,
-			PossessionsGeneral5,
-			PossessionsGeneral6,
-			PossessionsGeneral7,
-			PossessionsGeneral8,
-			PossessionsCursor,
-			PossessionsCount
-		};
+		} // namespace enum_
+		using namespace enum_;
 
-		const int EquipmentBegin = PossessionsCharm;
-		const int EquipmentEnd = PossessionsAmmo;
-		const int EquipmentCount = (EquipmentEnd - EquipmentBegin + 1);
+		const int16 SLOT_INVALID = IINVALID;
+		const int16 SLOT_BEGIN = INULL;
 
-		const int GeneralBegin = PossessionsGeneral1;
-		const int GeneralEnd = PossessionsGeneral8;
-		const int GeneralCount = (GeneralEnd - GeneralBegin + 1);
+		const int16 POSSESSIONS_BEGIN = slotCharm;
+		const int16 POSSESSIONS_END = slotCursor;
+		const int16 POSSESSIONS_COUNT = (POSSESSIONS_END - POSSESSIONS_BEGIN) + 1;
+
+		const int16 EQUIPMENT_BEGIN = slotCharm;
+		const int16 EQUIPMENT_END = slotAmmo;
+		const int16 EQUIPMENT_COUNT = (EQUIPMENT_END - EQUIPMENT_BEGIN + 1);
+
+		const int16 GENERAL_BEGIN = slotGeneral1;
+		const int16 GENERAL_END = slotGeneral8;
+		const int16 GENERAL_COUNT = (GENERAL_END - GENERAL_BEGIN + 1);
+
+		const int16 BONUS_BEGIN = invslot::slotCharm;
+		const int16 BONUS_STAT_END = invslot::slotWaist;
+		const int16 BONUS_SKILL_END = invslot::slotAmmo;
+
+		const int16 BANK_BEGIN = 2000;
+		const int16 BANK_END = (BANK_BEGIN + invtype::BANK_SIZE) - 1;
+
+		const int16 SHARED_BANK_BEGIN = 2500;
+		const int16 SHARED_BANK_END = (SHARED_BANK_BEGIN + invtype::SHARED_BANK_SIZE) - 1;
+
+		const int16 TRADE_BEGIN = 3000;
+		const int16 TRADE_END = (TRADE_BEGIN + invtype::TRADE_SIZE) - 1;
+
+		const int16 TRADE_NPC_END = (TRADE_BEGIN + invtype::TRADE_NPC_SIZE) - 1; // defined by implication
+
+		const int16 WORLD_BEGIN = 4000;
+		const int16 WORLD_END = (WORLD_BEGIN + invtype::WORLD_SIZE) - 1;
+
+		const int16 TRIBUTE_BEGIN = 400;
+		const int16 TRIBUTE_END = (TRIBUTE_BEGIN + invtype::TRIBUTE_SIZE) - 1;
+
+		const int16 GUILD_TRIBUTE_BEGIN = 450;
+		const int16 GUILD_TRIBUTE_END = (GUILD_TRIBUTE_BEGIN + invtype::GUILD_TRIBUTE_SIZE) - 1;
+
+		const int16 CORPSE_BEGIN = invslot::slotGeneral1;
+		const int16 CORPSE_END = invslot::slotGeneral1 + invslot::slotCursor;
+
+		const uint64 POSSESSIONS_BITMASK = 0x000000027FDFFFFF; // based on 34-slot count (RoF+)
+		const uint64 CORPSE_BITMASK = 0x017FFFFE7F800000; // based on 34-slot count (RoF+)
+
+		const char* GetInvPossessionsSlotName(int16 inv_slot);
+		const char* GetInvCorpseSlotName(int16 inv_slot);
+		const char* GetInvSlotName(int16 inv_type, int16 inv_slot);
 
 	} /*invslot*/
 
 	namespace invbag {
 		inline EQEmu::versions::ClientVersion GetInvBagRef() { return EQEmu::versions::ClientVersion::Titanium; }
 
-		enum : int { InvBagInvalid = -1, InvBagBegin };
+		const int16 SLOT_INVALID = IINVALID;
+		const int16 SLOT_BEGIN = INULL;
+		const int16 SLOT_END = 9;
+		const int16 SLOT_COUNT = 10;
+
+		const int16 GENERAL_BAGS_BEGIN = 251;
+		const int16 GENERAL_BAGS_COUNT = invslot::GENERAL_COUNT * SLOT_COUNT;
+		const int16 GENERAL_BAGS_END = (GENERAL_BAGS_BEGIN + GENERAL_BAGS_COUNT) - 1;
+
+		const int16 CURSOR_BAG_BEGIN = 331;
+		const int16 CURSOR_BAG_COUNT = SLOT_COUNT;
+		const int16 CURSOR_BAG_END = (CURSOR_BAG_BEGIN + CURSOR_BAG_COUNT) - 1;
+
+		const int16 BANK_BAGS_BEGIN = 2031;
+		const int16 BANK_BAGS_COUNT = (invtype::BANK_SIZE * SLOT_COUNT);
+		const int16 BANK_BAGS_END = (BANK_BAGS_BEGIN + BANK_BAGS_COUNT) - 1;
+
+		const int16 SHARED_BANK_BAGS_BEGIN = 2531;
+		const int16 SHARED_BANK_BAGS_COUNT = invtype::SHARED_BANK_SIZE * SLOT_COUNT;
+		const int16 SHARED_BANK_BAGS_END = (SHARED_BANK_BAGS_BEGIN + SHARED_BANK_BAGS_COUNT) - 1;
+
+		const int16 TRADE_BAGS_BEGIN = 3031;
+		const int16 TRADE_BAGS_COUNT = invtype::TRADE_SIZE * SLOT_COUNT;
+		const int16 TRADE_BAGS_END = (TRADE_BAGS_BEGIN + TRADE_BAGS_COUNT) - 1;
+
+		const char* GetInvBagIndexName(int16 bag_index);
 
 	} /*invbag*/
 
 	namespace invaug {
 		inline EQEmu::versions::ClientVersion GetInvAugRef() { return EQEmu::versions::ClientVersion::Titanium; }
 
-		enum : int { InvAugInvalid = -1, InvAugBegin };
+		const int16 SOCKET_INVALID = IINVALID;
+		const int16 SOCKET_BEGIN = INULL;
+		const int16 SOCKET_END = 4;
+		const int16 SOCKET_COUNT = 5;
+
+		const char* GetInvAugIndexName(int16 aug_index);
 
 	} /*invaug*/
 
@@ -152,147 +262,21 @@ namespace Titanium
 	namespace profile {
 		inline EQEmu::versions::ClientVersion GetProfileRef() { return EQEmu::versions::ClientVersion::Titanium; }
 
+		const int16 BANDOLIERS_SIZE = 4;		// number of bandolier instances
+		const int16 BANDOLIER_ITEM_COUNT = 4;	// number of equipment slots in bandolier instance
+
+		const int16 POTION_BELT_SIZE = 4;
+
+		const int16 SKILL_ARRAY_SIZE = 100;
+
 	} /*profile*/
 
 	namespace constants {
 		inline EQEmu::versions::ClientVersion GetConstantsRef() { return EQEmu::versions::ClientVersion::Titanium; }
 
-	} /*constants*/
+		const size_t CHARACTER_CREATION_LIMIT = 8; // Hard-coded in client - DO NOT ALTER
 
-	namespace behavior {
-		inline EQEmu::versions::ClientVersion GetBehaviorRef() { return EQEmu::versions::ClientVersion::Titanium; }
-
-	} /*behavior*/
-
-	namespace skills {
-		inline EQEmu::versions::ClientVersion GetSkillsRef() { return EQEmu::versions::ClientVersion::Titanium; }
-
-	} /*skills*/
-
-
-	// declarations
-	namespace inventory {
-		const bool ConcatenateInvTypeLimbo = true;
-
-		const bool AllowOverLevelEquipment = false;
-
-		const bool AllowEmptyBagInBag = false;
-		const bool AllowClickCastFromBag = false;
-
-	} /*inventory*/
-
-	namespace invtype {
-		const size_t InvTypePossessionsSize = invslot::PossessionsCount;
-		const size_t InvTypeBankSize = 16;
-		const size_t InvTypeSharedBankSize = 2;
-		const size_t InvTypeTradeSize = 8;
-		const size_t InvTypeWorldSize = 10;
-		const size_t InvTypeLimboSize = 36;
-		const size_t InvTypeTributeSize = 5;
-		const size_t InvTypeGuildTributeSize = 2;
-		const size_t InvTypeMerchantSize = 80;
-		const size_t InvTypeCorpseSize = InvTypePossessionsSize;
-		const size_t InvTypeBazaarSize = 80;
-		const size_t InvTypeInspectSize = invslot::EquipmentCount;
-		const size_t InvTypeViewMODPCSize = InvTypePossessionsSize;
-		const size_t InvTypeViewMODBankSize = InvTypeBankSize;
-		const size_t InvTypeViewMODSharedBankSize = InvTypeSharedBankSize;
-		const size_t InvTypeViewMODLimboSize = InvTypeLimboSize;
-		const size_t InvTypeAltStorageSize = 0;//unknown - "Shroud Bank"
-		const size_t InvTypeArchivedSize = 0;//unknown
-		const size_t InvTypeOtherSize = 0;//unknown
-
-		extern size_t GetInvTypeSize(int inv_type);
-		extern const char* GetInvTypeName(int inv_type);
-
-		extern bool IsInvTypePersistent(int inv_type);
-
-	} /*invtype*/
-
-	namespace invslot {
-		const int BankBegin = 2000;
-		const int BankEnd = (BankBegin + invtype::InvTypeBankSize) - 1;
-
-		const int SharedBankBegin = 2500;
-		const int SharedBankEnd = (SharedBankBegin + invtype::InvTypeSharedBankSize) - 1;
-
-		const int TradeBegin = 3000;
-		const int TradeEnd = (TradeBegin + invtype::InvTypeTradeSize) - 1;
-		const int TradeNPCEnd = 3003;
-
-		const int WorldBegin = 4000;
-		const int WorldEnd = (WorldBegin + invtype::InvTypeWorldSize) - 1;
-
-		const int TributeBegin = 400;
-		const int TributeEnd = (TributeBegin + invtype::InvTypeTributeSize) - 1;
-
-		const int GuildTributeBegin = 450;
-		const int GuildTributeEnd = (GuildTributeBegin + invtype::InvTypeGuildTributeSize) - 1;
-
-		const int CorpseBegin = PossessionsGeneral1;
-		const int CorpseEnd = PossessionsGeneral1 + PossessionsCursor;
-
-		extern const char* GetInvPossessionsSlotName(int inv_slot);
-		extern const char* GetInvCorpseSlotName(int inv_slot);
-		extern const char* GetInvSlotName(int inv_type, int inv_slot);
-
-	} /*invslot*/
-
-	namespace invbag {
-		const size_t ItemBagSize = 10;
-
-		const int GeneralBagsBegin = 251;
-		const int GeneralBagsSize = invslot::GeneralCount * ItemBagSize;
-		const int GeneralBagsEnd = (GeneralBagsBegin + GeneralBagsSize) - 1;
-
-		const int CursorBagBegin = 331;
-		const int CursorBagSize = ItemBagSize;
-		const int CursorBagEnd = (CursorBagBegin + CursorBagSize) - 1;
-
-		const int BankBagsBegin = 2031;
-		const int BankBagsSize = (invtype::InvTypeBankSize * ItemBagSize);
-		const int BankBagsEnd = (BankBagsBegin + BankBagsSize) - 1;
-
-		const int SharedBankBagsBegin = 2531;
-		const int SharedBankBagsSize = invtype::InvTypeSharedBankSize * ItemBagSize;
-		const int SharedBankBagsEnd = (SharedBankBagsBegin + SharedBankBagsSize) - 1;
-
-		const int TradeBagsBegin = 3031;
-		const int TradeBagsSize = invtype::InvTypeTradeSize * ItemBagSize;
-		const int TradeBagsEnd = (TradeBagsBegin + TradeBagsSize) - 1;
-
-		extern const char* GetInvBagIndexName(int bag_index);
-
-	} /*invbag*/
-
-	namespace invaug {
-		const size_t ItemAugSize = 5;
-
-		extern const char* GetInvAugIndexName(int aug_index);
-
-	} /*invaug*/
-
-	namespace item {
-
-	} /*item*/
-
-	namespace profile {
-		const size_t TributeSize = invtype::InvTypeTributeSize;
-		const size_t GuildTributeSize = invtype::InvTypeGuildTributeSize;
-
-		const size_t BandoliersSize = 4;		// number of bandolier instances
-		const size_t BandolierItemCount = 4;	// number of equipment slots in bandolier instance
-
-		const size_t PotionBeltSize = 4;
-
-		const size_t SkillArraySize = 100;
-
-	} /*profile*/
-
-	namespace constants {
-		const size_t CharacterCreationLimit = 8; // Hard-coded in client - DO NOT ALTER
-
-		const size_t SayLinkBodySize = 45;
+		const size_t SAY_LINK_BODY_SIZE = 45;
 
 		const int LongBuffs = 25;
 		const int ShortBuffs = 12;
@@ -305,11 +289,15 @@ namespace Titanium
 	} /*constants*/
 
 	namespace behavior {
+		inline EQEmu::versions::ClientVersion GetBehaviorRef() { return EQEmu::versions::ClientVersion::Titanium; }
+
 		const bool CoinHasWeight = true;
 
 	} /*behavior*/
 
 	namespace skills {
+		inline EQEmu::versions::ClientVersion GetSkillsRef() { return EQEmu::versions::ClientVersion::Titanium; }
+
 		const size_t LastUsableSkill = EQEmu::skills::SkillFrenzy;
 
 	} /*skills*/

common/patches/titanium_structs.h

@@ -655,7 +655,7 @@ struct BandolierItem_Struct
 struct Bandolier_Struct
 {
 	char Name[32];
-	BandolierItem_Struct Items[profile::BandolierItemCount];
+	BandolierItem_Struct Items[profile::BANDOLIER_ITEM_COUNT];
 };
 
 //len = 72
@@ -669,7 +669,7 @@ struct PotionBeltItem_Struct
 //len = 288
 struct PotionBelt_Struct
 {
-	PotionBeltItem_Struct Items[profile::PotionBeltSize];
+	PotionBeltItem_Struct Items[profile::POTION_BELT_SIZE];
 };
 
 static const uint32 MAX_GROUP_LEADERSHIP_AA_ARRAY = 16;
@@ -875,7 +875,7 @@ struct PlayerProfile_Struct
 /*06152*/ uint32  aapoints_spent;           // Number of spent AA points
 /*06156*/ uint32  aapoints;         // Unspent AA points
 /*06160*/ uint8 unknown06160[4];
-/*06164*/ Bandolier_Struct bandoliers[profile::BandoliersSize]; // bandolier contents
+/*06164*/ Bandolier_Struct bandoliers[profile::BANDOLIERS_SIZE]; // bandolier contents
 /*07444*/ uint8 unknown07444[5120];
 /*12564*/ PotionBelt_Struct  potionbelt; // potion belt
 /*12852*/ uint8 unknown12852[8];

common/patches/uf.cpp

@@ -1609,117 +1609,6 @@ namespace UF
 		FINISH_ENCODE();
 	}
 
-	ENCODE(OP_OpenNewTasksWindow)
-	{
-		AvailableTaskHeader_Struct*	__emu_AvailableTaskHeader;
-		AvailableTaskData1_Struct* 	__emu_AvailableTaskData1;
-		AvailableTaskData2_Struct* 	__emu_AvailableTaskData2;
-		AvailableTaskTrailer_Struct* 	__emu_AvailableTaskTrailer;
-
-		structs::AvailableTaskHeader_Struct*	__eq_AvailableTaskHeader;
-		structs::AvailableTaskData1_Struct* 	__eq_AvailableTaskData1;
-		structs::AvailableTaskData2_Struct* 	__eq_AvailableTaskData2;
-		structs::AvailableTaskTrailer_Struct* 	__eq_AvailableTaskTrailer;
-
-		EQApplicationPacket *in = *p;
-		*p = nullptr;
-
-		unsigned char *__emu_buffer = in->pBuffer;
-
-		__emu_AvailableTaskHeader = (AvailableTaskHeader_Struct*)__emu_buffer;
-
-		// For each task, SoF has an extra uint32 and what appears to be space for a null terminated string.
-		//
-		in->size = in->size + (__emu_AvailableTaskHeader->TaskCount * 5);
-		in->pBuffer = new unsigned char[in->size];
-
-		unsigned char *__eq_buffer = in->pBuffer;
-
-		__eq_AvailableTaskHeader = (structs::AvailableTaskHeader_Struct*)__eq_buffer;
-
-		char *__eq_ptr, *__emu_Ptr;
-
-		// Copy Header
-		//
-		//
-
-		__eq_AvailableTaskHeader->TaskCount = __emu_AvailableTaskHeader->TaskCount;
-		__eq_AvailableTaskHeader->unknown1 = __emu_AvailableTaskHeader->unknown1;
-		__eq_AvailableTaskHeader->TaskGiver = __emu_AvailableTaskHeader->TaskGiver;
-
-		__emu_Ptr = (char *)__emu_AvailableTaskHeader + sizeof(AvailableTaskHeader_Struct);
-		__eq_ptr = (char *)__eq_AvailableTaskHeader + sizeof(structs::AvailableTaskHeader_Struct);
-
-		for (uint32 i = 0; i<__emu_AvailableTaskHeader->TaskCount; i++) {
-
-			__emu_AvailableTaskData1 = (AvailableTaskData1_Struct*)__emu_Ptr;
-			__eq_AvailableTaskData1 = (structs::AvailableTaskData1_Struct*)__eq_ptr;
-
-			__eq_AvailableTaskData1->TaskID = __emu_AvailableTaskData1->TaskID;
-			// This next unknown seems to affect the colour of the task title. 0x3f80000 is what I have seen
-			// in Underfoot packets. Changing it to 0x3f000000 makes the title red.
-			__eq_AvailableTaskData1->unknown1 = 0x3f800000;
-			__eq_AvailableTaskData1->TimeLimit = __emu_AvailableTaskData1->TimeLimit;
-			__eq_AvailableTaskData1->unknown2 = __emu_AvailableTaskData1->unknown2;
-
-			__emu_Ptr += sizeof(AvailableTaskData1_Struct);
-			__eq_ptr += sizeof(structs::AvailableTaskData1_Struct);
-
-			strcpy(__eq_ptr, __emu_Ptr); // Title
-
-			__emu_Ptr += strlen(__emu_Ptr) + 1;
-			__eq_ptr += strlen(__eq_ptr) + 1;
-
-			strcpy(__eq_ptr, __emu_Ptr); // Description
-
-			__emu_Ptr += strlen(__emu_Ptr) + 1;
-			__eq_ptr += strlen(__eq_ptr) + 1;
-
-			__eq_ptr[0] = 0;
-			__eq_ptr += strlen(__eq_ptr) + 1;
-
-			__emu_AvailableTaskData2 = (AvailableTaskData2_Struct*)__emu_Ptr;
-			__eq_AvailableTaskData2 = (structs::AvailableTaskData2_Struct*)__eq_ptr;
-
-			__eq_AvailableTaskData2->unknown1 = __emu_AvailableTaskData2->unknown1;
-			__eq_AvailableTaskData2->unknown2 = __emu_AvailableTaskData2->unknown2;
-			__eq_AvailableTaskData2->unknown3 = __emu_AvailableTaskData2->unknown3;
-			__eq_AvailableTaskData2->unknown4 = __emu_AvailableTaskData2->unknown4;
-
-			__emu_Ptr += sizeof(AvailableTaskData2_Struct);
-			__eq_ptr += sizeof(structs::AvailableTaskData2_Struct);
-
-			strcpy(__eq_ptr, __emu_Ptr); // Unknown string
-
-			__emu_Ptr += strlen(__emu_Ptr) + 1;
-			__eq_ptr += strlen(__eq_ptr) + 1;
-
-			strcpy(__eq_ptr, __emu_Ptr); // Unknown string
-
-			__emu_Ptr += strlen(__emu_Ptr) + 1;
-			__eq_ptr += strlen(__eq_ptr) + 1;
-
-			__emu_AvailableTaskTrailer = (AvailableTaskTrailer_Struct*)__emu_Ptr;
-			__eq_AvailableTaskTrailer = (structs::AvailableTaskTrailer_Struct*)__eq_ptr;
-
-			__eq_AvailableTaskTrailer->ItemCount = __emu_AvailableTaskTrailer->ItemCount;
-			__eq_AvailableTaskTrailer->unknown1 = __emu_AvailableTaskTrailer->unknown1;
-			__eq_AvailableTaskTrailer->unknown2 = __emu_AvailableTaskTrailer->unknown2;
-			__eq_AvailableTaskTrailer->StartZone = __emu_AvailableTaskTrailer->StartZone;
-
-			__emu_Ptr += sizeof(AvailableTaskTrailer_Struct);
-			__eq_ptr += sizeof(structs::AvailableTaskTrailer_Struct);
-
-			strcpy(__eq_ptr, __emu_Ptr); // Unknown string
-
-			__emu_Ptr += strlen(__emu_Ptr) + 1;
-			__eq_ptr += strlen(__eq_ptr) + 1;
-		}
-
-		delete[] __emu_buffer;
-		dest->FastQueuePacket(&in, ack_req);
-	}
-
 	ENCODE(OP_PetBuffWindow)
 	{
 		EQApplicationPacket *in = *p;
@@ -1881,18 +1770,18 @@ namespace UF
 		//	OUT(unknown06160[4]);
 
 		// Copy bandoliers where server and client indexes converge
-		for (r = 0; r < EQEmu::legacy::BANDOLIERS_SIZE && r < profile::BandoliersSize; ++r) {
+		for (r = 0; r < EQEmu::profile::BANDOLIERS_SIZE && r < profile::BANDOLIERS_SIZE; ++r) {
 			OUT_str(bandoliers[r].Name);
-			for (uint32 k = 0; k < profile::BandolierItemCount; ++k) { // Will need adjusting if 'server != client' is ever true
+			for (uint32 k = 0; k < profile::BANDOLIER_ITEM_COUNT; ++k) { // Will need adjusting if 'server != client' is ever true
 				OUT(bandoliers[r].Items[k].ID);
 				OUT(bandoliers[r].Items[k].Icon);
 				OUT_str(bandoliers[r].Items[k].Name);
 			}
 		}
 		// Nullify bandoliers where server and client indexes diverge, with a client bias
-		for (r = EQEmu::legacy::BANDOLIERS_SIZE; r < profile::BandoliersSize; ++r) {
+		for (r = EQEmu::profile::BANDOLIERS_SIZE; r < profile::BANDOLIERS_SIZE; ++r) {
 			eq->bandoliers[r].Name[0] = '\0';
-			for (uint32 k = 0; k < profile::BandolierItemCount; ++k) { // Will need adjusting if 'server != client' is ever true
+			for (uint32 k = 0; k < profile::BANDOLIER_ITEM_COUNT; ++k) { // Will need adjusting if 'server != client' is ever true
 				eq->bandoliers[r].Items[k].ID = 0;
 				eq->bandoliers[r].Items[k].Icon = 0;
 				eq->bandoliers[r].Items[k].Name[0] = '\0';
@@ -1902,13 +1791,13 @@ namespace UF
 		//	OUT(unknown07444[5120]);
 
 		// Copy potion belt where server and client indexes converge
-		for (r = 0; r < EQEmu::legacy::POTION_BELT_ITEM_COUNT && r < profile::PotionBeltSize; ++r) {
+		for (r = 0; r < EQEmu::profile::POTION_BELT_SIZE && r < profile::POTION_BELT_SIZE; ++r) {
 			OUT(potionbelt.Items[r].ID);
 			OUT(potionbelt.Items[r].Icon);
 			OUT_str(potionbelt.Items[r].Name);
 		}
 		// Nullify potion belt where server and client indexes diverge, with a client bias
-		for (r = EQEmu::legacy::POTION_BELT_ITEM_COUNT; r < profile::PotionBeltSize; ++r) {
+		for (r = EQEmu::profile::POTION_BELT_SIZE; r < profile::POTION_BELT_SIZE; ++r) {
 			eq->potionbelt.Items[r].ID = 0;
 			eq->potionbelt.Items[r].Icon = 0;
 			eq->potionbelt.Items[r].Name[0] = '\0';
@@ -2217,8 +2106,8 @@ namespace UF
 			eq->CharCount = emu->CharCount;
 			eq->TotalChars = emu->TotalChars;
 
-			if (eq->TotalChars > constants::CharacterCreationLimit)
-				eq->TotalChars = constants::CharacterCreationLimit;
+			if (eq->TotalChars > constants::CHARACTER_CREATION_LIMIT)
+				eq->TotalChars = constants::CHARACTER_CREATION_LIMIT;
 
 			// Special Underfoot adjustment - field should really be 'AdditionalChars' or 'BonusChars'
 			uint32 adjusted_total = eq->TotalChars - 8; // Yes, it rolls under for '< 8' - probably an int32 field
@@ -2234,7 +2123,7 @@ namespace UF
 
 		size_t names_length = 0;
 		size_t character_count = 0;
-		for (; character_count < emu->CharCount && character_count < constants::CharacterCreationLimit; ++character_count) {
+		for (; character_count < emu->CharCount && character_count < constants::CHARACTER_CREATION_LIMIT; ++character_count) {
 			emu_cse = (CharacterSelectEntry_Struct *)emu_ptr;
 			names_length += strlen(emu_cse->Name);
 			emu_ptr += sizeof(CharacterSelectEntry_Struct);
@@ -2250,8 +2139,8 @@ namespace UF
 		eq->CharCount = character_count;
 		eq->TotalChars = emu->TotalChars;
 
-		if (eq->TotalChars > constants::CharacterCreationLimit)
-			eq->TotalChars = constants::CharacterCreationLimit;
+		if (eq->TotalChars > constants::CHARACTER_CREATION_LIMIT)
+			eq->TotalChars = constants::CHARACTER_CREATION_LIMIT;
 
 		// Special Underfoot adjustment - field should really be 'AdditionalChars' or 'BonusChars' in this client
 		uint32 adjusted_total = eq->TotalChars - 8; // Yes, it rolls under for '< 8' - probably an int32 field
@@ -2528,13 +2417,16 @@ namespace UF
 		InBuffer += description_size;
 		InBuffer += sizeof(TaskDescriptionData2_Struct);
 
-		std::string old_message = InBuffer; // start 'Reward' as string
+		uint32 reward_size = strlen(InBuffer) + 1;
+		InBuffer += reward_size;
+
+		std::string old_message = InBuffer; // start item link string
 		std::string new_message;
 		ServerToUFSayLink(new_message, old_message);
 
 		in->size = sizeof(TaskDescriptionHeader_Struct) + sizeof(TaskDescriptionData1_Struct)+
 			sizeof(TaskDescriptionData2_Struct) + sizeof(TaskDescriptionTrailer_Struct)+
-			title_size + description_size + new_message.length() + 1;
+			title_size + description_size + reward_size + new_message.length() + 1;
 
 		in->pBuffer = new unsigned char[in->size];
 
@@ -3918,7 +3810,7 @@ namespace UF
 		ibs.nodrop = item->NoDrop;
 		ibs.attune = item->Attuneable;
 		ibs.size = item->Size;
-		ibs.slots = SwapBits21and22(item->Slots);
+		ibs.slots = SwapBits21And22(item->Slots);
 		ibs.price = item->Price;
 		ibs.icon = item->Icon;
 		ibs.unknown1 = 1;
@@ -4008,7 +3900,7 @@ namespace UF
 		isbs.augtype = item->AugType;
 		isbs.augrestrict = item->AugRestrict;
 
-		for (int index = 0; index < invaug::ItemAugSize; ++index) {
+		for (int index = invaug::SOCKET_BEGIN; index <= invaug::SOCKET_END; ++index) {
 			isbs.augslots[index].type = item->AugSlotType[index];
 			isbs.augslots[index].visible = item->AugSlotVisible[index];
 			isbs.augslots[index].unknown = item->AugSlotUnk2[index];
@@ -4204,18 +4096,18 @@ namespace UF
 
 		ob.write((const char*)&subitem_count, sizeof(uint32));
 
-		for (uint32 index = EQEmu::inventory::containerBegin; index < EQEmu::inventory::ContainerCount; ++index) {
+		for (uint32 index = EQEmu::invbag::SLOT_BEGIN; index <= EQEmu::invbag::SLOT_END; ++index) {
 			EQEmu::ItemInstance* sub = inst->GetItem(index);
 			if (!sub)
 				continue;
 
 			int SubSlotNumber = INVALID_INDEX;
-			if (slot_id_in >= EQEmu::legacy::GENERAL_BEGIN && slot_id_in <= EQEmu::legacy::GENERAL_END)
-				SubSlotNumber = (((slot_id_in + 3) * EQEmu::inventory::ContainerCount) + index + 1);
-			else if (slot_id_in >= EQEmu::legacy::BANK_BEGIN && slot_id_in <= EQEmu::legacy::BANK_END)
-				SubSlotNumber = (((slot_id_in - EQEmu::legacy::BANK_BEGIN) * EQEmu::inventory::ContainerCount) + EQEmu::legacy::BANK_BAGS_BEGIN + index);
-			else if (slot_id_in >= EQEmu::legacy::SHARED_BANK_BEGIN && slot_id_in <= EQEmu::legacy::SHARED_BANK_END)
-				SubSlotNumber = (((slot_id_in - EQEmu::legacy::SHARED_BANK_BEGIN) * EQEmu::inventory::ContainerCount) + EQEmu::legacy::SHARED_BANK_BAGS_BEGIN + index);
+			if (slot_id_in >= EQEmu::invslot::GENERAL_BEGIN && slot_id_in <= EQEmu::invslot::GENERAL_END)
+				SubSlotNumber = (((slot_id_in + 3) * EQEmu::invbag::SLOT_COUNT) + index + 1);
+			else if (slot_id_in >= EQEmu::invslot::BANK_BEGIN && slot_id_in <= EQEmu::invslot::BANK_END)
+				SubSlotNumber = (((slot_id_in - EQEmu::invslot::BANK_BEGIN) * EQEmu::invbag::SLOT_COUNT) + EQEmu::invbag::BANK_BAGS_BEGIN + index);
+			else if (slot_id_in >= EQEmu::invslot::SHARED_BANK_BEGIN && slot_id_in <= EQEmu::invslot::SHARED_BANK_END)
+				SubSlotNumber = (((slot_id_in - EQEmu::invslot::SHARED_BANK_BEGIN) * EQEmu::invbag::SLOT_COUNT) + EQEmu::invbag::SHARED_BANK_BAGS_BEGIN + index);
 			else
 				SubSlotNumber = slot_id_in;
 
@@ -4233,16 +4125,16 @@ namespace UF
 	{
 		uint32 UnderfootSlot = 0;
 
-		if (serverSlot >= EQEmu::inventory::slotAmmo && serverSlot <= 53) // Cursor/Ammo/Power Source and Normal Inventory Slots
+		if (serverSlot >= EQEmu::invslot::slotAmmo && serverSlot <= 53) // Cursor/Ammo/Power Source and Normal Inventory Slots
 			UnderfootSlot = serverSlot + 1;
-		else if (serverSlot >= EQEmu::legacy::GENERAL_BAGS_BEGIN && serverSlot <= EQEmu::legacy::CURSOR_BAG_END)
+		else if (serverSlot >= EQEmu::invbag::GENERAL_BAGS_BEGIN && serverSlot <= EQEmu::invbag::CURSOR_BAG_END)
 			UnderfootSlot = serverSlot + 11;
-		else if (serverSlot >= EQEmu::legacy::BANK_BAGS_BEGIN && serverSlot <= EQEmu::legacy::BANK_BAGS_END)
+		else if (serverSlot >= EQEmu::invbag::BANK_BAGS_BEGIN && serverSlot <= EQEmu::invbag::BANK_BAGS_END)
 			UnderfootSlot = serverSlot + 1;
-		else if (serverSlot >= EQEmu::legacy::SHARED_BANK_BAGS_BEGIN && serverSlot <= EQEmu::legacy::SHARED_BANK_BAGS_END)
+		else if (serverSlot >= EQEmu::invbag::SHARED_BANK_BAGS_BEGIN && serverSlot <= EQEmu::invbag::SHARED_BANK_BAGS_END)
 			UnderfootSlot = serverSlot + 1;
-		else if (serverSlot == EQEmu::inventory::slotPowerSource)
-			UnderfootSlot = invslot::PossessionsPowerSource;
+		else if (serverSlot == EQEmu::invslot::SLOT_POWER_SOURCE)
+			UnderfootSlot = invslot::slotPowerSource;
 		else
 			UnderfootSlot = serverSlot;
 
@@ -4259,16 +4151,16 @@ namespace UF
 	{
 		uint32 ServerSlot = 0;
 
-		if (ufSlot >= invslot::PossessionsAmmo && ufSlot <= invslot::CorpseEnd) // Cursor/Ammo/Power Source and Normal Inventory Slots
+		if (ufSlot >= invslot::slotAmmo && ufSlot <= invslot::CORPSE_END) // Cursor/Ammo/Power Source and Normal Inventory Slots
 			ServerSlot = ufSlot - 1;
-		else if (ufSlot >= invbag::GeneralBagsBegin && ufSlot <= invbag::CursorBagEnd)
+		else if (ufSlot >= invbag::GENERAL_BAGS_BEGIN && ufSlot <= invbag::CURSOR_BAG_END)
 			ServerSlot = ufSlot - 11;
-		else if (ufSlot >= invbag::BankBagsBegin && ufSlot <= invbag::BankBagsEnd)
+		else if (ufSlot >= invbag::BANK_BAGS_BEGIN && ufSlot <= invbag::BANK_BAGS_END)
 			ServerSlot = ufSlot - 1;
-		else if (ufSlot >= invbag::SharedBankBagsBegin && ufSlot <= invbag::SharedBankBagsEnd)
+		else if (ufSlot >= invbag::SHARED_BANK_BAGS_BEGIN && ufSlot <= invbag::SHARED_BANK_BAGS_END)
 			ServerSlot = ufSlot - 1;
-		else if (ufSlot == invslot::PossessionsPowerSource)
-			ServerSlot = EQEmu::inventory::slotPowerSource;
+		else if (ufSlot == invslot::slotPowerSource)
+			ServerSlot = EQEmu::invslot::SLOT_POWER_SOURCE;
 		else
 			ServerSlot = ufSlot;
 
@@ -4283,7 +4175,7 @@ namespace UF
 
 	static inline void ServerToUFSayLink(std::string& ufSayLink, const std::string& serverSayLink)
 	{
-		if ((constants::SayLinkBodySize == EQEmu::constants::SayLinkBodySize) || (serverSayLink.find('\x12') == std::string::npos)) {
+		if ((constants::SAY_LINK_BODY_SIZE == EQEmu::constants::SAY_LINK_BODY_SIZE) || (serverSayLink.find('\x12') == std::string::npos)) {
 			ufSayLink = serverSayLink;
 			return;
 		}
@@ -4292,7 +4184,7 @@ namespace UF
 
 		for (size_t segment_iter = 0; segment_iter < segments.size(); ++segment_iter) {
 			if (segment_iter & 1) {
-				if (segments[segment_iter].length() <= EQEmu::constants::SayLinkBodySize) {
+				if (segments[segment_iter].length() <= EQEmu::constants::SAY_LINK_BODY_SIZE) {
 					ufSayLink.append(segments[segment_iter]);
 					// TODO: log size mismatch error
 					continue;
@@ -4323,7 +4215,7 @@ namespace UF
 
 	static inline void UFToServerSayLink(std::string& serverSayLink, const std::string& ufSayLink)
 	{
-		if ((EQEmu::constants::SayLinkBodySize == constants::SayLinkBodySize) || (ufSayLink.find('\x12') == std::string::npos)) {
+		if ((EQEmu::constants::SAY_LINK_BODY_SIZE == constants::SAY_LINK_BODY_SIZE) || (ufSayLink.find('\x12') == std::string::npos)) {
 			serverSayLink = ufSayLink;
 			return;
 		}
@@ -4332,7 +4224,7 @@ namespace UF
 
 		for (size_t segment_iter = 0; segment_iter < segments.size(); ++segment_iter) {
 			if (segment_iter & 1) {
-				if (segments[segment_iter].length() <= constants::SayLinkBodySize) {
+				if (segments[segment_iter].length() <= constants::SAY_LINK_BODY_SIZE) {
 					serverSayLink.append(segments[segment_iter]);
 					// TODO: log size mismatch error
 					continue;

common/patches/uf_limits.cpp

@@ -22,198 +22,198 @@
 #include "../string_util.h"
 
 
-size_t UF::invtype::GetInvTypeSize(int inv_type)
+int16 UF::invtype::GetInvTypeSize(int16 inv_type)
 {
 	switch (inv_type) {
-	case invtype::InvTypePossessions:
-		return invtype::InvTypePossessionsSize;
-	case invtype::InvTypeBank:
-		return invtype::InvTypeBankSize;
-	case invtype::InvTypeSharedBank:
-		return invtype::InvTypeSharedBankSize;
-	case invtype::InvTypeTrade:
-		return invtype::InvTypeTradeSize;
-	case invtype::InvTypeWorld:
-		return invtype::InvTypeWorldSize;
-	case invtype::InvTypeLimbo:
-		return invtype::InvTypeLimboSize;
-	case invtype::InvTypeTribute:
-		return invtype::InvTypeTributeSize;
-	case invtype::InvTypeGuildTribute:
-		return invtype::InvTypeGuildTributeSize;
-	case invtype::InvTypeMerchant:
-		return invtype::InvTypeMerchantSize;
-	case invtype::InvTypeCorpse:
-		return invtype::InvTypeCorpseSize;
-	case invtype::InvTypeBazaar:
-		return invtype::InvTypeBazaarSize;
-	case invtype::InvTypeInspect:
-		return invtype::InvTypeInspectSize;
-	case invtype::InvTypeViewMODPC:
-		return invtype::InvTypeViewMODPCSize;
-	case invtype::InvTypeViewMODBank:
-		return invtype::InvTypeViewMODBankSize;
-	case invtype::InvTypeViewMODSharedBank:
-		return invtype::InvTypeViewMODSharedBankSize;
-	case invtype::InvTypeViewMODLimbo:
-		return invtype::InvTypeViewMODLimboSize;
-	case invtype::InvTypeAltStorage:
-		return invtype::InvTypeAltStorageSize;
-	case invtype::InvTypeArchived:
-		return invtype::InvTypeArchivedSize;
-	case invtype::InvTypeOther:
-		return invtype::InvTypeOtherSize;
+	case invtype::typePossessions:
+		return invtype::POSSESSIONS_SIZE;
+	case invtype::typeBank:
+		return invtype::BANK_SIZE;
+	case invtype::typeSharedBank:
+		return invtype::SHARED_BANK_SIZE;
+	case invtype::typeTrade:
+		return invtype::TRADE_SIZE;
+	case invtype::typeWorld:
+		return invtype::WORLD_SIZE;
+	case invtype::typeLimbo:
+		return invtype::LIMBO_SIZE;
+	case invtype::typeTribute:
+		return invtype::TRIBUTE_SIZE;
+	case invtype::typeGuildTribute:
+		return invtype::GUILD_TRIBUTE_SIZE;
+	case invtype::typeMerchant:
+		return invtype::MERCHANT_SIZE;
+	case invtype::typeCorpse:
+		return invtype::CORPSE_SIZE;
+	case invtype::typeBazaar:
+		return invtype::BAZAAR_SIZE;
+	case invtype::typeInspect:
+		return invtype::INSPECT_SIZE;
+	case invtype::typeViewMODPC:
+		return invtype::VIEW_MOD_PC_SIZE;
+	case invtype::typeViewMODBank:
+		return invtype::VIEW_MOD_BANK_SIZE;
+	case invtype::typeViewMODSharedBank:
+		return invtype::VIEW_MOD_SHARED_BANK_SIZE;
+	case invtype::typeViewMODLimbo:
+		return invtype::VIEW_MOD_LIMBO_SIZE;
+	case invtype::typeAltStorage:
+		return invtype::ALT_STORAGE_SIZE;
+	case invtype::typeArchived:
+		return invtype::ARCHIVED_SIZE;
+	case invtype::typeOther:
+		return invtype::OTHER_SIZE;
 	default:
-		return 0;
+		return INULL;
 	}
 }
 
-const char* UF::invtype::GetInvTypeName(int inv_type)
+const char* UF::invtype::GetInvTypeName(int16 inv_type)
 {
 	switch (inv_type) {
-	case invtype::InvTypeInvalid:
+	case invtype::TYPE_INVALID:
 		return "Invalid Type";
-	case invtype::InvTypePossessions:
+	case invtype::typePossessions:
 		return "Possessions";
-	case invtype::InvTypeBank:
+	case invtype::typeBank:
 		return "Bank";
-	case invtype::InvTypeSharedBank:
+	case invtype::typeSharedBank:
 		return "Shared Bank";
-	case invtype::InvTypeTrade:
+	case invtype::typeTrade:
 		return "Trade";
-	case invtype::InvTypeWorld:
+	case invtype::typeWorld:
 		return "World";
-	case invtype::InvTypeLimbo:
+	case invtype::typeLimbo:
 		return "Limbo";
-	case invtype::InvTypeTribute:
+	case invtype::typeTribute:
 		return "Tribute";
-	case invtype::InvTypeGuildTribute:
+	case invtype::typeGuildTribute:
 		return "Guild Tribute";
-	case invtype::InvTypeMerchant:
+	case invtype::typeMerchant:
 		return "Merchant";
-	case invtype::InvTypeCorpse:
+	case invtype::typeCorpse:
 		return "Corpse";
-	case invtype::InvTypeBazaar:
+	case invtype::typeBazaar:
 		return "Bazaar";
-	case invtype::InvTypeInspect:
+	case invtype::typeInspect:
 		return "Inspect";
-	case invtype::InvTypeViewMODPC:
+	case invtype::typeViewMODPC:
 		return "View MOD PC";
-	case invtype::InvTypeViewMODBank:
+	case invtype::typeViewMODBank:
 		return "View MOD Bank";
-	case invtype::InvTypeViewMODSharedBank:
+	case invtype::typeViewMODSharedBank:
 		return "View MOD Shared Bank";
-	case invtype::InvTypeViewMODLimbo:
+	case invtype::typeViewMODLimbo:
 		return "View MOD Limbo";
-	case invtype::InvTypeAltStorage:
+	case invtype::typeAltStorage:
 		return "Alt Storage";
-	case invtype::InvTypeArchived:
+	case invtype::typeArchived:
 		return "Archived";
-	case invtype::InvTypeOther:
+	case invtype::typeOther:
 		return "Other";
 	default:
 		return "Unknown Type";
 	}
 }
 
-bool UF::invtype::IsInvTypePersistent(int inv_type)
+bool UF::invtype::IsInvTypePersistent(int16 inv_type)
 {
 	switch (inv_type) {
-	case invtype::InvTypePossessions:
-	case invtype::InvTypeBank:
-	case invtype::InvTypeSharedBank:
-	case invtype::InvTypeTrade:
-	case invtype::InvTypeWorld:
-	case invtype::InvTypeLimbo:
-	case invtype::InvTypeTribute:
-	case invtype::InvTypeGuildTribute:
+	case invtype::typePossessions:
+	case invtype::typeBank:
+	case invtype::typeSharedBank:
+	case invtype::typeTrade:
+	case invtype::typeWorld:
+	case invtype::typeLimbo:
+	case invtype::typeTribute:
+	case invtype::typeGuildTribute:
 		return true;
 	default:
 		return false;
 	}
 }
 
-const char* UF::invslot::GetInvPossessionsSlotName(int inv_slot)
+const char* UF::invslot::GetInvPossessionsSlotName(int16 inv_slot)
 {
 	switch (inv_slot) {
-	case invslot::InvSlotInvalid:
+	case invslot::SLOT_INVALID:
 		return "Invalid Slot";
-	case invslot::PossessionsCharm:
+	case invslot::slotCharm:
 		return "Charm";
-	case invslot::PossessionsEar1:
+	case invslot::slotEar1:
 		return "Ear 1";
-	case invslot::PossessionsHead:
+	case invslot::slotHead:
 		return "Head";
-	case invslot::PossessionsFace:
+	case invslot::slotFace:
 		return "Face";
-	case invslot::PossessionsEar2:
+	case invslot::slotEar2:
 		return "Ear 2";
-	case invslot::PossessionsNeck:
+	case invslot::slotNeck:
 		return "Neck";
-	case invslot::PossessionsShoulders:
+	case invslot::slotShoulders:
 		return "Shoulders";
-	case invslot::PossessionsArms:
+	case invslot::slotArms:
 		return "Arms";
-	case invslot::PossessionsBack:
+	case invslot::slotBack:
 		return "Back";
-	case invslot::PossessionsWrist1:
+	case invslot::slotWrist1:
 		return "Wrist 1";
-	case invslot::PossessionsWrist2:
+	case invslot::slotWrist2:
 		return "Wrist 2";
-	case invslot::PossessionsRange:
+	case invslot::slotRange:
 		return "Range";
-	case invslot::PossessionsHands:
+	case invslot::slotHands:
 		return "Hands";
-	case invslot::PossessionsPrimary:
+	case invslot::slotPrimary:
 		return "Primary";
-	case invslot::PossessionsSecondary:
+	case invslot::slotSecondary:
 		return "Secondary";
-	case invslot::PossessionsFinger1:
+	case invslot::slotFinger1:
 		return "Finger 1";
-	case invslot::PossessionsFinger2:
+	case invslot::slotFinger2:
 		return "Finger 2";
-	case invslot::PossessionsChest:
+	case invslot::slotChest:
 		return "Chest";
-	case invslot::PossessionsLegs:
+	case invslot::slotLegs:
 		return "Legs";
-	case invslot::PossessionsFeet:
+	case invslot::slotFeet:
 		return "Feet";
-	case invslot::PossessionsWaist:
+	case invslot::slotWaist:
 		return "Waist";
-	case invslot::PossessionsPowerSource:
+	case invslot::slotPowerSource:
 		return "Power Source";
-	case invslot::PossessionsAmmo:
+	case invslot::slotAmmo:
 		return "Ammo";
-	case invslot::PossessionsGeneral1:
+	case invslot::slotGeneral1:
 		return "General 1";
-	case invslot::PossessionsGeneral2:
+	case invslot::slotGeneral2:
 		return "General 2";
-	case invslot::PossessionsGeneral3:
+	case invslot::slotGeneral3:
 		return "General 3";
-	case invslot::PossessionsGeneral4:
+	case invslot::slotGeneral4:
 		return "General 4";
-	case invslot::PossessionsGeneral5:
+	case invslot::slotGeneral5:
 		return "General 5";
-	case invslot::PossessionsGeneral6:
+	case invslot::slotGeneral6:
 		return "General 6";
-	case invslot::PossessionsGeneral7:
+	case invslot::slotGeneral7:
 		return "General 7";
-	case invslot::PossessionsGeneral8:
+	case invslot::slotGeneral8:
 		return "General 8";
-	case invslot::PossessionsCursor:
+	case invslot::slotCursor:
 		return "Cursor";
 	default:
 		return "Unknown Slot";
 	}
 }
 
-const char* UF::invslot::GetInvCorpseSlotName(int inv_slot)
+const char* UF::invslot::GetInvCorpseSlotName(int16 inv_slot)
 {
-	if (!invtype::GetInvTypeSize(invtype::InvTypeCorpse) || inv_slot == invslot::InvSlotInvalid)
+	if (!invtype::GetInvTypeSize(invtype::typeCorpse) || inv_slot == invslot::SLOT_INVALID)
 		return "Invalid Slot";
 
 	// needs work
-	if ((size_t)(inv_slot + 1) < invslot::CorpseBegin || (size_t)(inv_slot + 1) >= invslot::CorpseEnd)
+	if ((inv_slot + 1) < invslot::CORPSE_BEGIN || (inv_slot + 1) >= invslot::CORPSE_END)
 		return "Unknown Slot";
 
 	static std::string ret_str;
@@ -222,19 +222,19 @@ const char* UF::invslot::GetInvCorpseSlotName(int inv_slot)
 	return ret_str.c_str();
 }
 
-const char* UF::invslot::GetInvSlotName(int inv_type, int inv_slot)
+const char* UF::invslot::GetInvSlotName(int16 inv_type, int16 inv_slot)
 {
-	if (inv_type == invtype::InvTypePossessions)
+	if (inv_type == invtype::typePossessions)
 		return invslot::GetInvPossessionsSlotName(inv_slot);
-	else if (inv_type == invtype::InvTypeCorpse)
+	else if (inv_type == invtype::typeCorpse)
 		return invslot::GetInvCorpseSlotName(inv_slot);
 
-	size_t type_size = invtype::GetInvTypeSize(inv_type);
+	int16 type_size = invtype::GetInvTypeSize(inv_type);
 
-	if (!type_size || inv_slot == invslot::InvSlotInvalid)
+	if (!type_size || inv_slot == invslot::SLOT_INVALID)
 		return "Invalid Slot";
 
-	if ((size_t)(inv_slot + 1) >= type_size)
+	if ((inv_slot + 1) >= type_size)
 		return "Unknown Slot";
 
 	static std::string ret_str;
@@ -243,12 +243,12 @@ const char* UF::invslot::GetInvSlotName(int inv_type, int inv_slot)
 	return ret_str.c_str();
 }
 
-const char* UF::invbag::GetInvBagIndexName(int bag_index)
+const char* UF::invbag::GetInvBagIndexName(int16 bag_index)
 {
-	if (bag_index == invbag::InvBagInvalid)
+	if (bag_index == invbag::SLOT_INVALID)
 		return "Invalid Bag";
 
-	if ((size_t)bag_index >= invbag::ItemBagSize)
+	if (bag_index >= invbag::SLOT_COUNT)
 		return "Unknown Bag";
 
 	static std::string ret_str;
@@ -257,12 +257,12 @@ const char* UF::invbag::GetInvBagIndexName(int bag_index)
 	return ret_str.c_str();
 }
 
-const char* UF::invaug::GetInvAugIndexName(int aug_index)
+const char* UF::invaug::GetInvAugIndexName(int16 aug_index)
 {
-	if (aug_index == invaug::InvAugInvalid)
+	if (aug_index == invaug::SOCKET_INVALID)
 		return "Invalid Augment";
 
-	if ((size_t)aug_index >= invaug::ItemAugSize)
+	if (aug_index >= invaug::SOCKET_COUNT)
 		return "Unknown Augment";
 
 	static std::string ret_str;

common/patches/uf_limits.h

@@ -27,109 +27,219 @@
 
 namespace UF
 {
-	enum : int { Invalid = -1, Null, Safety };
+	const int16 IINVALID = -1;
+	const int16 INULL = 0;
 
-	enum : bool { False = false, True = true };
-
-	// pre-declarations
 	namespace inventory {
 		inline EQEmu::versions::ClientVersion GetInventoryRef() { return EQEmu::versions::ClientVersion::UF; }
 
+		const bool ConcatenateInvTypeLimbo = true;
+
+		const bool AllowOverLevelEquipment = true;
+
+		const bool AllowEmptyBagInBag = false;
+		const bool AllowClickCastFromBag = false;
+
 	} /*inventory*/
 
 	namespace invtype {
 		inline EQEmu::versions::ClientVersion GetInvTypeRef() { return EQEmu::versions::ClientVersion::UF; }
 
-		enum : int { InvTypeInvalid = -1, InvTypeBegin };
+		namespace enum_ {
+			enum InventoryTypes : int16 {
+				typePossessions = INULL,
+				typeBank,
+				typeSharedBank,
+				typeTrade,
+				typeWorld,
+				typeLimbo,
+				typeTribute,
+				typeGuildTribute,
+				typeMerchant,
+				typeCorpse,
+				typeBazaar,
+				typeInspect,
+				typeViewMODPC,
+				typeViewMODBank,
+				typeViewMODSharedBank,
+				typeViewMODLimbo,
+				typeAltStorage,
+				typeArchived,
+				typeOther
+			};
 
-		enum InventoryType : int {
-			InvTypePossessions = InvTypeBegin,
-			InvTypeBank,
-			InvTypeSharedBank,
-			InvTypeTrade,
-			InvTypeWorld,
-			InvTypeLimbo,
-			InvTypeTribute,
-			InvTypeGuildTribute,
-			InvTypeMerchant,
-			InvTypeCorpse,
-			InvTypeBazaar,
-			InvTypeInspect,
-			InvTypeViewMODPC,
-			InvTypeViewMODBank,
-			InvTypeViewMODSharedBank,
-			InvTypeViewMODLimbo,
-			InvTypeAltStorage,
-			InvTypeArchived,
-			InvTypeOther,
-			InvTypeCount
-		};
+		} // namespace enum_
+		using namespace enum_;
+
+		const int16 POSSESSIONS_SIZE = 32;
+		const int16 BANK_SIZE = 24;
+		const int16 SHARED_BANK_SIZE = 2;
+		const int16 TRADE_SIZE = 8;
+		const int16 WORLD_SIZE = 10;
+		const int16 LIMBO_SIZE = 36;
+		const int16 TRIBUTE_SIZE = 5;
+		const int16 GUILD_TRIBUTE_SIZE = 2;
+		const int16 MERCHANT_SIZE = 80;
+		const int16 CORPSE_SIZE = POSSESSIONS_SIZE;
+		const int16 BAZAAR_SIZE = 80;
+		const int16 INSPECT_SIZE = 23;
+		const int16 VIEW_MOD_PC_SIZE = POSSESSIONS_SIZE;
+		const int16 VIEW_MOD_BANK_SIZE = BANK_SIZE;
+		const int16 VIEW_MOD_SHARED_BANK_SIZE = SHARED_BANK_SIZE;
+		const int16 VIEW_MOD_LIMBO_SIZE = LIMBO_SIZE;
+		const int16 ALT_STORAGE_SIZE = 0;//unknown - "Shroud Bank"
+		const int16 ARCHIVED_SIZE = 0;//unknown
+		const int16 OTHER_SIZE = 0;//unknown
+
+		const int16 TRADE_NPC_SIZE = 4; // defined by implication
+
+		const int16 TYPE_INVALID = IINVALID;
+		const int16 TYPE_BEGIN = typePossessions;
+		const int16 TYPE_END = typeOther;
+		const int16 TYPE_COUNT = (TYPE_END - TYPE_BEGIN) + 1;
+
+		int16 GetInvTypeSize(int16 inv_type);
+		const char* GetInvTypeName(int16 inv_type);
+
+		bool IsInvTypePersistent(int16 inv_type);
 
 	} /*invtype*/
 
 	namespace invslot {
 		inline EQEmu::versions::ClientVersion GetInvSlotRef() { return EQEmu::versions::ClientVersion::UF; }
 
-		enum : int { InvSlotInvalid = -1, InvSlotBegin };
+		namespace enum_ {
+			enum InventorySlots : int16 {
+				slotCharm = INULL,
+				slotEar1,
+				slotHead,
+				slotFace,
+				slotEar2,
+				slotNeck,
+				slotShoulders,
+				slotArms,
+				slotBack,
+				slotWrist1,
+				slotWrist2,
+				slotRange,
+				slotHands,
+				slotPrimary,
+				slotSecondary,
+				slotFinger1,
+				slotFinger2,
+				slotChest,
+				slotLegs,
+				slotFeet,
+				slotWaist,
+				slotPowerSource,
+				slotAmmo,
+				slotGeneral1,
+				slotGeneral2,
+				slotGeneral3,
+				slotGeneral4,
+				slotGeneral5,
+				slotGeneral6,
+				slotGeneral7,
+				slotGeneral8,
+				slotCursor
+			};
 
-		enum PossessionsSlot : int {
-			PossessionsCharm = InvSlotBegin,
-			PossessionsEar1,
-			PossessionsHead,
-			PossessionsFace,
-			PossessionsEar2,
-			PossessionsNeck,
-			PossessionsShoulders,
-			PossessionsArms,
-			PossessionsBack,
-			PossessionsWrist1,
-			PossessionsWrist2,
-			PossessionsRange,
-			PossessionsHands,
-			PossessionsPrimary,
-			PossessionsSecondary,
-			PossessionsFinger1,
-			PossessionsFinger2,
-			PossessionsChest,
-			PossessionsLegs,
-			PossessionsFeet,
-			PossessionsWaist,
-			PossessionsPowerSource,
-			PossessionsAmmo,
-			PossessionsGeneral1,
-			PossessionsGeneral2,
-			PossessionsGeneral3,
-			PossessionsGeneral4,
-			PossessionsGeneral5,
-			PossessionsGeneral6,
-			PossessionsGeneral7,
-			PossessionsGeneral8,
-			PossessionsCursor,
-			PossessionsCount
-		};
+		} // namespace enum_
+		using namespace enum_;
 
-		const int EquipmentBegin = PossessionsCharm;
-		const int EquipmentEnd = PossessionsAmmo;
-		const int EquipmentCount = (EquipmentEnd - EquipmentBegin + 1);
+		const int16 SLOT_INVALID = IINVALID;
+		const int16 SLOT_BEGIN = INULL;
 
-		const int GeneralBegin = PossessionsGeneral1;
-		const int GeneralEnd = PossessionsGeneral8;
-		const int GeneralCount = (GeneralEnd - GeneralBegin + 1);
+		const int16 POSSESSIONS_BEGIN = slotCharm;
+		const int16 POSSESSIONS_END = slotCursor;
+		const int16 POSSESSIONS_COUNT = (POSSESSIONS_END - POSSESSIONS_BEGIN) + 1;
+
+		const int16 EQUIPMENT_BEGIN = slotCharm;
+		const int16 EQUIPMENT_END = slotAmmo;
+		const int16 EQUIPMENT_COUNT = (EQUIPMENT_END - EQUIPMENT_BEGIN + 1);
+
+		const int16 GENERAL_BEGIN = slotGeneral1;
+		const int16 GENERAL_END = slotGeneral8;
+		const int16 GENERAL_COUNT = (GENERAL_END - GENERAL_BEGIN + 1);
+
+		const int16 BONUS_BEGIN = invslot::slotCharm;
+		const int16 BONUS_STAT_END = invslot::slotPowerSource;
+		const int16 BONUS_SKILL_END = invslot::slotAmmo;
+
+		const int16 BANK_BEGIN = 2000;
+		const int16 BANK_END = (BANK_BEGIN + invtype::BANK_SIZE) - 1;
+
+		const int16 SHARED_BANK_BEGIN = 2500;
+		const int16 SHARED_BANK_END = (SHARED_BANK_BEGIN + invtype::SHARED_BANK_SIZE) - 1;
+
+		const int16 TRADE_BEGIN = 3000;
+		const int16 TRADE_END = (TRADE_BEGIN + invtype::TRADE_SIZE) - 1;
+
+		const int16 TRADE_NPC_END = (TRADE_BEGIN + invtype::TRADE_NPC_SIZE) - 1; // defined by implication
+
+		const int16 WORLD_BEGIN = 4000;
+		const int16 WORLD_END = (WORLD_BEGIN + invtype::WORLD_SIZE) - 1;
+
+		const int16 TRIBUTE_BEGIN = 400;
+		const int16 TRIBUTE_END = (TRIBUTE_BEGIN + invtype::TRIBUTE_SIZE) - 1;
+
+		const int16 GUILD_TRIBUTE_BEGIN = 450;
+		const int16 GUILD_TRIBUTE_END = (GUILD_TRIBUTE_BEGIN + invtype::GUILD_TRIBUTE_SIZE) - 1;
+
+		const int16 CORPSE_BEGIN = invslot::slotGeneral1;
+		const int16 CORPSE_END = invslot::slotGeneral1 + invslot::slotCursor;
+
+		const uint64 POSSESSIONS_BITMASK = 0x000000027FFFFFFF; // based on 34-slot count (RoF+)
+		const uint64 CORPSE_BITMASK = 0x01FFFFFE7F800000; // based on 34-slot count (RoF+)
+
+		const char* GetInvPossessionsSlotName(int16 inv_slot);
+		const char* GetInvCorpseSlotName(int16 inv_slot);
+		const char* GetInvSlotName(int16 inv_type, int16 inv_slot);
 
 	} /*invslot*/
 
 	namespace invbag {
 		inline EQEmu::versions::ClientVersion GetInvBagRef() { return EQEmu::versions::ClientVersion::UF; }
 
-		enum : int { InvBagInvalid = -1, InvBagBegin };
+		const int16 SLOT_INVALID = IINVALID;
+		const int16 SLOT_BEGIN = INULL;
+		const int16 SLOT_END = 9;
+		const int16 SLOT_COUNT = 10;
+
+		const int16 GENERAL_BAGS_BEGIN = 262;
+		const int16 GENERAL_BAGS_COUNT = invslot::GENERAL_COUNT * SLOT_COUNT;
+		const int16 GENERAL_BAGS_END = (GENERAL_BAGS_BEGIN + GENERAL_BAGS_COUNT) - 1;
+
+		const int16 CURSOR_BAG_BEGIN = 342;
+		const int16 CURSOR_BAG_COUNT = SLOT_COUNT;
+		const int16 CURSOR_BAG_END = (CURSOR_BAG_BEGIN + CURSOR_BAG_COUNT) - 1;
+
+		const int16 BANK_BAGS_BEGIN = 2032;
+		const int16 BANK_BAGS_COUNT = (invtype::BANK_SIZE * SLOT_COUNT);
+		const int16 BANK_BAGS_END = (BANK_BAGS_BEGIN + BANK_BAGS_COUNT) - 1;
+
+		const int16 SHARED_BANK_BAGS_BEGIN = 2532;
+		const int16 SHARED_BANK_BAGS_COUNT = invtype::SHARED_BANK_SIZE * SLOT_COUNT;
+		const int16 SHARED_BANK_BAGS_END = (SHARED_BANK_BAGS_BEGIN + SHARED_BANK_BAGS_COUNT) - 1;
+
+		const int16 TRADE_BAGS_BEGIN = 3031;
+		const int16 TRADE_BAGS_COUNT = invtype::TRADE_SIZE * SLOT_COUNT;
+		const int16 TRADE_BAGS_END = (TRADE_BAGS_BEGIN + TRADE_BAGS_COUNT) - 1;
+
+		const char* GetInvBagIndexName(int16 bag_index);
 
 	} /*invbag*/
 
 	namespace invaug {
 		inline EQEmu::versions::ClientVersion GetInvAugRef() { return EQEmu::versions::ClientVersion::UF; }
 
-		enum : int { InvAugInvalid = -1, InvAugBegin };
+		const int16 SOCKET_INVALID = IINVALID;
+		const int16 SOCKET_BEGIN = INULL;
+		const int16 SOCKET_END = 4;
+		const int16 SOCKET_COUNT = 5;
 
+		const char* GetInvAugIndexName(int16 aug_index);
+	
 	} /*invaug*/
 
 	namespace item {
@@ -154,147 +264,21 @@ namespace UF
 	namespace profile {
 		inline EQEmu::versions::ClientVersion GetProfileRef() { return EQEmu::versions::ClientVersion::UF; }
 
+		const int16 BANDOLIERS_SIZE = 20;		// number of bandolier instances
+		const int16 BANDOLIER_ITEM_COUNT = 4;	// number of equipment slots in bandolier instance
+
+		const int16 POTION_BELT_SIZE = 5;
+
+		const int16 SKILL_ARRAY_SIZE = 100;
+
 	} /*profile*/
 
 	namespace constants {
 		inline EQEmu::versions::ClientVersion GetConstantsRef() { return EQEmu::versions::ClientVersion::UF; }
 
-	} /*constants*/
+		const size_t CHARACTER_CREATION_LIMIT = 12;
 
-	namespace behavior {
-		inline EQEmu::versions::ClientVersion GetBehaviorRef() { return EQEmu::versions::ClientVersion::UF; }
-
-	} /*behavior*/
-
-	namespace skills {
-		inline EQEmu::versions::ClientVersion GetSkillsRef() { return EQEmu::versions::ClientVersion::UF; }
-
-	} /*skills*/
-
-
-	// declarations
-	namespace inventory {
-		const bool ConcatenateInvTypeLimbo = true;
-
-		const bool AllowOverLevelEquipment = true;
-
-		const bool AllowEmptyBagInBag = false;
-		const bool AllowClickCastFromBag = false;
-
-	} /*inventory*/
-
-	namespace invtype {
-		const size_t InvTypePossessionsSize = invslot::PossessionsCount;
-		const size_t InvTypeBankSize = 24;
-		const size_t InvTypeSharedBankSize = 2;
-		const size_t InvTypeTradeSize = 8;
-		const size_t InvTypeWorldSize = 10;
-		const size_t InvTypeLimboSize = 36;
-		const size_t InvTypeTributeSize = 5;
-		const size_t InvTypeGuildTributeSize = 2;
-		const size_t InvTypeMerchantSize = 80;
-		const size_t InvTypeCorpseSize = InvTypePossessionsSize;
-		const size_t InvTypeBazaarSize = 80;
-		const size_t InvTypeInspectSize = invslot::EquipmentCount;
-		const size_t InvTypeViewMODPCSize = InvTypePossessionsSize;
-		const size_t InvTypeViewMODBankSize = InvTypeBankSize;
-		const size_t InvTypeViewMODSharedBankSize = InvTypeSharedBankSize;
-		const size_t InvTypeViewMODLimboSize = InvTypeLimboSize;
-		const size_t InvTypeAltStorageSize = 0;//unknown - "Shroud Bank"
-		const size_t InvTypeArchivedSize = 0;//unknown
-		const size_t InvTypeOtherSize = 0;//unknown
-
-		extern size_t GetInvTypeSize(int inv_type);
-		extern const char* GetInvTypeName(int inv_type);
-
-		extern bool IsInvTypePersistent(int inv_type);
-
-	} /*invtype*/
-
-	namespace invslot {
-		const int BankBegin = 2000;
-		const int BankEnd = (BankBegin + invtype::InvTypeBankSize) - 1;
-
-		const int SharedBankBegin = 2500;
-		const int SharedBankEnd = (SharedBankBegin + invtype::InvTypeSharedBankSize) - 1;
-
-		const int TradeBegin = 3000;
-		const int TradeEnd = (TradeBegin + invtype::InvTypeTradeSize) - 1;
-		const int TradeNPCEnd = 3003;
-
-		const int WorldBegin = 4000;
-		const int WorldEnd = (WorldBegin + invtype::InvTypeWorldSize) - 1;
-
-		const int TributeBegin = 400;
-		const int TributeEnd = (TributeBegin + invtype::InvTypeTributeSize) - 1;
-
-		const int GuildTributeBegin = 450;
-		const int GuildTributeEnd = (GuildTributeBegin + invtype::InvTypeGuildTributeSize) - 1;
-
-		const int CorpseBegin = invslot::PossessionsGeneral1;
-		const int CorpseEnd = invslot::PossessionsGeneral1 + invslot::PossessionsCursor;
-
-		extern const char* GetInvPossessionsSlotName(int inv_slot);
-		extern const char* GetInvCorpseSlotName(int inv_slot);
-		extern const char* GetInvSlotName(int inv_type, int inv_slot);
-
-	} /*invslot*/
-
-	namespace invbag {
-		const size_t ItemBagSize = 10;
-
-		const int GeneralBagsBegin = 262;
-		const int GeneralBagsSize = invslot::GeneralCount * ItemBagSize;
-		const int GeneralBagsEnd = (GeneralBagsBegin + GeneralBagsSize) - 1;
-
-		const int CursorBagBegin = 342;
-		const int CursorBagSize = ItemBagSize;
-		const int CursorBagEnd = (CursorBagBegin + CursorBagSize) - 1;
-
-		const int BankBagsBegin = 2032;
-		const int BankBagsSize = (invtype::InvTypeBankSize * ItemBagSize);
-		const int BankBagsEnd = (BankBagsBegin + BankBagsSize) - 1;
-
-		const int SharedBankBagsBegin = 2532;
-		const int SharedBankBagsSize = invtype::InvTypeSharedBankSize * ItemBagSize;
-		const int SharedBankBagsEnd = (SharedBankBagsBegin + SharedBankBagsSize) - 1;
-
-		const int TradeBagsBegin = 3031;
-		const int TradeBagsSize = invtype::InvTypeTradeSize * ItemBagSize;
-		const int TradeBagsEnd = (TradeBagsBegin + TradeBagsSize) - 1;
-
-		extern const char* GetInvBagIndexName(int bag_index);
-
-	} /*invbag*/
-
-	namespace invaug {
-		const size_t ItemAugSize = 5;
-
-		extern const char* GetInvAugIndexName(int aug_index);
-	
-	} /*invaug*/
-
-	namespace item {
-
-	} /*item*/
-
-	namespace profile {
-		const size_t TributeSize = invtype::InvTypeTributeSize;
-		const size_t GuildTributeSize = invtype::InvTypeGuildTributeSize;
-
-		const size_t BandoliersSize = 20;		// number of bandolier instances
-		const size_t BandolierItemCount = 4;	// number of equipment slots in bandolier instance
-
-		const size_t PotionBeltSize = 5;
-
-		const size_t SkillArraySize = 100;
-
-	} /*profile*/
-
-	namespace constants {
-		const size_t CharacterCreationLimit = 12;
-
-		const size_t SayLinkBodySize = 50;
+		const size_t SAY_LINK_BODY_SIZE = 50;
 
 		const int LongBuffs = 30;
 		const int ShortBuffs = 20;
@@ -307,11 +291,15 @@ namespace UF
 	} /*constants*/
 
 	namespace behavior {
+		inline EQEmu::versions::ClientVersion GetBehaviorRef() { return EQEmu::versions::ClientVersion::UF; }
+
 		const bool CoinHasWeight = false;
 
 	} /*behavior*/
 
 	namespace skills {
+		inline EQEmu::versions::ClientVersion GetSkillsRef() { return EQEmu::versions::ClientVersion::UF; }
+
 		const size_t LastUsableSkill = EQEmu::skills::SkillTripleAttack;
 
 	} /*skills*/

common/patches/uf_ops.h

@@ -72,7 +72,6 @@ E(OP_MoveItem)
 E(OP_NewSpawn)
 E(OP_NewZone)
 E(OP_OnLevelMessage)
-E(OP_OpenNewTasksWindow)
 E(OP_PetBuffWindow)
 E(OP_PlayerProfile)
 E(OP_RaidJoin)

common/patches/uf_structs.h

@@ -746,7 +746,7 @@ struct BandolierItem_Struct
 struct Bandolier_Struct
 {
 	char Name[32];
-	BandolierItem_Struct Items[profile::BandolierItemCount];
+	BandolierItem_Struct Items[profile::BANDOLIER_ITEM_COUNT];
 };
 
 //len = 72
@@ -760,7 +760,7 @@ struct PotionBeltItem_Struct
 //len = 288
 struct PotionBelt_Struct
 {
-	PotionBeltItem_Struct Items[profile::PotionBeltSize];
+	PotionBeltItem_Struct Items[profile::POTION_BELT_SIZE];
 };
 
 static const uint32 MAX_GROUP_LEADERSHIP_AA_ARRAY = 16;
@@ -969,7 +969,7 @@ struct PlayerProfile_Struct
 /*11236*/ uint32  aapoints_spent;		// Number of spent AA points
 /*11240*/ uint32  aapoints;				// Unspent AA points
 /*11244*/ uint8 unknown11244[4];
-/*11248*/ Bandolier_Struct bandoliers[profile::BandoliersSize]; // [6400] bandolier contents
+/*11248*/ Bandolier_Struct bandoliers[profile::BANDOLIERS_SIZE]; // [6400] bandolier contents
 /*17648*/ PotionBelt_Struct  potionbelt;	// [360] potion belt 72 extra octets by adding 1 more belt slot
 /*18008*/ uint8 unknown18008[8];
 /*18016*/ uint32 available_slots;

common/perl_eqdb.cpp

@@ -28,9 +28,9 @@
 typedef const char Const_char;
 
 #ifdef EMBPERL
-#include "../common/global_define.h"
-#include "../common/useperl.h"
+#include "global_define.h"
 #include "eqdb.h"
+#include "useperl.h"
 
 #ifdef THIS /* this macro seems to leak out on some systems */
 #undef THIS

common/perl_eqdb_res.cpp

@@ -28,9 +28,9 @@
 typedef const char Const_char;
 
 #ifdef EMBPERL
-#include "../common/global_define.h"
-#include "../common/useperl.h"
+#include "global_define.h"
 #include "eqdb_res.h"
+#include "useperl.h"
 
 
 XS(XS_EQDBRes_num_rows); /* prototype to pass -Wmissing-prototypes */

common/races.cpp

@@ -1349,102 +1349,99 @@ const char* GetPlayerRaceName(uint32 player_race_value)
 	return GetRaceIDName(GetRaceIDFromPlayerRaceValue(player_race_value));
 }
 
-uint32 GetPlayerRaceValue(uint16 race_id)
-{
+uint32 GetPlayerRaceValue(uint16 race_id) {
 	switch (race_id) {
-	case HUMAN:
-	case BARBARIAN:
-	case ERUDITE:
-	case WOOD_ELF:
-	case HIGH_ELF:
-	case DARK_ELF:
-	case HALF_ELF:
-	case DWARF:
-	case TROLL:
-	case OGRE:
-	case HALFLING:
-	case GNOME:
-		return race_id;
-	case IKSAR:
-		return PLAYER_RACE_IKSAR;
-	case VAHSHIR:
-		return PLAYER_RACE_VAHSHIR;
-	case FROGLOK:
-	case FROGLOK2:
-		return PLAYER_RACE_FROGLOK;
-	case DRAKKIN:
-		return PLAYER_RACE_DRAKKIN;
-	default:
-		return PLAYER_RACE_UNKNOWN; // watch
+		case HUMAN:
+		case BARBARIAN:
+		case ERUDITE:
+		case WOOD_ELF:
+		case HIGH_ELF:
+		case DARK_ELF:
+		case HALF_ELF:
+		case DWARF:
+		case TROLL:
+		case OGRE:
+		case HALFLING:
+		case GNOME:
+			return race_id;
+		case IKSAR:
+			return PLAYER_RACE_IKSAR;
+		case VAHSHIR:
+			return PLAYER_RACE_VAHSHIR;
+		case FROGLOK:
+		case FROGLOK2:
+			return PLAYER_RACE_FROGLOK;
+		case DRAKKIN:
+			return PLAYER_RACE_DRAKKIN;
+		default:
+			return PLAYER_RACE_UNKNOWN; // watch
 	}
 }
 
-uint32 GetPlayerRaceBit(uint16 race_id)
-{
+uint32 GetPlayerRaceBit(uint16 race_id) {
 	switch (race_id) {
-	case HUMAN:
-		return PLAYER_RACE_HUMAN_BIT;
-	case BARBARIAN:
-		return PLAYER_RACE_BARBARIAN_BIT;
-	case ERUDITE:
-		return PLAYER_RACE_ERUDITE_BIT;
-	case WOOD_ELF:
-		return PLAYER_RACE_WOOD_ELF_BIT;
-	case HIGH_ELF:
-		return PLAYER_RACE_HIGH_ELF_BIT;
-	case DARK_ELF:
-		return PLAYER_RACE_DARK_ELF_BIT;
-	case HALF_ELF:
-		return PLAYER_RACE_HALF_ELF_BIT;
-	case DWARF:
-		return PLAYER_RACE_DWARF_BIT;
-	case TROLL:
-		return PLAYER_RACE_TROLL_BIT;
-	case OGRE:
-		return PLAYER_RACE_OGRE_BIT;
-	case HALFLING:
-		return PLAYER_RACE_HALFLING_BIT;
-	case GNOME:
-		return PLAYER_RACE_GNOME_BIT;
-	case IKSAR:
-		return PLAYER_RACE_IKSAR_BIT;
-	case VAHSHIR:
-		return PLAYER_RACE_VAHSHIR_BIT;
-	case FROGLOK:
-		return PLAYER_RACE_FROGLOK_BIT;
-	case DRAKKIN:
-		return PLAYER_RACE_DRAKKIN_BIT;
-	default:
-		return PLAYER_RACE_UNKNOWN_BIT;
+		case HUMAN:
+			return PLAYER_RACE_HUMAN_BIT;
+		case BARBARIAN:
+			return PLAYER_RACE_BARBARIAN_BIT;
+		case ERUDITE:
+			return PLAYER_RACE_ERUDITE_BIT;
+		case WOOD_ELF:
+			return PLAYER_RACE_WOOD_ELF_BIT;
+		case HIGH_ELF:
+			return PLAYER_RACE_HIGH_ELF_BIT;
+		case DARK_ELF:
+			return PLAYER_RACE_DARK_ELF_BIT;
+		case HALF_ELF:
+			return PLAYER_RACE_HALF_ELF_BIT;
+		case DWARF:
+			return PLAYER_RACE_DWARF_BIT;
+		case TROLL:
+			return PLAYER_RACE_TROLL_BIT;
+		case OGRE:
+			return PLAYER_RACE_OGRE_BIT;
+		case HALFLING:
+			return PLAYER_RACE_HALFLING_BIT;
+		case GNOME:
+			return PLAYER_RACE_GNOME_BIT;
+		case IKSAR:
+			return PLAYER_RACE_IKSAR_BIT;
+		case VAHSHIR:
+			return PLAYER_RACE_VAHSHIR_BIT;
+		case FROGLOK:
+			return PLAYER_RACE_FROGLOK_BIT;
+		case DRAKKIN:
+			return PLAYER_RACE_DRAKKIN_BIT;
+		default:
+			return PLAYER_RACE_UNKNOWN_BIT;
 	}
 }
 
-uint16 GetRaceIDFromPlayerRaceValue(uint32 player_race_value)
-{
+uint16 GetRaceIDFromPlayerRaceValue(uint32 player_race_value) {
 	switch (player_race_value) {
-	case PLAYER_RACE_HUMAN:
-	case PLAYER_RACE_BARBARIAN:
-	case PLAYER_RACE_ERUDITE:
-	case PLAYER_RACE_WOOD_ELF:
-	case PLAYER_RACE_HIGH_ELF:
-	case PLAYER_RACE_DARK_ELF:
-	case PLAYER_RACE_HALF_ELF:
-	case PLAYER_RACE_DWARF:
-	case PLAYER_RACE_TROLL:
-	case PLAYER_RACE_OGRE:
-	case PLAYER_RACE_HALFLING:
-	case PLAYER_RACE_GNOME:
-		return player_race_value;
-	case PLAYER_RACE_IKSAR:
-		return IKSAR;
-	case PLAYER_RACE_VAHSHIR:
-		return VAHSHIR;
-	case PLAYER_RACE_FROGLOK:
-		return FROGLOK;
-	case PLAYER_RACE_DRAKKIN:
-		return DRAKKIN;
-	default:
-		return PLAYER_RACE_UNKNOWN; // watch
+		case PLAYER_RACE_HUMAN:
+		case PLAYER_RACE_BARBARIAN:
+		case PLAYER_RACE_ERUDITE:
+		case PLAYER_RACE_WOOD_ELF:
+		case PLAYER_RACE_HIGH_ELF:
+		case PLAYER_RACE_DARK_ELF:
+		case PLAYER_RACE_HALF_ELF:
+		case PLAYER_RACE_DWARF:
+		case PLAYER_RACE_TROLL:
+		case PLAYER_RACE_OGRE:
+		case PLAYER_RACE_HALFLING:
+		case PLAYER_RACE_GNOME:
+			return player_race_value;
+		case PLAYER_RACE_IKSAR:
+			return IKSAR;
+		case PLAYER_RACE_VAHSHIR:
+			return VAHSHIR;
+		case PLAYER_RACE_FROGLOK:
+			return FROGLOK;
+		case PLAYER_RACE_DRAKKIN:
+			return DRAKKIN;
+		default:
+			return PLAYER_RACE_UNKNOWN; // watch
 	}
 }
 
@@ -1488,6 +1485,122 @@ uint16 GetRaceIDFromPlayerRaceBit(uint32 player_race_bit)
 	}
 }
 
+float GetRaceGenderDefaultHeight(int race, int gender)
+{
+	static float male_height[] = {
+	    6.0f,  6.0f,  7.0f,   6.0f,   5.0f,  6.0f,  5.0f,   5.5f,  4.0f,  8.0f,  9.0f,  3.5f,  3.0f,  6.0f,   6.0f,
+	    2.0f,  8.5f,  8.0f,   21.0f,  20.0f, 6.0f,  6.0f,   3.5f,  3.0f,  6.0f,  2.0f,  5.0f,  5.0f,  6.0f,   6.0f,
+	    6.0f,  7.5f,  6.0f,   6.0f,   6.0f,  6.0f,  6.0f,   6.0f,  5.0f,  6.0f,  6.0f,  7.0f,  4.0f,  4.7f,   6.0f,
+	    8.0f,  3.0f,  12.0f,  5.0f,   21.0f, 6.0f,  6.0f,   3.0f,  9.0f,  6.0f,  6.0f,  2.0f,  6.0f,  3.0f,   6.0f,
+	    4.0f,  20.0f, 5.0f,   5.0f,   6.0f,  9.0f,  25.0f,  6.0f,  6.0f,  10.0f, 6.0f,  6.0f,  6.0f,  6.0f,   2.5f,
+	    7.0f,  6.0f,  5.0f,   6.0f,   1.5f,  1.0f,  3.5f,   7.0f,  6.0f,  6.0f,  6.0f,  6.0f,  7.0f,  3.0f,   3.0f,
+	    7.0f,  12.0f, 8.0f,   9.0f,   4.0f,  11.5f, 8.0f,   6.0f,  6.0f,  12.0f, 6.0f,  6.0f,  6.0f,  20.0f,  10.0f,
+	    6.5f,  6.0f,  17.0f,  1.0f,   4.0f,  6.0f,  8.0f,   5.0f,  1.0f,  6.0f,  6.0f,  5.0f,  5.0f,  5.0f,   9.0f,
+	    3.0f,  8.0f,  2.0f,   24.0f,  6.0f,  10.0f, 6.0f,   6.0f,  6.0f,  3.0f,  7.0f,  9.0f,  6.0f,  11.0f,  2.5f,
+	    14.0f, 8.0f,  7.0f,   12.0f,  6.0f,  27.0f, 6.0f,   6.0f,  6.0f,  6.0f,  2.0f,  9.0f,  9.0f,  6.0f,   9.0f,
+	    3.0f,  3.0f,  6.0f,   6.0f,   10.0f, 6.0f,  6.0f,   15.0f, 15.0f, 9.0f,  7.0f,  6.0f,  6.0f,  7.0f,   8.0f,
+	    3.0f,  3.0f,  6.0f,   7.0f,   13.0f, 6.0f,  6.0f,   9.0f,  5.0f,  7.0f,  9.0f,  6.0f,  6.0f,  8.0f,   6.0f,
+	    6.0f,  5.5f,  6.0f,   4.0f,   25.0f, 6.0f,  6.0f,   6.0f,  22.0f, 20.0f, 6.0f,  10.0f, 13.5f, 12.0f,  3.0f,
+	    30.0f, 6.0f,  6.0f,   35.0f,  1.5f,  8.0f,  3.0f,   6.0f,  2.0f,  6.0f,  6.0f,  5.0f,  2.0f,  7.0f,   6.0f,
+	    6.0f,  6.0f,  6.0f,   4.0f,   6.0f,  6.0f,  6.0f,   8.0f,  8.0f,  7.0f,  8.0f,  6.0f,  7.0f,  6.0f,   7.0f,
+	    6.0f,  10.0f, 3.0f,   6.0f,   8.0f,  9.0f,  15.0f,  5.0f,  10.0f, 7.0f,  6.0f,  7.0f,  6.0f,  7.0f,   7.0f,
+	    12.0f, 6.0f,  4.0f,   6.0f,   5.0f,  3.0f,  30.0f,  30.0f, 15.0f, 20.0f, 6.0f,  10.0f, 6.0f,  14.0f,  14.0f,
+	    16.0f, 15.0f, 30.0f,  15.0f,  7.5f,  5.0f,  4.0f,   6.0f,  15.0f, 6.5f,  3.0f,  12.0f, 10.0f, 10.5f,  10.0f,
+	    7.5f,  6.0f,  6.0f,   12.5f,  9.0f,  20.0f, 2.0f,   10.0f, 25.0f, 8.0f,  6.0f,  6.0f,  10.0f, 18.0f,  45.0f,
+	    13.0f, 15.0f, 8.0f,   30.0f,  25.0f, 25.0f, 10.0f,  13.0f, 5.0f,  3.5f,  15.0f, 35.0f, 11.0f, 15.0f,  50.0f,
+	    13.0f, 6.0f,  7.0f,   6.0f,   60.0f, 6.0f,  22.0f,  22.0f, 21.0f, 22.0f, 15.0f, 25.0f, 23.0f, 8.0f,   15.0f,
+	    10.0f, 6.0f,  7.0f,   6.0f,   12.0f, 9.5f,  6.0f,   12.0f, 12.0f, 12.0f, 15.0f, 4.0f,  5.0f,  105.0f, 20.0f,
+	    5.0f,  10.0f, 10.0f,  10.0f,  20.0f, 13.5f, 8.0f,   10.0f, 3.0f,  5.0f,  9.0f,  6.0f,  6.0f,  6.0f,   10.0f,
+	    8.0f,  8.0f,  8.0f,   6.0f,   6.0f,  5.0f,  5.0f,   5.0f,  9.0f,  9.0f,  9.0f,  6.0f,  8.5f,  6.0f,   7.0f,
+	    8.0f,  7.0f,  11.0f,  6.0f,   7.0f,  9.0f,  8.0f,   6.0f,  8.0f,  6.0f,  6.0f,  6.0f,  6.0f,  9.0f,   10.0f,
+	    6.0f,  3.0f,  4.0f,   3.0f,   3.0f,  4.0f,  10.0f,  10.0f, 2.0f,  8.0f,  6.0f,  6.0f,  14.0f, 7.0f,   5.0f,
+	    9.0f,  7.0f,  7.0f,   10.0f,  10.0f, 12.0f, 9.0f,   7.0f,  12.0f, 13.0f, 16.0f, 6.0f,  9.0f,  6.0f,   6.0f,
+	    10.0f, 25.0f, 15.0f,  6.0f,   25.0f, 6.0f,  6.0f,   8.0f,  11.0f, 6.0f,  9.0f,  2.0f,  6.0f,  5.0f,   4.0f,
+	    8.5f,  6.0f,  6.0f,   6.0f,   4.0f,  6.0f,  15.0f,  1.0f,  2.0f,  6.0f,  40.0f, 8.0f,  12.0f, 3.0f,   8.0f,
+	    99.0f, 9.0f,  100.0f, 100.0f, 10.0f, 6.0f,  27.5f,  20.0f, 6.0f,  6.0f,  5.0f,  6.0f,  8.0f,  5.0f,   3.0f,
+	    11.5f, 25.0f, 80.0f,  20.0f,  9.0f,  8.0f,  5.0f,   4.0f,  7.0f,  10.0f, 6.0f,  11.0f, 8.0f,  5.0f,   6.0f,
+	    6.0f,  30.0f, 7.0f,   15.0f,  9.0f,  6.0f,  9.0f,   6.0f,  3.0f,  32.5f, 15.0f, 7.5f,  10.0f, 10.0f,  6.0f,
+	    6.0f,  6.0f,  6.0f,   6.0f,   6.0f,  9.0f,  20.0f,  6.0f,  6.0f,  6.0f,  25.0f, 12.0f, 6.0f,  8.0f,   6.0f,
+	    6.0f,  20.0f, 10.0f,  8.0f,   12.0f, 8.0f,  2.0f,   6.0f,  3.0f,  6.0f,  7.0f,  1.5f,  6.0f,  3.0f,   3.0f,
+	    3.0f,  3.0f,  2.0f,   3.0f,   3.0f,  6.0f,  6.0f,   6.0f,  4.5f,  7.0f,  6.0f,  7.0f,  6.0f,  22.0f,  8.0f,
+	    15.0f, 22.0f, 8.0f,   15.0f,  6.0f,  80.0f, 150.0f, 7.0f,  6.0f,  6.0f,  6.0f,  12.0f, 6.0f,  6.0f,   6.0f,
+	    6.0f,  6.0f,  6.0f,   6.0f,   6.0f,  6.0f,  6.0f,   35.0f, 20.0f, 9.0f,  6.0f,  6.0f,  6.0f,  20.0f,  20.0f,
+	    20.0f, 20.0f, 20.0f,  9.0f,   4.0f,  4.0f,  10.0f,  5.0f,  8.0f,  6.0f,  10.0f, 6.0f,  6.0f,  2.0f,   36.0f,
+	    14.0f, 7.0f,  250.0f, 6.0f,   9.0f,  6.0f,  7.0f,   4.0f,  6.0f,  8.0f,  6.0f,  23.0f, 6.0f,  6.0f,   6.0f,
+	    70.0f, 6.0f,  7.0f,   6.0f,   6.0f,  6.0f,  20.0f,  6.0f,  6.0f,  6.0f,  5.0f,  1.0f,  6.0f,  6.0f,   6.0f,
+	    6.0f,  6.0f,  6.0f,   6.0f,   6.0f,  6.0f,  6.0f,   6.0f,  6.0f,  6.0f,  6.0f,  6.0f,  6.0f,  6.0f,   6.0f,
+	    6.0f,  6.0f,  6.0f,   6.0f,   6.0f,  6.0f,  6.0f,   6.0f,  6.0f,  6.0f,  6.0f,  6.0f,  6.0f,  6.0f,   6.0f,
+	    6.0f,  6.0f,  6.0f,   6.0f,   6.0f,  6.0f,  6.0f,   6.0f,  6.0f,  6.0f,  6.0f,  6.0f,  6.0f,  6.0f,   6.0f,
+	    4.0f,  4.0f,  6.0f,   6.0f,   6.0f,  6.0f,  6.0f,   6.0f,  6.0f,  6.0f,  6.0f,  10.0f, 6.0f,  6.0f,   6.0f,
+	    6.0f,  6.0f,  6.0f,   6.0f,   6.0f,  6.0f,  6.0f,   6.0f,  6.0f,  6.0f,  6.0f,  6.0f,  6.0f,  6.0f,   6.0f,
+	    6.0f,  6.0f,  6.0f,   6.0f,   6.0f,  6.0f,  6.0f,   6.0f,  6.0f,  6.0f,  6.0f,  6.0f,  6.0f,  6.0f,   6.0f,
+	    6.0f,  6.0f,  6.0f,   6.0f,   6.0f,  7.0f,  7.0f,   7.0f,  7.0f,  6.0f,  6.0f,  6.0f,  6.0f,  6.0f,   8.0f,
+	    6.0f,  6.0f,  6.0f,   7.0f,   6.0f,  6.0f,  6.0f,   7.5f,  6.0f,  6.0f,  4.0f,  6.0f,  3.0f,  6.0f,   6.0f,
+	    1.0f,  9.0f,  7.0f,   8.0f,   7.0f,  8.0f,  6.0f,   6.0f,  6.0f,  6.0f,  6.0f,  8.0f,
+	};
+
+	static float female_height[] = {
+	    6.0f,  6.0f,  7.0f,   6.0f,   5.0f,  6.0f,  5.0f,   5.5f,  4.0f,  8.0f,  9.0f,  3.5f,  3.0f,  6.0f,   6.0f,
+	    2.0f,  8.5f,  8.0f,   21.0f,  20.0f, 6.0f,  6.0f,   3.5f,  3.0f,  6.0f,  2.0f,  5.0f,  5.0f,  6.0f,   6.0f,
+	    6.0f,  7.5f,  6.0f,   6.0f,   6.0f,  6.0f,  6.0f,   6.0f,  5.0f,  6.0f,  6.0f,  7.0f,  4.0f,  4.7f,   6.0f,
+	    8.0f,  3.0f,  12.0f,  5.0f,   21.0f, 6.0f,  6.0f,   3.0f,  9.0f,  6.0f,  6.0f,  2.0f,  6.0f,  3.0f,   6.0f,
+	    4.0f,  20.0f, 5.0f,   5.0f,   6.0f,  9.0f,  25.0f,  6.0f,  6.0f,  10.0f, 6.0f,  6.0f,  6.0f,  6.0f,   2.5f,
+	    7.0f,  6.0f,  5.0f,   6.0f,   1.5f,  1.0f,  3.5f,   7.0f,  6.0f,  6.0f,  6.0f,  6.0f,  7.0f,  3.0f,   3.0f,
+	    7.0f,  12.0f, 8.0f,   9.0f,   4.0f,  11.5f, 8.0f,   6.0f,  6.0f,  12.0f, 6.0f,  6.0f,  6.0f,  20.0f,  10.0f,
+	    6.5f,  6.0f,  17.0f,  1.0f,   4.0f,  6.0f,  8.0f,   5.0f,  1.0f,  6.0f,  6.0f,  5.0f,  5.0f,  5.0f,   9.0f,
+	    3.0f,  8.0f,  2.0f,   24.0f,  6.0f,  10.0f, 6.0f,   6.0f,  6.0f,  3.0f,  7.0f,  9.0f,  6.0f,  11.0f,  2.5f,
+	    14.0f, 8.0f,  7.0f,   12.0f,  6.0f,  27.0f, 6.0f,   6.0f,  6.0f,  6.0f,  2.0f,  9.0f,  9.0f,  6.0f,   9.0f,
+	    3.0f,  3.0f,  6.0f,   6.0f,   10.0f, 6.0f,  6.0f,   15.0f, 15.0f, 9.0f,  7.0f,  6.0f,  6.0f,  7.0f,   8.0f,
+	    3.0f,  3.0f,  6.0f,   7.0f,   13.0f, 6.0f,  6.0f,   9.0f,  5.0f,  7.0f,  9.0f,  6.0f,  6.0f,  8.0f,   6.0f,
+	    6.0f,  5.5f,  6.0f,   4.0f,   25.0f, 6.0f,  6.0f,   6.0f,  22.0f, 20.0f, 6.0f,  10.0f, 13.5f, 12.0f,  3.0f,
+	    30.0f, 6.0f,  6.0f,   35.0f,  1.5f,  8.0f,  3.0f,   6.0f,  2.0f,  6.0f,  6.0f,  5.0f,  2.0f,  7.0f,   6.0f,
+	    6.0f,  6.0f,  6.0f,   4.0f,   6.0f,  6.0f,  6.0f,   8.0f,  8.0f,  7.0f,  8.0f,  6.0f,  7.0f,  6.0f,   7.0f,
+	    6.0f,  10.0f, 3.0f,   6.0f,   8.0f,  9.0f,  15.0f,  5.0f,  10.0f, 7.0f,  6.0f,  7.0f,  6.0f,  7.0f,   7.0f,
+	    12.0f, 6.0f,  4.0f,   6.0f,   5.0f,  3.0f,  30.0f,  30.0f, 15.0f, 20.0f, 6.0f,  10.0f, 6.0f,  14.0f,  14.0f,
+	    16.0f, 15.0f, 30.0f,  15.0f,  7.5f,  5.0f,  4.0f,   6.0f,  15.0f, 6.5f,  3.0f,  12.0f, 10.0f, 10.5f,  10.0f,
+	    7.5f,  6.0f,  6.0f,   12.5f,  9.0f,  20.0f, 2.0f,   10.0f, 25.0f, 8.0f,  6.0f,  6.0f,  10.0f, 18.0f,  45.0f,
+	    13.0f, 15.0f, 8.0f,   30.0f,  25.0f, 25.0f, 10.0f,  13.0f, 5.0f,  3.5f,  15.0f, 35.0f, 11.0f, 15.0f,  50.0f,
+	    13.0f, 6.0f,  7.0f,   6.0f,   60.0f, 6.0f,  22.0f,  22.0f, 21.0f, 22.0f, 15.0f, 25.0f, 23.0f, 8.0f,   15.0f,
+	    10.0f, 6.0f,  7.0f,   6.0f,   12.0f, 9.5f,  6.0f,   12.0f, 12.0f, 12.0f, 15.0f, 4.0f,  5.0f,  105.0f, 20.0f,
+	    5.0f,  10.0f, 10.0f,  10.0f,  20.0f, 13.5f, 8.0f,   10.0f, 3.0f,  5.0f,  9.0f,  6.0f,  6.0f,  6.0f,   10.0f,
+	    8.0f,  8.0f,  8.0f,   6.0f,   6.0f,  5.0f,  5.0f,   5.0f,  9.0f,  9.0f,  9.0f,  6.0f,  8.5f,  6.0f,   7.0f,
+	    8.0f,  7.0f,  11.0f,  6.0f,   7.0f,  9.0f,  8.0f,   6.0f,  8.0f,  6.0f,  6.0f,  6.0f,  6.0f,  9.0f,   10.0f,
+	    6.0f,  3.0f,  4.0f,   3.0f,   3.0f,  4.0f,  10.0f,  10.0f, 2.0f,  8.0f,  6.0f,  6.0f,  14.0f, 7.0f,   5.0f,
+	    9.0f,  7.0f,  7.0f,   10.0f,  10.0f, 12.0f, 9.0f,   7.0f,  12.0f, 13.0f, 16.0f, 6.0f,  9.0f,  6.0f,   6.0f,
+	    10.0f, 25.0f, 15.0f,  6.0f,   25.0f, 6.0f,  6.0f,   8.0f,  11.0f, 6.0f,  9.0f,  2.0f,  6.0f,  5.0f,   4.0f,
+	    8.5f,  6.0f,  6.0f,   6.0f,   4.0f,  6.0f,  15.0f,  1.0f,  2.0f,  6.0f,  40.0f, 8.0f,  12.0f, 3.0f,   8.0f,
+	    99.0f, 9.0f,  100.0f, 100.0f, 10.0f, 6.0f,  27.5f,  20.0f, 6.0f,  6.0f,  5.0f,  6.0f,  8.0f,  5.0f,   3.0f,
+	    11.5f, 25.0f, 80.0f,  20.0f,  9.0f,  8.0f,  5.0f,   4.0f,  7.0f,  10.0f, 6.0f,  11.0f, 8.0f,  5.0f,   6.0f,
+	    6.0f,  30.0f, 7.0f,   15.0f,  9.0f,  6.0f,  9.0f,   6.0f,  3.0f,  32.5f, 15.0f, 7.5f,  10.0f, 10.0f,  6.0f,
+	    6.0f,  6.0f,  6.0f,   6.0f,   6.0f,  9.0f,  20.0f,  6.0f,  6.0f,  6.0f,  25.0f, 12.0f, 6.0f,  8.0f,   6.0f,
+	    6.0f,  20.0f, 9.0f,   8.0f,   12.0f, 8.0f,  2.0f,   6.0f,  3.0f,  6.0f,  7.0f,  1.5f,  6.0f,  3.0f,   3.0f,
+	    3.0f,  3.0f,  2.0f,   3.0f,   3.0f,  6.0f,  6.0f,   6.0f,  4.5f,  7.0f,  6.0f,  7.0f,  5.7f,  22.0f,  8.0f,
+	    15.0f, 22.0f, 8.0f,   15.0f,  6.0f,  80.0f, 150.0f, 7.0f,  6.0f,  6.0f,  6.0f,  12.0f, 6.0f,  6.0f,   6.0f,
+	    6.0f,  6.0f,  6.0f,   6.0f,   6.0f,  6.0f,  6.0f,   35.0f, 20.0f, 9.0f,  6.0f,  6.0f,  6.0f,  20.0f,  20.0f,
+	    20.0f, 20.0f, 20.0f,  9.0f,   4.0f,  4.0f,  10.0f,  5.0f,  8.0f,  6.0f,  10.0f, 5.7f,  6.0f,  2.0f,   36.0f,
+	    14.0f, 7.0f,  250.0f, 6.0f,   9.0f,  6.0f,  7.0f,   4.0f,  6.0f,  8.0f,  6.0f,  23.0f, 6.0f,  6.0f,   6.0f,
+	    70.0f, 6.0f,  7.0f,   6.0f,   6.0f,  6.0f,  20.0f,  6.0f,  6.0f,  6.0f,  5.0f,  1.0f,  6.0f,  6.0f,   6.0f,
+	    6.0f,  6.0f,  6.0f,   6.0f,   6.0f,  6.0f,  6.0f,   6.0f,  6.0f,  6.0f,  6.0f,  6.0f,  6.0f,  6.0f,   6.0f,
+	    6.0f,  6.0f,  6.0f,   6.0f,   6.0f,  6.0f,  6.0f,   6.0f,  6.0f,  6.0f,  6.0f,  6.0f,  6.0f,  6.0f,   6.0f,
+	    6.0f,  6.0f,  6.0f,   6.0f,   6.0f,  6.0f,  6.0f,   6.0f,  6.0f,  6.0f,  6.0f,  6.0f,  6.0f,  6.0f,   6.0f,
+	    4.0f,  4.0f,  6.0f,   6.0f,   6.0f,  6.0f,  6.0f,   6.0f,  6.0f,  6.0f,  6.0f,  10.0f, 6.0f,  6.0f,   6.0f,
+	    6.0f,  6.0f,  6.0f,   6.0f,   6.0f,  6.0f,  6.0f,   6.0f,  6.0f,  6.0f,  6.0f,  6.0f,  6.0f,  6.0f,   6.0f,
+	    6.0f,  6.0f,  6.0f,   6.0f,   6.0f,  6.0f,  6.0f,   6.0f,  6.0f,  6.0f,  6.0f,  6.0f,  6.0f,  6.0f,   6.0f,
+	    6.0f,  6.0f,  6.0f,   6.0f,   6.0f,  7.0f,  7.0f,   7.0f,  7.0f,  6.0f,  6.0f,  6.0f,  6.0f,  6.0f,   8.0f,
+	    6.0f,  6.0f,  6.0f,   7.0f,   6.0f,  6.0f,  6.0f,   7.5f,  6.0f,  6.0f,  4.0f,  6.0f,  3.0f,  6.0f,   6.0f,
+	    1.0f,  9.0f,  7.0f,   8.0f,   7.0f,  8.0f,  6.0f,   6.0f,  6.0f,  6.0f,  6.0f,  8.0f,
+	};
+
+	const auto size = sizeof(male_height) / sizeof(male_height[0]);
+
+	if (race >= size)
+		return 6.0f;
+
+	if (gender == 1)
+		return female_height[race];
+
+	return male_height[race];
+}
 
 // PlayerAppearance prep
 #define HUMAN_MALE ((HUMAN << 8) | MALE)

common/rulesys.cpp

@@ -236,46 +236,51 @@ void RuleManager::SaveRules(Database *database, const char *ruleset_name) {
 }
 
 bool RuleManager::LoadRules(Database *database, const char *ruleset_name) {
-	
-	int ruleset_id = GetRulesetID(database, ruleset_name);
+
+	int ruleset_id = this->GetRulesetID(database, ruleset_name);
 	if (ruleset_id < 0) {
 		Log(Logs::Detail, Logs::Rules, "Failed to find ruleset '%s' for load operation. Canceling.", ruleset_name);
-		return(false);
+		return (false);
 	}
 
 	Log(Logs::Detail, Logs::Rules, "Loading rule set '%s' (%d)", ruleset_name, ruleset_id);
 
 	m_activeRuleset = ruleset_id;
-	m_activeName = ruleset_name;
+	m_activeName    = ruleset_name;
 
 	/* Load default ruleset values first if we're loading something other than default */
-	if (strcasecmp(ruleset_name, "default") != 0){
+	if (strcasecmp(ruleset_name, "default") != 0) {
 		std::string default_ruleset_name = "default";
-		int default_ruleset_id = GetRulesetID(database, default_ruleset_name.c_str());
+		int         default_ruleset_id   = GetRulesetID(database, default_ruleset_name.c_str());
 		if (default_ruleset_id < 0) {
-			Log(Logs::Detail, Logs::Rules, "Failed to find default ruleset '%s' for load operation. Canceling.", default_ruleset_name.c_str());
-			return(false);
+			Log(Logs::Detail, Logs::Rules, "Failed to find default ruleset '%s' for load operation. Canceling.",
+			    default_ruleset_name.c_str());
+			return (false);
 		}
 		Log(Logs::Detail, Logs::Rules, "Loading rule set '%s' (%d)", default_ruleset_name.c_str(), default_ruleset_id);
 
-		std::string query = StringFormat("SELECT rule_name, rule_value FROM rule_values WHERE ruleset_id = %d", default_ruleset_id);
+		std::string query = StringFormat(
+				"SELECT rule_name, rule_value FROM rule_values WHERE ruleset_id = %d",
+				default_ruleset_id
+		);
+
 		auto results = database->QueryDatabase(query);
 		if (!results.Success())
 			return false;
 
 		for (auto row = results.begin(); row != results.end(); ++row)
-		if (!SetRule(row[0], row[1], nullptr, false))
-			Log(Logs::Detail, Logs::Rules, "Unable to interpret rule record for %s", row[0]);
+			if (!SetRule(row[0], row[1], nullptr, false))
+				Log(Logs::Detail, Logs::Rules, "Unable to interpret rule record for %s", row[0]);
 	}
 
-	std::string query = StringFormat("SELECT rule_name, rule_value FROM rule_values WHERE ruleset_id=%d", ruleset_id);
-	auto results = database->QueryDatabase(query);
+	std::string query   = StringFormat("SELECT rule_name, rule_value FROM rule_values WHERE ruleset_id=%d", ruleset_id);
+	auto        results = database->QueryDatabase(query);
 	if (!results.Success())
 		return false;
 
 	for (auto row = results.begin(); row != results.end(); ++row)
-	if (!SetRule(row[0], row[1], nullptr, false))
-		Log(Logs::Detail, Logs::Rules, "Unable to interpret rule record for %s", row[0]);
+		if (!SetRule(row[0], row[1], nullptr, false))
+			Log(Logs::Detail, Logs::Rules, "Unable to interpret rule record for %s", row[0]);
 
 	return true;
 }
@@ -283,7 +288,7 @@ bool RuleManager::LoadRules(Database *database, const char *ruleset_name) {
 void RuleManager::_SaveRule(Database *database, RuleType type, uint16 index) {
 	char value_string[100];
 
-	switch(type) {
+	switch (type) {
 		case IntRule:
 			sprintf(value_string, "%d", m_RuleIntValues[index]);
 			break;
@@ -291,22 +296,26 @@ void RuleManager::_SaveRule(Database *database, RuleType type, uint16 index) {
 			sprintf(value_string, "%.13f", m_RuleRealValues[index]);
 			break;
 		case BoolRule:
-			sprintf(value_string, "%s", m_RuleBoolValues[index]?"true":"false");
+			sprintf(value_string, "%s", m_RuleBoolValues[index] ? "true" : "false");
 			break;
 	}
 
-	std::string query = StringFormat("REPLACE INTO rule_values "
-                                    "(ruleset_id, rule_name, rule_value) "
-                                    " VALUES(%d, '%s', '%s')",
-                                    m_activeRuleset, _GetRuleName(type, index), value_string);
-    auto results = database->QueryDatabase(query);
+	std::string query = StringFormat(
+			"REPLACE INTO rule_values "
+			"(ruleset_id, rule_name, rule_value) "
+			" VALUES(%d, '%s', '%s')",
+			m_activeRuleset,
+			_GetRuleName(type, index),
+			value_string
+	);
 
+	database->QueryDatabase(query);
 }
 
 
 int RuleManager::GetRulesetID(Database *database, const char *ruleset_name) {
 
-	uint32 len = strlen(ruleset_name);
+	uint32 len = static_cast<uint32>(strlen(ruleset_name));
 	auto rst = new char[2 * len + 1];
 	database->DoEscapeString(rst, ruleset_name, len);
 

common/ruletypes.h

@@ -156,7 +156,9 @@ RULE_BOOL(Character, UseOldBindWound, false) // Uses the original bind wound beh
 RULE_BOOL(Character, GrantHoTTOnCreate, false) // Grant Health of Target's Target leadership AA on character creation
 RULE_BOOL(Character, UseOldConSystem, false) // Grant Health of Target's Target leadership AA on character creation
 RULE_BOOL(Character, OPClientUpdateVisualDebug, false) // Shows a pulse and forward directional particle each time the client sends its position to server
+RULE_BOOL(Character, AllowCrossClassTrainers, false)
 RULE_BOOL(Character, PetsUseReagents, true) //Pets use reagent on spells
+RULE_BOOL(Character, DismountWater, true) // Dismount horses when entering water
 RULE_CATEGORY_END()
 
 RULE_CATEGORY(Mercs)
@@ -513,7 +515,8 @@ RULE_INT(NPC, MinorNPCCorpseDecayTimeMS, 450000) //level<55
 RULE_INT(NPC, MajorNPCCorpseDecayTimeMS, 1500000) //level>=55
 RULE_INT(NPC, CorpseUnlockTimer, 150000)
 RULE_INT(NPC, EmptyNPCCorpseDecayTimeMS, 0)
-RULE_BOOL (NPC, UseItemBonusesForNonPets, true)
+RULE_BOOL(NPC, UseItemBonusesForNonPets, true)
+RULE_BOOL(NPC, UseBaneDamage, false)
 RULE_INT(NPC, SayPauseTimeInSec, 5)
 RULE_INT(NPC, OOCRegen, 0)
 RULE_BOOL(NPC, BuffFriends, false)
@@ -546,6 +549,8 @@ RULE_INT(Aggro, IntAggroThreshold, 75) // Int <= this will aggro regardless of l
 RULE_BOOL(Aggro, AllowTickPulling, false) // tick pulling is an exploit in an NPC's call for help fixed sometime in 2006 on live
 RULE_BOOL(Aggro, UseLevelAggro, true) // Level 18+ and Undead will aggro regardless of level difference. (this will disabled Rule:IntAggroThreshold if set to true)
 RULE_INT(Aggro, ClientAggroCheckInterval, 6) // Interval in which clients actually check for aggro - in seconds
+RULE_REAL(Aggro, PetAttackRange, 40000.0) // max squared range /pet attack works at default is 200
+RULE_BOOL(Aggro, NPCAggroMaxDistanceEnabled, true) /* If enabled, NPC's will drop aggro beyond 600 units or what is defined at the zone level */
 RULE_CATEGORY_END()
 
 RULE_CATEGORY(TaskSystem)
@@ -597,6 +602,9 @@ RULE_BOOL(Bots, BotLevelsWithOwner, false) // Auto-updates spawned bots as owner
 RULE_BOOL(Bots, BotCharacterLevelEnabled, false) // Enables required level to spawn bots
 RULE_INT(Bots, BotCharacterLevel, 0) // 0 as default (if level > this value you can spawn bots if BotCharacterLevelEnabled is true)
 RULE_INT(Bots, CasterStopMeleeLevel, 13) // Level at which caster bots stop melee attacks
+RULE_INT(Bots, AllowedClasses, 0xFFFFFFFF) // Bitmask of allowed bot classes
+RULE_INT(Bots, AllowedRaces, 0xFFFFFFFF) // Bitmask of allowed bot races
+RULE_INT(Bots, AllowedGenders, 0x3) // Bitmask of allowed bot genders
 RULE_CATEGORY_END()
 #endif
 

common/say_link.cpp

@@ -29,7 +29,7 @@
 bool EQEmu::saylink::DegenerateLinkBody(SayLinkBody_Struct& say_link_body_struct, const std::string& say_link_body)
 {
 	memset(&say_link_body_struct, 0, sizeof(say_link_body_struct));
-	if (say_link_body.length() != EQEmu::constants::SayLinkBodySize)
+	if (say_link_body.length() != EQEmu::constants::SAY_LINK_BODY_SIZE)
 		return false;
 
 	say_link_body_struct.action_id = (uint8)strtol(say_link_body.substr(0, 1).c_str(), nullptr, 16);
@@ -68,7 +68,7 @@ bool EQEmu::saylink::GenerateLinkBody(std::string& say_link_body, const SayLinkB
 		(0xFFFFFFFF & say_link_body_struct.hash)
 	);
 
-	if (say_link_body.length() != EQEmu::constants::SayLinkBodySize)
+	if (say_link_body.length() != EQEmu::constants::SAY_LINK_BODY_SIZE)
 		return false;
 
 	return true;
@@ -88,25 +88,25 @@ const std::string& EQEmu::SayLinkEngine::GenerateLink()
 	generate_body();
 	generate_text();
 
-	if ((m_LinkBody.length() == EQEmu::constants::SayLinkBodySize) && (m_LinkText.length() > 0)) {
+	if ((m_LinkBody.length() == EQEmu::constants::SAY_LINK_BODY_SIZE) && (m_LinkText.length() > 0)) {
 		m_Link.push_back(0x12);
 		m_Link.append(m_LinkBody);
 		m_Link.append(m_LinkText);
 		m_Link.push_back(0x12);
 	}
 
-	if ((m_Link.length() == 0) || (m_Link.length() > (EQEmu::constants::SayLinkMaximumSize))) {
+	if ((m_Link.length() == 0) || (m_Link.length() > (EQEmu::constants::SAY_LINK_MAXIMUM_SIZE))) {
 		m_Error = true;
 		m_Link = "<LINKER ERROR>";
 		Log(Logs::General, Logs::Error, "SayLinkEngine::GenerateLink() failed to generate a useable say link");
 		Log(Logs::General, Logs::Error, ">> LinkType: %i, Lengths: {link: %u(%u), body: %u(%u), text: %u(%u)}",
 			m_LinkType,
 			m_Link.length(),
-			EQEmu::constants::SayLinkMaximumSize,
+			EQEmu::constants::SAY_LINK_MAXIMUM_SIZE,
 			m_LinkBody.length(),
-			EQEmu::constants::SayLinkBodySize,
+			EQEmu::constants::SAY_LINK_BODY_SIZE,
 			m_LinkText.length(),
-			EQEmu::constants::SayLinkTextSize
+			EQEmu::constants::SAY_LINK_TEXT_SIZE
 		);
 		Log(Logs::General, Logs::Error, ">> LinkBody: %s", m_LinkBody.c_str());
 		Log(Logs::General, Logs::Error, ">> LinkText: %s", m_LinkText.c_str());

common/serialize_buffer.cpp

@@ -0,0 +1,23 @@
+#include "serialize_buffer.h"
+
+void SerializeBuffer::Grow(size_t new_size)
+{
+	assert(new_size > m_capacity);
+	auto new_buffer = new unsigned char[new_size * 2];
+	memset(new_buffer, 0, new_size * 2);
+
+	if (m_buffer)
+		memcpy(new_buffer, m_buffer, m_capacity);
+	m_capacity = new_size * 2;
+	delete[] m_buffer;
+	m_buffer = new_buffer;
+}
+
+void SerializeBuffer::Reset()
+{
+	delete[] m_buffer;
+	m_buffer = nullptr;
+	m_capacity = 0;
+	m_pos = 0;
+}
+

common/serialize_buffer.h

@@ -0,0 +1,199 @@
+#ifndef SERIALIZE_BUFFER_H
+#define SERIALIZE_BUFFER_H
+
+#include <cstring>
+#include <cassert>
+#include <cstdint>
+#include <string>
+
+class SerializeBuffer
+{
+public:
+	SerializeBuffer() : m_buffer(nullptr), m_capacity(0), m_pos(0) {}
+
+	explicit SerializeBuffer(size_t size) : m_capacity(size), m_pos(0)
+	{
+		m_buffer = new unsigned char[size];
+		memset(m_buffer, 0, size);
+	}
+
+	SerializeBuffer(const SerializeBuffer &rhs)
+	    : m_buffer(new unsigned char[rhs.m_capacity]), m_capacity(rhs.m_capacity), m_pos(rhs.m_pos)
+	{
+		memcpy(m_buffer, rhs.m_buffer, rhs.m_capacity);
+	}
+
+	SerializeBuffer &operator=(const SerializeBuffer &rhs)
+	{
+		if (this != &rhs) {
+			delete[] m_buffer;
+			m_buffer = new unsigned char[rhs.m_capacity];
+			m_capacity = rhs.m_capacity;
+			m_pos = rhs.m_pos;
+			memcpy(m_buffer, rhs.m_buffer, m_capacity);
+		}
+		return *this;
+	}
+
+	SerializeBuffer(SerializeBuffer &&rhs) : m_buffer(rhs.m_buffer), m_capacity(rhs.m_capacity), m_pos(rhs.m_pos)
+	{
+		rhs.m_buffer = nullptr;
+		rhs.m_capacity = 0;
+		rhs.m_pos = 0;
+	}
+
+	SerializeBuffer &operator=(SerializeBuffer &&rhs)
+	{
+		if (this != &rhs) {
+			delete[] m_buffer;
+
+			m_buffer = rhs.m_buffer;
+			m_capacity = rhs.m_capacity;
+			m_pos = rhs.m_pos;
+
+			rhs.m_buffer = nullptr;
+			rhs.m_capacity = 0;
+			rhs.m_pos = 0;
+		}
+		return *this;
+	}
+
+	~SerializeBuffer() { delete[] m_buffer; }
+
+	void WriteUInt8(uint8_t v)
+	{
+		if (m_pos + sizeof(uint8_t) > m_capacity)
+			Grow(m_capacity + sizeof(uint8_t));
+		*(uint8_t *)(m_buffer + m_pos) = v;
+		m_pos += sizeof(uint8_t);
+	}
+
+	void WriteUInt16(uint16_t v)
+	{
+		if (m_pos + sizeof(uint16_t) > m_capacity)
+			Grow(m_capacity + sizeof(uint16_t));
+		*(uint16_t *)(m_buffer + m_pos) = v;
+		m_pos += sizeof(uint16_t);
+	}
+
+	void WriteUInt32(uint32_t v)
+	{
+		if (m_pos + sizeof(uint32_t) > m_capacity)
+			Grow(m_capacity + sizeof(uint32_t));
+		*(uint32_t *)(m_buffer + m_pos) = v;
+		m_pos += sizeof(uint32_t);
+	}
+
+	void WriteUInt64(uint64_t v)
+	{
+		if (m_pos + sizeof(uint64_t) > m_capacity)
+			Grow(m_capacity + sizeof(uint64_t));
+		*(uint64_t *)(m_buffer + m_pos) = v;
+		m_pos += sizeof(uint64_t);
+	}
+
+	void WriteInt8(int8_t v)
+	{
+		if (m_pos + sizeof(int8_t) > m_capacity)
+			Grow(m_capacity + sizeof(int8_t));
+		*(int8_t *)(m_buffer + m_pos) = v;
+		m_pos += sizeof(int8_t);
+	}
+
+	void WriteInt16(int16_t v)
+	{
+		if (m_pos + sizeof(int16_t) > m_capacity)
+			Grow(m_capacity + sizeof(int16_t));
+		*(int16_t *)(m_buffer + m_pos) = v;
+		m_pos += sizeof(int16_t);
+	}
+
+	void WriteInt32(int32_t v)
+	{
+		if (m_pos + sizeof(int32_t) > m_capacity)
+			Grow(m_capacity + sizeof(int32_t));
+		*(int32_t *)(m_buffer + m_pos) = v;
+		m_pos += sizeof(int32_t);
+	}
+
+	void WriteInt64(int64_t v)
+	{
+		if (m_pos + sizeof(int64_t) > m_capacity)
+			Grow(m_capacity + sizeof(int64_t));
+		*(int64_t *)(m_buffer + m_pos) = v;
+		m_pos += sizeof(int64_t);
+	}
+
+	void WriteFloat(float v)
+	{
+		if (m_pos + sizeof(float) > m_capacity)
+			Grow(m_capacity + sizeof(float));
+		*(float *)(m_buffer + m_pos) = v;
+		m_pos += sizeof(float);
+	}
+
+	void WriteDouble(double v)
+	{
+		if (m_pos + sizeof(double) > m_capacity)
+			Grow(m_capacity + sizeof(double));
+		*(double *)(m_buffer + m_pos) = v;
+		m_pos += sizeof(double);
+	}
+
+	void WriteString(const char *str)
+	{
+		assert(str != nullptr);
+		auto len = strlen(str) + 1;
+		if (m_pos + len > m_capacity)
+			Grow(m_capacity + len);
+		memcpy(m_buffer + m_pos, str, len);
+		m_pos += len;
+	}
+
+	void WriteString(const std::string &str)
+	{
+		auto len = str.length() + 1;
+		if (m_pos + len > m_capacity)
+			Grow(m_capacity + len);
+		memcpy(m_buffer + m_pos, str.c_str(), len);
+		m_pos += len;
+	}
+
+	void WriteLengthString(uint32_t len, const char *str)
+	{
+		assert(str != nullptr);
+		if (m_pos + len + sizeof(uint32_t) > m_capacity)
+			Grow(m_capacity + len + sizeof(uint32_t));
+		*(uint32_t *)(m_buffer + m_pos) = len;
+		m_pos += sizeof(uint32_t);
+		memcpy(m_buffer + m_pos, str, len);
+		m_pos += len;
+	}
+
+	void WriteLengthString(const std::string &str)
+	{
+		uint32_t len = str.length();
+		if (m_pos + len + sizeof(uint32_t) > m_capacity)
+			Grow(m_capacity + len + sizeof(uint32_t));
+		*(uint32_t *)(m_buffer + m_pos) = len;
+		m_pos += sizeof(uint32_t);
+		memcpy(m_buffer + m_pos, str.c_str(), len);
+		m_pos += len;
+	}
+
+	size_t size() const { return m_pos; }
+	size_t length() const { return size(); }
+	size_t capacity() const { return m_capacity; }
+	const unsigned char *buffer() const { return m_buffer; }
+
+	friend class BasePacket;
+
+private:
+	void Grow(size_t new_size);
+	void Reset();
+	unsigned char *m_buffer;
+	size_t m_capacity;
+	size_t m_pos;
+};
+
+#endif /* !SERIALIZE_BUFFER_H */

common/shareddb.cpp

@@ -151,8 +151,8 @@ bool SharedDatabase::SaveCursor(uint32 char_id, std::list<EQEmu::ItemInstance*>:
 	std::string query = StringFormat("DELETE FROM inventory WHERE charid = %i "
                                     "AND ((slotid >= 8000 AND slotid <= 8999) "
                                     "OR slotid = %i OR (slotid >= %i AND slotid <= %i) )",
-									char_id, EQEmu::inventory::slotCursor,
-									EQEmu::legacy::CURSOR_BAG_BEGIN, EQEmu::legacy::CURSOR_BAG_END);
+									char_id, EQEmu::invslot::slotCursor,
+									EQEmu::invbag::CURSOR_BAG_BEGIN, EQEmu::invbag::CURSOR_BAG_END);
     auto results = QueryDatabase(query);
     if (!results.Success()) {
         std::cout << "Clearing cursor failed: " << results.ErrorMessage() << std::endl;
@@ -163,7 +163,7 @@ bool SharedDatabase::SaveCursor(uint32 char_id, std::list<EQEmu::ItemInstance*>:
     for(auto it = start; it != end; ++it, i++) {
 		if (i > 8999) { break; } // shouldn't be anything in the queue that indexes this high
         EQEmu::ItemInstance *inst = *it;
-		int16 use_slot = (i == 8000) ? EQEmu::inventory::slotCursor : i;
+		int16 use_slot = (i == 8000) ? EQEmu::invslot::slotCursor : i;
 		if (!SaveInventory(char_id, inst, use_slot)) {
 			return false;
 		}
@@ -208,10 +208,12 @@ bool SharedDatabase::VerifyInventory(uint32 account_id, int16 slot_id, const EQE
 bool SharedDatabase::SaveInventory(uint32 char_id, const EQEmu::ItemInstance* inst, int16 slot_id) {
 
 	//never save tribute slots:
-	if (slot_id >= EQEmu::legacy::TRIBUTE_BEGIN && slot_id <= EQEmu::legacy::TRIBUTE_END)
+	if (slot_id >= EQEmu::invslot::TRIBUTE_BEGIN && slot_id <= EQEmu::invslot::TRIBUTE_END)
+		return true;
+	if (slot_id >= EQEmu::invslot::GUILD_TRIBUTE_BEGIN && slot_id <= EQEmu::invslot::GUILD_TRIBUTE_END)
 		return true;
 
-	if (slot_id >= EQEmu::legacy::SHARED_BANK_BEGIN && slot_id <= EQEmu::legacy::SHARED_BANK_BAGS_END) {
+	if (slot_id >= EQEmu::invslot::SHARED_BANK_BEGIN && slot_id <= EQEmu::invbag::SHARED_BANK_BAGS_END) {
         // Shared bank inventory
 		if (!inst) {
 			return DeleteSharedBankSlot(char_id, slot_id);
@@ -238,9 +240,9 @@ bool SharedDatabase::SaveInventory(uint32 char_id, const EQEmu::ItemInstance* in
 bool SharedDatabase::UpdateInventorySlot(uint32 char_id, const EQEmu::ItemInstance* inst, int16 slot_id) {
 	// need to check 'inst' argument for valid pointer
 
-	uint32 augslot[EQEmu::inventory::SocketCount] = { 0, 0, 0, 0, 0, 0 };
+	uint32 augslot[EQEmu::invaug::SOCKET_COUNT] = { 0, 0, 0, 0, 0, 0 };
 	if (inst->IsClassCommon()) {
-		for (int i = EQEmu::inventory::socketBegin; i < EQEmu::inventory::SocketCount; i++) {
+		for (int i = EQEmu::invaug::SOCKET_BEGIN; i <= EQEmu::invaug::SOCKET_END; i++) {
 			EQEmu::ItemInstance *auginst = inst->GetItem(i);
 			augslot[i] = (auginst && auginst->GetItem()) ? auginst->GetItem()->ID : 0;
 		}
@@ -270,7 +272,7 @@ bool SharedDatabase::UpdateInventorySlot(uint32 char_id, const EQEmu::ItemInstan
 	if (inst->IsClassBag() && EQEmu::InventoryProfile::SupportsContainers(slot_id))
 		// Limiting to bag slot count will get rid of 'hidden' duplicated items and 'Invalid Slot ID'
 		// messages through attrition (and the modded code in SaveInventory)
-		for (uint8 idx = EQEmu::inventory::containerBegin; idx < inst->GetItem()->BagSlots && idx < EQEmu::inventory::ContainerCount; idx++) {
+		for (uint8 idx = EQEmu::invbag::SLOT_BEGIN; idx < inst->GetItem()->BagSlots && idx <= EQEmu::invbag::SLOT_END; idx++) {
 			const EQEmu::ItemInstance* baginst = inst->GetItem(idx);
 			SaveInventory(char_id, baginst, EQEmu::InventoryProfile::CalcSlotId(slot_id, idx));
 		}
@@ -285,9 +287,9 @@ bool SharedDatabase::UpdateInventorySlot(uint32 char_id, const EQEmu::ItemInstan
 bool SharedDatabase::UpdateSharedBankSlot(uint32 char_id, const EQEmu::ItemInstance* inst, int16 slot_id) {
 	// need to check 'inst' argument for valid pointer
 
-	uint32 augslot[EQEmu::inventory::SocketCount] = { 0, 0, 0, 0, 0, 0 };
+	uint32 augslot[EQEmu::invaug::SOCKET_COUNT] = { 0, 0, 0, 0, 0, 0 };
 	if (inst->IsClassCommon()) {
-		for (int i = EQEmu::inventory::socketBegin; i < EQEmu::inventory::SocketCount; i++) {
+		for (int i = EQEmu::invaug::SOCKET_BEGIN; i <= EQEmu::invaug::SOCKET_END; i++) {
 			EQEmu::ItemInstance *auginst = inst->GetItem(i);
 			augslot[i] = (auginst && auginst->GetItem()) ? auginst->GetItem()->ID : 0;
 		}
@@ -316,7 +318,7 @@ bool SharedDatabase::UpdateSharedBankSlot(uint32 char_id, const EQEmu::ItemInsta
 	if (inst->IsClassBag() && EQEmu::InventoryProfile::SupportsContainers(slot_id)) {
 		// Limiting to bag slot count will get rid of 'hidden' duplicated items and 'Invalid Slot ID'
 		// messages through attrition (and the modded code in SaveInventory)
-		for (uint8 idx = EQEmu::inventory::containerBegin; idx < inst->GetItem()->BagSlots && idx < EQEmu::inventory::ContainerCount; idx++) {
+		for (uint8 idx = EQEmu::invbag::SLOT_BEGIN; idx < inst->GetItem()->BagSlots && idx <= EQEmu::invbag::SLOT_END; idx++) {
 			const EQEmu::ItemInstance* baginst = inst->GetItem(idx);
 			SaveInventory(char_id, baginst, EQEmu::InventoryProfile::CalcSlotId(slot_id, idx));
 		}
@@ -342,7 +344,7 @@ bool SharedDatabase::DeleteInventorySlot(uint32 char_id, int16 slot_id) {
 	if (!EQEmu::InventoryProfile::SupportsContainers(slot_id))
         return true;
 
-	int16 base_slot_id = EQEmu::InventoryProfile::CalcSlotId(slot_id, EQEmu::inventory::containerBegin);
+	int16 base_slot_id = EQEmu::InventoryProfile::CalcSlotId(slot_id, EQEmu::invbag::SLOT_BEGIN);
     query = StringFormat("DELETE FROM inventory WHERE charid = %i AND slotid >= %i AND slotid < %i",
                         char_id, base_slot_id, (base_slot_id+10));
     results = QueryDatabase(query);
@@ -368,7 +370,7 @@ bool SharedDatabase::DeleteSharedBankSlot(uint32 char_id, int16 slot_id) {
 	if (!EQEmu::InventoryProfile::SupportsContainers(slot_id))
         return true;
 
-	int16 base_slot_id = EQEmu::InventoryProfile::CalcSlotId(slot_id, EQEmu::inventory::containerBegin);
+	int16 base_slot_id = EQEmu::InventoryProfile::CalcSlotId(slot_id, EQEmu::invbag::SLOT_BEGIN);
     query = StringFormat("DELETE FROM sharedbank WHERE acctid = %i "
                         "AND slotid >= %i AND slotid < %i",
                         account_id, base_slot_id, (base_slot_id+10));
@@ -474,7 +476,7 @@ bool SharedDatabase::GetSharedBank(uint32 id, EQEmu::InventoryProfile *inv, bool
 		uint32 item_id = (uint32)atoi(row[1]);
 		int8 charges = (int8)atoi(row[2]);
 
-		uint32 aug[EQEmu::inventory::SocketCount];
+		uint32 aug[EQEmu::invaug::SOCKET_COUNT];
 		aug[0] = (uint32)atoi(row[3]);
 		aug[1] = (uint32)atoi(row[4]);
 		aug[2] = (uint32)atoi(row[5]);
@@ -495,7 +497,7 @@ bool SharedDatabase::GetSharedBank(uint32 id, EQEmu::InventoryProfile *inv, bool
 
 		EQEmu::ItemInstance *inst = CreateBaseItem(item, charges);
 		if (inst && item->IsClassCommon()) {
-			for (int i = EQEmu::inventory::socketBegin; i < EQEmu::inventory::SocketCount; i++) {
+			for (int i = EQEmu::invaug::SOCKET_BEGIN; i <= EQEmu::invaug::SOCKET_END; i++) {
 				if (aug[i])
 					inst->PutAugment(this, i, aug[i]);
 			}
@@ -570,7 +572,7 @@ bool SharedDatabase::GetInventory(uint32 char_id, EQEmu::InventoryProfile *inv)
 		uint16 charges = atoi(row[2]);
 		uint32 color = atoul(row[3]);
 
-		uint32 aug[EQEmu::inventory::SocketCount];
+		uint32 aug[EQEmu::invaug::SOCKET_COUNT];
 
 		aug[0] = (uint32)atoul(row[4]);
 		aug[1] = (uint32)atoul(row[5]);
@@ -632,8 +634,8 @@ bool SharedDatabase::GetInventory(uint32 char_id, EQEmu::InventoryProfile *inv)
 		inst->SetOrnamentHeroModel(item->HerosForgeModel);
 
 		if (instnodrop ||
-			(((slot_id >= EQEmu::legacy::EQUIPMENT_BEGIN && slot_id <= EQEmu::legacy::EQUIPMENT_END) ||
-			slot_id == EQEmu::inventory::slotPowerSource) &&
+			(((slot_id >= EQEmu::invslot::EQUIPMENT_BEGIN && slot_id <= EQEmu::invslot::EQUIPMENT_END) ||
+			slot_id == EQEmu::invslot::SLOT_POWER_SOURCE) &&
 		     inst->GetItem()->Attuneable))
 			inst->SetAttuned(true);
 
@@ -655,7 +657,7 @@ bool SharedDatabase::GetInventory(uint32 char_id, EQEmu::InventoryProfile *inv)
 		}
 
 		if (item->IsClassCommon()) {
-			for (int i = EQEmu::inventory::socketBegin; i < EQEmu::inventory::SocketCount; i++) {
+			for (int i = EQEmu::invaug::SOCKET_BEGIN; i <= EQEmu::invaug::SOCKET_END; i++) {
 				if (aug[i])
 					inst->PutAugment(this, i, aug[i]);
 			}
@@ -712,7 +714,7 @@ bool SharedDatabase::GetInventory(uint32 account_id, char *name, EQEmu::Inventor
 		int8 charges = atoi(row[2]);
 		uint32 color = atoul(row[3]);
 
-		uint32 aug[EQEmu::inventory::SocketCount];
+		uint32 aug[EQEmu::invaug::SOCKET_COUNT];
 		aug[0] = (uint32)atoi(row[4]);
 		aug[1] = (uint32)atoi(row[5]);
 		aug[2] = (uint32)atoi(row[6]);
@@ -773,7 +775,7 @@ bool SharedDatabase::GetInventory(uint32 account_id, char *name, EQEmu::Inventor
 		inst->SetCharges(charges);
 
 		if (item->IsClassCommon()) {
-			for (int i = EQEmu::inventory::socketBegin; i < EQEmu::inventory::SocketCount; i++) {
+			for (int i = EQEmu::invaug::SOCKET_BEGIN; i <= EQEmu::invaug::SOCKET_END; i++) {
 				if (aug[i])
 					inst->PutAugment(this, i, aug[i]);
 			}

common/spdat.cpp

@@ -244,8 +244,7 @@ bool IsBeneficialSpell(uint16 spell_id)
 			} else {
 				// If the resisttype is not magic and spell is Bind Sight or Cast Sight
 				// It's not beneficial
-				if (sai == SAI_Dispell_Sight && spells[spell_id].skill == 18 &&
-						!IsEffectInSpell(spell_id, SE_VoiceGraft))
+				if ((sai == SAI_Calm && IsEffectInSpell(spell_id, SE_Harmony)) || (sai == SAI_Calm_Song && IsEffectInSpell(spell_id, SE_BindSight)) || (sai == SAI_Dispell_Sight && spells[spell_id].skill == 18 && !IsEffectInSpell(spell_id, SE_VoiceGraft)))
 					return false;
 			}
 		}

common/timer.cpp

@@ -129,14 +129,13 @@ void Timer::SetTimer(uint32 set_timer_time) {
 	}
 }
 
-uint32 Timer::GetRemainingTime() {
+uint32 Timer::GetRemainingTime() const {
 	if (enabled) {
-		if (current_time-start_time > timer_time)
+		if (current_time - start_time > timer_time)
 			return 0;
 		else
 			return (start_time + timer_time) - current_time;
-	}
-	else {
+	} else {
 		return 0xFFFFFFFF;
 	}
 }

common/timer.h

@@ -40,7 +40,7 @@ public:
 	void Disable();
 	void Start(uint32 set_timer_time=0, bool ChangeResetTimer = true);
 	void SetTimer(uint32 set_timer_time=0);
-	uint32 GetRemainingTime();
+	uint32 GetRemainingTime() const;
 	inline const uint32& GetTimerTime()		{ return timer_time; }
 	inline const uint32& GetSetAtTrigger()	{ return set_at_trigger; }
 	void Trigger();

common/useperl.h

@@ -6,6 +6,10 @@
 #include <EXTERN.h>
 #define WIN32IO_IS_STDIO
 
+// header to detect if libc++ is the std lib
+// this doesn't do shit for C++ but libc++ and GCC 6.1+ use it to define some macros
+#include <ciso646>
+
 #ifndef WIN32
 extern "C" {	//the perl headers dont do this for us...
 #endif
@@ -47,7 +51,7 @@ extern "C" {	//the perl headers dont do this for us...
 #endif
 
 //These need to be cleaned up on FreeBSD
-#ifdef __FreeBSD__
+#if defined(__FreeBSD__) || defined(_LIBCPP_VERSION)
 #ifdef do_open
 #undef do_open
 #endif

common/version.h

@@ -30,9 +30,9 @@
 	Manifest: https://github.com/EQEmu/Server/blob/master/utils/sql/db_update_manifest.txt
 */
 
-#define CURRENT_BINARY_DATABASE_VERSION 9122
+#define CURRENT_BINARY_DATABASE_VERSION 9125
 #ifdef BOTS
-	#define CURRENT_BINARY_BOTS_DATABASE_VERSION 9018
+	#define CURRENT_BINARY_BOTS_DATABASE_VERSION 9019
 #else
 	#define CURRENT_BINARY_BOTS_DATABASE_VERSION 0 // must be 0
 #endif

libs/CMakeLists.txt

@@ -3,4 +3,5 @@ IF(EQEMU_BUILD_LUA)
 ENDIF(EQEMU_BUILD_LUA)
 
 ADD_SUBDIRECTORY(libuv)
-ADD_SUBDIRECTORY(format)
+ADD_SUBDIRECTORY(format)
+ADD_SUBDIRECTORY(recast)

libs/format/.github/pull_request_template

@@ -0,0 +1,3 @@
+<!---
+Please make sure you've followed the guidelines outlined in the CONTRIBUTING.rst file.
+--->

libs/format/.gitignore

@@ -0,0 +1,19 @@
+bin/
+/_CPack_Packages
+/doc/doxyxml
+/doc/html
+virtualenv
+/Testing
+/install_manifest.txt
+*~
+*.a
+*.so*
+*.zip
+cmake_install.cmake
+CPack*.cmake
+fmt-*.cmake
+CTestTestfile.cmake
+CMakeCache.txt
+CMakeFiles
+Makefile
+run-msbuild.bat

libs/format/.travis.yml

@@ -1,4 +1,5 @@
 language: cpp
+dist: trusty
 sudo: required # the doc target uses sudo to install dependencies
 
 os:
@@ -22,12 +23,5 @@ matrix:
     - os: osx
       env: BUILD=Doc
 
-addons:
-  apt:
-    sources:
-      - kubuntu-backports # cmake 2.8.12
-    packages:
-      - cmake
-
 script:
   - support/travis-build.py

libs/format/CMakeLists.txt

@@ -1,6 +1,6 @@
 message(STATUS "CMake version: ${CMAKE_VERSION}")
 
-cmake_minimum_required(VERSION 2.8)
+cmake_minimum_required(VERSION 2.8.12)
 
 # Determine if fmt is built as a subproject (using add_subdirectory)
 # or if it is the master project.
@@ -9,12 +9,22 @@ if (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
   set(MASTER_PROJECT ON)
 endif ()
 
+# Joins arguments and places the results in ${result_var}.
+function(join result_var)
+  set(result )
+  foreach (arg ${ARGN})
+    set(result "${result}${arg}")
+  endforeach ()
+  set(${result_var} "${result}" PARENT_SCOPE)
+endfunction()
+
 # Set the default CMAKE_BUILD_TYPE to Release.
 # This should be done before the project command since the latter can set
 # CMAKE_BUILD_TYPE itself (it does so for nmake).
 if (NOT CMAKE_BUILD_TYPE)
-  set(CMAKE_BUILD_TYPE Release CACHE STRING
-    "Choose the type of build, options are: None(CMAKE_CXX_FLAGS or CMAKE_C_FLAGS used) Debug Release RelWithDebInfo MinSizeRel.")
+  join(doc "Choose the type of build, options are: None(CMAKE_CXX_FLAGS or "
+           "CMAKE_C_FLAGS used) Debug Release RelWithDebInfo MinSizeRel.")
+  set(CMAKE_BUILD_TYPE Release CACHE STRING ${doc})
 endif ()
 
 option(FMT_PEDANTIC "Enable extra warnings and expensive tests." OFF)
@@ -28,13 +38,17 @@ option(FMT_USE_CPP11 "Enable the addition of C++11 compiler flags." ON)
 project(FMT)
 
 # Starting with cmake 3.0 VERSION is part of the project command.
-set(FMT_VERSION 3.0.0)
-if (NOT FMT_VERSION MATCHES "^([0-9]+).([0-9]+).([0-9]+)$")
-  message(FATAL_ERROR "Invalid version format ${FMT_VERSION}.")
+file(READ fmt/format.h format_h)
+if (NOT format_h MATCHES "FMT_VERSION ([0-9]+)([0-9][0-9])([0-9][0-9])")
+  message(FATAL_ERROR "Cannot get FMT_VERSION from format.h.")
 endif ()
-set(CPACK_PACKAGE_VERSION_MAJOR ${CMAKE_MATCH_1})
-set(CPACK_PACKAGE_VERSION_MINOR ${CMAKE_MATCH_2})
-set(CPACK_PACKAGE_VERSION_PATCH ${CMAKE_MATCH_3})
+# Use math to skip leading zeros if any.
+math(EXPR CPACK_PACKAGE_VERSION_MAJOR ${CMAKE_MATCH_1})
+math(EXPR CPACK_PACKAGE_VERSION_MINOR ${CMAKE_MATCH_2})
+math(EXPR CPACK_PACKAGE_VERSION_PATCH ${CMAKE_MATCH_3})
+join(FMT_VERSION ${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.
+                 ${CPACK_PACKAGE_VERSION_PATCH})
+message(STATUS "Version: ${FMT_VERSION}")
 
 message(STATUS "Build type: ${CMAKE_BUILD_TYPE}")
 

libs/format/CONTRIBUTING.rst

@@ -0,0 +1,11 @@
+Contributing to fmt
+===================
+
+All C++ code must adhere to `Google C++ Style Guide
+<https://google.github.io/styleguide/cppguide.html>`_ with the following
+exceptions:
+
+* Exceptions are permitted
+* snake_case should be used instead of UpperCamelCase for function names
+
+Thanks for contributing!