Merge pull request #13 from EQEmu/master

update

.gitignore

@@ -37,3 +37,6 @@ x64/
 x86/
 log/
 logs/
+vcpkg/
+
+.idea/*

.travis.yml

@@ -1,32 +1,27 @@
 language: cpp
 compiler: gcc
-sudo: false
+dist: trusty
-addons:
+
-  apt:
+before_install:
-    sources:
+  - sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test
-    - ubuntu-toolchain-r-test
+  - sudo apt-get update -qq
-    packages:
+  - mkdir $HOME/usr
-    - gcc-4.8
+  - export PATH="$HOME/usr/bin:$PATH"
-    - g++-4.8
+  - wget https://cmake.org/files/v3.11/cmake-3.11.2-Linux-x86_64.sh
-    - libmysqlclient-dev
+  - chmod +x cmake-3.11.2-Linux-x86_64.sh
-    - libperl-dev
+  - ./cmake-3.11.2-Linux-x86_64.sh --prefix=$HOME/usr --exclude-subdir --skip-license
-    - libboost-dev
+
-    - liblua5.1-0-dev
-    - zlib1g-dev
-    - uuid-dev
-    - libssl-dev
 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,8 +27,6 @@
 #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)
 
 #FindMySQL is located here so lets make it so CMake can find it
@@ -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)
@@ -53,7 +53,6 @@ IF(MSVC OR MINGW)
 ENDIF(MSVC OR MINGW)
 
 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")
@@ -100,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")
@@ -309,7 +291,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)
+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)
@@ -342,7 +324,7 @@ 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")
 
 	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)
@@ -357,6 +339,8 @@ 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 GNU General Public License is a free, copyleft license for
-the terms and conditions of version 3 of the GNU General Public
+software and other kinds of works.
-License, supplemented by the additional permissions listed below.
 
-  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
+  When we speak of free software, we are referring to freedom, not
-General Public License, and the "GNU GPL" refers to version 3 of the GNU
+price.  Our General Public Licenses are designed to make sure that you
-General Public License.
+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,
+  To protect your rights, we need to prevent others from denying you
-other than an Application or a Combined Work as defined below.
+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
+  For example, if you distribute copies of such a program, whether
-by the Library, but which is not otherwise based on the Library.
+gratis or for a fee, you must pass on to the recipients the same
-Defining a subclass of a class defined by the Library is deemed a mode
+freedoms that you received.  You must make sure that they, too, receive
-of using an interface provided by the Library.
+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
+  Developers that use the GNU GPL protect your rights with two steps:
-Application with the Library.  The particular version of the Library
+(1) assert copyright on the software, and (2) offer you this License
-with which the Combined Work was made is also called the "Linked
+giving you legal permission to copy, distribute and/or modify it.
-Version".
 
-  The "Minimal Corresponding Source" for a Combined Work means the
+  For the developers' and authors' protection, the GPL clearly explains
-Corresponding Source for the Combined Work, excluding any source code
+that there is no warranty for this free software.  For both users' and
-for portions of the Combined Work that, considered in isolation, are
+authors' sake, the GPL requires that modified versions be marked as
-based on the Application, and not on the Linked Version.
+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
+  Some devices are designed to deny users access to install or run
-object code and/or source code for the Application, including any data
+modified versions of the software inside them, although the manufacturer
-and utility programs needed for reproducing the Combined Work from the
+can do so.  This is fundamentally incompatible with the aim of
-Application, but excluding the System Libraries of the Combined Work.
+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
+  The precise terms and conditions for copying, distribution and
-without being bound by section 3 of the GNU GPL.
+modification follow.
 
-  2. Conveying Modified Versions.
+                       TERMS AND CONDITIONS
 
-  If you modify a copy of the Library, and, in your modifications, a
+  0. Definitions.
-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:
 
-   a) under this License, provided that you make a good faith effort to
+  "This License" refers to version 3 of the GNU General Public License.
-   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
 
-   b) under the GNU GPL, with none of the additional permissions of
+  "Copyright" also means copyright-like laws that apply to other kinds of
-   this License applicable to that copy.
+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
+  To "modify" a work means to copy from or adapt all or part of the work
-a header file that is part of the Library.  You may convey such object
+in a fashion requiring copyright permission, other than the making of an
-code under terms of your choice, provided that, if the incorporated
+exact copy.  The resulting work is called a "modified version" of the
-material is not limited to numerical parameters, data structure
+earlier work or a work "based on" the earlier work.
-layouts and accessors, or small macros, inline functions and templates
-(ten or fewer lines in length), you do both of the following:
 
-   a) Give prominent notice with each copy of the object code that the
+  A "covered work" means either the unmodified Program or a work based
-   Library is used in it and that the Library and its use are
+on the Program.
-   covered by this License.
 
-   b) Accompany the object code with a copy of the GNU GPL and this license
+  To "propagate" a work means to do anything with it that, without
-   document.
+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,
+  An interactive user interface displays "Appropriate Legal Notices"
-taken together, effectively do not restrict modification of the
+to the extent that it includes a convenient and prominently visible
-portions of the Library contained in the Combined Work and reverse
+feature that (1) displays an appropriate copyright notice, and (2)
-engineering for debugging such modifications, if you also do each of
+tells the user that there is no warranty for the work (except to the
-the following:
+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
+  1. Source Code.
-   the Library is used in it and that the Library and its use are
-   covered by this License.
 
-   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+  The "source code" for a work means the preferred form of the work
-   document.
+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
+  A "Standard Interface" means an interface that either is an official
-   execution, include the copyright notice for the Library among
+standard defined by a recognized standards body, or, in the case of
-   these notices, as well as a reference directing the user to the
+interfaces specified for a particular programming language, one that
-   copies of the GNU GPL and this license document.
+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
+  The "Corresponding Source" for a work in object code form means all
-       License, and the Corresponding Application Code in a form
+the source code needed to generate, install, and (for an executable
-       suitable for, and under terms that permit, the user to
+work) run the object code and to modify the work, including scripts to
-       recombine or relink the Application with a modified version of
+control those activities.  However, it does not include the work's
-       the Linked Version to produce a modified Combined Work, in the
+System Libraries, or general-purpose tools or generally available free
-       manner specified by section 6 of the GNU GPL for conveying
+programs which are used unmodified in performing those activities but
-       Corresponding Source.
+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
+  The Corresponding Source need not include anything that users
-       Library.  A suitable mechanism is one that (a) uses at run time
+can regenerate automatically from other parts of the Corresponding
-       a copy of the Library already present on the user's computer
+Source.
-       system, and (b) will operate properly with a modified version
-       of the Library that is interface-compatible with the Linked
-       Version.
 
-   e) Provide Installation Information, but only if you would otherwise
+  The Corresponding Source for a work in source code form is that
-   be required to provide such information under section 6 of the
+same work.
-   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.)
 
-  5. Combined Libraries.
+  2. Basic Permissions.
 
-  You may place library facilities that are a work based on the
+  All rights granted under this License are granted for the term of
-Library side by side in a single library together with other library
+copyright on the Program, and are irrevocable provided the stated
-facilities that are not Applications and are not covered by this
+conditions are met.  This License explicitly affirms your unlimited
-License, and convey such a combined library under terms of your
+permission to run the unmodified Program.  The output from running a
-choice, if you do both of the following:
+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
+  You may make, run and propagate covered works that you do not
-   on the Library, uncombined with any other library facilities,
+convey, without conditions so long as your license otherwise remains
-   conveyed under the terms of this License.
+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
+  Conveying under any other circumstances is permitted solely under
-   is a work based on the Library, and explaining where to find the
+the conditions stated below.  Sublicensing is not allowed; section 10
-   accompanying uncombined form of the same work.
+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
+  No covered work shall be deemed part of an effective technological
-of the GNU Lesser General Public License from time to time. Such new
+measure under any applicable law fulfilling obligations under article
-versions will be similar in spirit to the present version, but may
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
-differ in detail to address new problems or concerns.
+similar laws prohibiting or restricting circumvention of such
+measures.
 
-  Each version is given a distinguishing version number. If the
+  When you convey a covered work, you waive any legal power to forbid
-Library as you received it specifies that a certain numbered version
+circumvention of technological measures to the extent such circumvention
-of the GNU Lesser General Public License "or any later version"
+is effected by exercising rights under this License with respect to
-applies to it, you have the option of following the terms and
+the covered work, and you disclaim any intention to limit operation or
-conditions either of that published version or of any later version
+modification of the work as a means of enforcing, against the work's
-published by the Free Software Foundation. If the Library as you
+users, your or third parties' legal rights to forbid circumvention of
-received it does not specify a version number of the GNU Lesser
+technological measures.
-General Public License, you may choose any version of the GNU Lesser
-General Public License ever published by the Free Software Foundation.
 
-  If the Library as you received it specifies that a proxy can decide
+  4. Conveying Verbatim Copies.
-whether future versions of the GNU Lesser General Public License shall
+
-apply, that proxy's public statement of acceptance of any version is
+  You may convey verbatim copies of the Program's source code as you
-permanent authorization for you to choose that version for the
+receive it, in any medium, provided that you conspicuously and
-Library.
+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)   |
+|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)   |[![Windows CI](https://ci.appveyor.com/api/projects/status/d0cvokm7u732v8vl/branch/master?svg=true)](https://ci.appveyor.com/project/KimLS/server/branch/master)   |
+|[![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,10 +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

common/CMakeLists.txt

@@ -3,6 +3,7 @@ CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
 SET(common_sources
 	base_packet.cpp
 	classes.cpp
+	compression.cpp
 	condition.cpp
 	crash.cpp
 	crc16.cpp
@@ -13,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
@@ -60,6 +60,7 @@ SET(common_sources
 	rdtsc.cpp
 	rulesys.cpp
 	say_link.cpp
+	serialize_buffer.cpp
 	serverinfo.cpp
 	shareddb.cpp
 	skills.cpp
@@ -113,6 +114,7 @@ SET(common_headers
 	base_data.h
 	bodytypes.h
 	classes.h
+	compression.h
 	condition.h
 	crash.h
 	crc16.h
@@ -122,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
@@ -190,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) {
+		if (i == EQEmu::invslot::slotCursor) {
-			i = EQEmu::legacy::GENERAL_BAGS_BEGIN; 
+			i = EQEmu::invbag::GENERAL_BAGS_BEGIN; 
 			continue;
 		}
-		else if (i == EQEmu::legacy::CURSOR_BAG_END) { 
+		else if (i == EQEmu::invbag::CURSOR_BAG_END) { 
-			i = EQEmu::legacy::BANK_BEGIN; 
+			i = EQEmu::invslot::BANK_BEGIN; 
 			continue; 
 		}
-		else if (i == EQEmu::legacy::BANK_END) { 
+		else if (i == EQEmu::invslot::BANK_END) { 
-			i = EQEmu::legacy::BANK_BAGS_BEGIN; 
+			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 {
+	namespace invtype {
-		const EQEmu::versions::ClientVersion CharacterCreationClient = EQEmu::versions::ClientVersion::RoF2;
+		using namespace RoF2::invtype::enum_;
-		const size_t CharacterCreationMax = RoF2::constants::CharacterCreationLimit;
 
-		const size_t SayLinkOpenerSize = 1;
+		using RoF2::invtype::POSSESSIONS_SIZE;
-		const size_t SayLinkBodySize = RoF2::constants::SayLinkBodySize;
+		using RoF2::invtype::BANK_SIZE;
-		const size_t SayLinkTextSize = 256; // this may be varied until it breaks something (tested:374) - the others are constant
+		using RoF2::invtype::SHARED_BANK_SIZE;
-		const size_t SayLinkCloserSize = 1;
+		using RoF2::invtype::TRADE_SIZE;
-		const size_t SayLinkMaximumSize = (SayLinkOpenerSize + SayLinkBodySize + SayLinkTextSize + SayLinkCloserSize);
+		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;
+			uint64 CorpseBitmask;
-			size_t ItemAugSize;
+			int16 BagSlotCount;
+			int16 AugSocketCount;
 
 			bool AllowEmptyBagInBag;
 			bool AllowClickCastFromBag;
@@ -84,17 +89,15 @@ namespace EQEmu
 
 namespace ClientUnknown
 {
-	enum : int { Invalid = -1, Null, Safety };
+	const int16 IINVALID = -1;
-
+	const int16 INULL = 0;
-	enum : bool { False = false, True = true };
 
 } /*ClientUnknown*/
 
 namespace Client62
 {
-	enum : int { Invalid = -1, Null, Safety };
+	const int16 IINVALID = -1;
-
+	const int16 INULL = 0;
-	enum : bool { False = false, True = true };
 
 } /*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	tributes[EQEmu::invtype::TRIBUTE_SIZE];	//-1 == NONE
-	uint32	tiers[EQEmu::legacy::TRIBUTE_SIZE];		//all 00's
+	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;
+	uint8	open_window;
-	uint32	unknown3;
+	uint32	task_type;
-	uint8	unknown4;
+	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; // ??
+	uint8 	has_rewards;
-	uint32	unknown1;
+	uint32	coin_reward;
-	uint32	unknown2;
+	uint32	xp_reward;
-	uint16	unknown3;
+	uint32	faction_reward;
-	//uint8	unknown4;
 };
 
 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	TaskType; // task, shared task, quest
-	uint32	unknown3;
+	uint32	TaskID;		// must match
 	uint32	ActivityID;
-	uint32	unknown4; // 0x00000001
+	uint32	task_completed; // Broadcasts "Task '%1' Completed" it not 0 and "Task '%1' Failed." if 0
-	uint32	unknown5; // 0x00000001
+	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/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/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) ||
+	else if ((slot_id >= invslot::EQUIPMENT_BEGIN && slot_id <= invslot::EQUIPMENT_END) ||
-		(slot_id >= legacy::TRIBUTE_BEGIN && slot_id <= legacy::TRIBUTE_END) || (slot_id == inventory::slotPowerSource)) {
+		(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;
+				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 < inventory::ContainerCount); ++free_bag_slot) {
+				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;
+			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 < inventory::ContainerCount); ++free_bag_slot) {
+			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;
+			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 < inventory::ContainerCount); ++free_bag_slot) {
+			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;
+			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 < inventory::ContainerCount); ++free_bag_slot) {
+			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) {
+	if (slot_id >= invbag::GENERAL_BAGS_BEGIN && slot_id <= invbag::GENERAL_BAGS_END) {
-		parent_slot_id = legacy::GENERAL_BEGIN + (slot_id - legacy::GENERAL_BAGS_BEGIN) / inventory::ContainerCount;
+		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) {
+	else if (slot_id >= invbag::CURSOR_BAG_BEGIN && slot_id <= invbag::CURSOR_BAG_END) {
-		parent_slot_id = inventory::slotCursor;
+		parent_slot_id = invslot::slotCursor;
 	}
-	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) {
-		parent_slot_id = legacy::BANK_BEGIN + (slot_id - legacy::BANK_BAGS_BEGIN) / inventory::ContainerCount;
+		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) {
+	else if (slot_id >= invbag::SHARED_BANK_BAGS_BEGIN && slot_id <= invbag::SHARED_BANK_BAGS_END) {
-		parent_slot_id = legacy::SHARED_BANK_BEGIN + (slot_id - legacy::SHARED_BANK_BAGS_BEGIN) / inventory::ContainerCount;
+		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) {
+	else if (slot_id >= invbag::TRADE_BAGS_BEGIN && slot_id <= invbag::TRADE_BAGS_END) {
-		parent_slot_id = legacy::TRADE_BEGIN + (slot_id - legacy::TRADE_BAGS_BEGIN) / inventory::ContainerCount;
+		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) {
+	if (bagslot_id == invslot::slotCursor || bagslot_id == 8000) {
-		slot_id = legacy::CURSOR_BAG_BEGIN + bagidx;
+		slot_id = invbag::CURSOR_BAG_BEGIN + bagidx;
 	}
-	else if (bagslot_id >= legacy::GENERAL_BEGIN && bagslot_id <= legacy::GENERAL_END) {
+	else if (bagslot_id >= invslot::GENERAL_BEGIN && bagslot_id <= invslot::GENERAL_END) {
-		slot_id = legacy::GENERAL_BAGS_BEGIN + (bagslot_id - legacy::GENERAL_BEGIN) * inventory::ContainerCount + bagidx;
+		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) {
+	else if (bagslot_id >= invslot::BANK_BEGIN && bagslot_id <= invslot::BANK_END) {
-		slot_id = legacy::BANK_BAGS_BEGIN + (bagslot_id - legacy::BANK_BEGIN) * inventory::ContainerCount + bagidx;
+		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) {
+	else if (bagslot_id >= invslot::SHARED_BANK_BEGIN && bagslot_id <= invslot::SHARED_BANK_END) {
-		slot_id = legacy::SHARED_BANK_BAGS_BEGIN + (bagslot_id - legacy::SHARED_BANK_BEGIN) * inventory::ContainerCount + bagidx;
+		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) {
+	else if (bagslot_id >= invslot::TRADE_BEGIN && bagslot_id <= invslot::TRADE_END) {
-		slot_id = legacy::TRADE_BAGS_BEGIN + (bagslot_id - legacy::TRADE_BEGIN) * inventory::ContainerCount + bagidx;
+		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) {
+	if (slot_id >= invbag::GENERAL_BAGS_BEGIN && slot_id <= invbag::GENERAL_BAGS_END) {
-		index = (slot_id - legacy::GENERAL_BAGS_BEGIN) % inventory::ContainerCount;
+		index = (slot_id - invbag::GENERAL_BAGS_BEGIN) % invbag::SLOT_COUNT;
 	}
-	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) {
-		index = (slot_id - legacy::CURSOR_BAG_BEGIN); // % inventory::ContainerCount; - not needed since range is 10 slots
+		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) {
+	else if (slot_id >= invbag::BANK_BAGS_BEGIN && slot_id <= invbag::BANK_BAGS_END) {
-		index = (slot_id - legacy::BANK_BAGS_BEGIN) % inventory::ContainerCount;
+		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) {
+	else if (slot_id >= invbag::SHARED_BANK_BAGS_BEGIN && slot_id <= invbag::SHARED_BANK_BAGS_END) {
-		index = (slot_id - legacy::SHARED_BANK_BAGS_BEGIN) % inventory::ContainerCount;
+		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) {
+	else if (slot_id >= invbag::TRADE_BAGS_BEGIN && slot_id <= invbag::TRADE_BAGS_END) {
-		index = (slot_id - legacy::TRADE_BAGS_BEGIN) % inventory::ContainerCount;
+		index = (slot_id - invbag::TRADE_BAGS_BEGIN) % invbag::SLOT_COUNT;
 	}
-	else if (slot_id >= legacy::WORLD_BEGIN && slot_id <= legacy::WORLD_END) {
+	else if (slot_id >= invslot::WORLD_BEGIN && slot_id <= invslot::WORLD_END) {
-		index = (slot_id - legacy::WORLD_BEGIN); // % inventory::ContainerCount; - not needed since range is 10 slots
+		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) ||
+	if ((slot_id == invslot::slotCursor) ||
-		(slot_id >= legacy::GENERAL_BEGIN && slot_id <= legacy::GENERAL_END) ||
+		(slot_id >= invslot::GENERAL_BEGIN && slot_id <= invslot::GENERAL_END) ||
-		(slot_id >= legacy::BANK_BEGIN && slot_id <= legacy::BANK_END) ||
+		(slot_id >= invslot::BANK_BEGIN && slot_id <= invslot::BANK_END) ||
-		(slot_id >= legacy::SHARED_BANK_BEGIN && slot_id <= legacy::SHARED_BANK_END) ||
+		(slot_id >= invslot::SHARED_BANK_BEGIN && slot_id <= invslot::SHARED_BANK_END) ||
-		(slot_id >= legacy::TRADE_BEGIN && slot_id <= legacy::TRADE_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 < invslot::EQUIPMENT_BEGIN || iter->first > invslot::EQUIPMENT_END) && iter->first != invslot::SLOT_POWER_SOURCE) { continue; }
-		if (iter->first == inventory::slotAmmo) { 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) {
+		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::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);
+	int16 slot_count = invtype::GetInvTypeSize(_type_index);
-	if (!slot_count || _slot_index < inventory::slotBegin || _slot_index >= slot_count)
+	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 invslot::slotHead:
-	case inventory::slotChest:
+	case invslot::slotChest:
-	case inventory::slotArms:
+	case invslot::slotArms:
-	case inventory::slotWrist1:
+	case invslot::slotWrist1:
-	case inventory::slotHands:
+	case invslot::slotHands:
-	case inventory::slotLegs:
+	case invslot::slotLegs:
-	case inventory::slotFeet:
+	case invslot::slotFeet:
-	case inventory::slotPrimary:
+	case invslot::slotPrimary:
-	case inventory::slotSecondary:
+	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 invslot::slotHead:
-	case inventory::slotChest:
+	case invslot::slotChest:
-	case inventory::slotArms:
+	case invslot::slotArms:
-	case inventory::slotWrist1:
+	case invslot::slotWrist1:
-	case inventory::slotHands:
+	case invslot::slotHands:
-	case inventory::slotLegs:
+	case invslot::slotLegs:
-	case inventory::slotFeet:
+	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;
+	_type_index = invtype::TYPE_INVALID;
-	_slot_index = inventory::slotInvalid;
+	_slot_index = invslot::SLOT_INVALID;
-	_container_index = inventory::containerInvalid;
+	_container_index = invbag::SLOT_INVALID;
-	_socket_index = inventory::socketInvalid;
+	_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() : _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(inventory::slotInvalid), _container_index(inventory::containerInvalid), _socket_index(inventory::socketInvalid), _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(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(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(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(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 SetTypeInvalid() { _type_index = invtype::TYPE_INVALID; }
-		void SetSlotInvalid() { _slot_index = inventory::slotInvalid; }
+		void SetSlotInvalid() { _slot_index = invslot::SLOT_INVALID; }
-		void SetContainerInvalid() { _container_index = inventory::containerInvalid; }
+		void SetContainerInvalid() { _container_index = invbag::SLOT_INVALID; }
-		void SetSocketInvalid() { _socket_index = inventory::socketInvalid; }
+		void SetSocketInvalid() { _socket_index = invaug::SOCKET_INVALID; }
 
-		void SetTypeBegin() { _type_index = inventory::typeBegin; }
+		void SetTypeBegin() { _type_index = invtype::TYPE_BEGIN; }
-		void SetSlotBegin() { _slot_index = inventory::slotBegin; }
+		void SetSlotBegin() { _slot_index = invslot::SLOT_BEGIN; }
-		void SetContainerBegin() { _container_index = inventory::containerBegin; }
+		void SetContainerBegin() { _container_index = invbag::SLOT_BEGIN; }
-		void SetSocketBegin() { _socket_index = inventory::socketBegin; }
+		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	AugSlotType[invaug::SOCKET_COUNT];	// RoF: Augment Slot 1-6 Type
-		uint8	AugSlotVisible[inventory::SocketCount];	// RoF: Augment Slot 1-6 Visible
+		uint8	AugSlotVisible[invaug::SOCKET_COUNT];	// RoF: Augment Slot 1-6 Visible
-		uint8	AugSlotUnk2[inventory::SocketCount];	// RoF: Augment Slot 1-6 Unknown Most likely Powersource related
+		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 (slot_id == invslot::SLOT_POWER_SOURCE) { use_slot = invslot::slotGeneral1; }
-	if ((uint16)slot_id <= legacy::EQUIPMENT_END) { use_slot = slot_id; }
+	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;
+	int index = invslot::EQUIPMENT_BEGIN;
-	for (; index <= inventory::slotGeneral1; ++index) { // MainGeneral1 should be legacy::EQUIPMENT_END
+	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;
+	int index = invaug::SOCKET_BEGIN;
-	for (; index < inventory::SocketCount; ++index) {
+	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 == invslot::SLOT_POWER_SOURCE && (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 && 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/net/console_server_connection.cpp

@@ -1,9 +1,9 @@
 #include "console_server.h"
-#include "../common/util/uuid.h"
+#include "../util/uuid.h"
-#include "../common/net/packet.h"
+#include "../net/packet.h"
-#include "../common/eqemu_logsys.h"
+#include "../eqemu_logsys.h"
-#include "../common/servertalk.h"
+#include "../servertalk.h"
-#include "../common/rulesys.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::steady_clock::time_point Timestamp;
-		typedef std::chrono::high_resolution_clock Clock;
+		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)
+			if (slot_id_in >= EQEmu::invslot::GENERAL_BEGIN && slot_id_in <= EQEmu::invslot::GENERAL_END)
-				SubSlotNumber = (((slot_id_in + 3) * EQEmu::inventory::ContainerCount) + index + 1);
+				SubSlotNumber = (((slot_id_in + 3) * EQEmu::invbag::SLOT_COUNT) + index + 1);
-			else if (slot_id_in >= EQEmu::legacy::BANK_BEGIN && slot_id_in <= EQEmu::legacy::BANK_END)
+			else if (slot_id_in >= EQEmu::invslot::BANK_BEGIN && slot_id_in <= EQEmu::invslot::BANK_END)
-				SubSlotNumber = (((slot_id_in - EQEmu::legacy::BANK_BEGIN) * EQEmu::inventory::ContainerCount) + EQEmu::legacy::BANK_BAGS_BEGIN + index);
+				SubSlotNumber = (((slot_id_in - EQEmu::invslot::BANK_BEGIN) * EQEmu::invbag::SLOT_COUNT) + EQEmu::invbag::BANK_BAGS_BEGIN + index);
-			else if (slot_id_in >= EQEmu::legacy::SHARED_BANK_BEGIN && slot_id_in <= EQEmu::legacy::SHARED_BANK_END)
+			else if (slot_id_in >= EQEmu::invslot::SHARED_BANK_BEGIN && slot_id_in <= EQEmu::invslot::SHARED_BANK_END)
-				SubSlotNumber = (((slot_id_in - EQEmu::legacy::SHARED_BANK_BEGIN) * EQEmu::inventory::ContainerCount) + EQEmu::legacy::SHARED_BANK_BAGS_BEGIN + index);
+				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
+		if (serverSlot < 56 || serverSlot == EQEmu::invslot::SLOT_POWER_SOURCE) { // Main Inventory and Cursor
-			RoFSlot.Type = invtype::InvTypePossessions;
+			RoFSlot.Type = invtype::typePossessions;
 			RoFSlot.Slot = serverSlot;
 
-			if (serverSlot == EQEmu::inventory::slotPowerSource)
+			if (serverSlot == EQEmu::invslot::SLOT_POWER_SOURCE)
-				RoFSlot.Slot = invslot::PossessionsPowerSource;
+				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)
+		else if (serverSlot >= EQEmu::invbag::GENERAL_BAGS_BEGIN && serverSlot <= EQEmu::invbag::CURSOR_BAG_END) { // (> 250 && < 341)
-			RoFSlot.Type = invtype::InvTypePossessions;
+			RoFSlot.Type = invtype::typePossessions;
 			TempSlot = serverSlot - 1;
-			RoFSlot.Slot = int(TempSlot / EQEmu::inventory::ContainerCount) - 2;
+			RoFSlot.Slot = int(TempSlot / EQEmu::invbag::SLOT_COUNT) - 2;
-			RoFSlot.SubIndex = TempSlot - ((RoFSlot.Slot + 2) * EQEmu::inventory::ContainerCount);
+			RoFSlot.SubIndex = TempSlot - ((RoFSlot.Slot + 2) * EQEmu::invbag::SLOT_COUNT);
 
-			if (RoFSlot.Slot >= invslot::PossessionsGeneral9) // (> 30)
+			if (RoFSlot.Slot >= invslot::slotGeneral9) // (> 30)
-				RoFSlot.Slot = invslot::PossessionsCursor;
+				RoFSlot.Slot = invslot::slotCursor;
 		}
 
-		else if (serverSlot >= EQEmu::legacy::TRIBUTE_BEGIN && serverSlot <= EQEmu::legacy::TRIBUTE_END) { // Tribute
+		else if (serverSlot >= EQEmu::invslot::TRIBUTE_BEGIN && serverSlot <= EQEmu::invslot::TRIBUTE_END) { // Tribute
-			RoFSlot.Type = invtype::InvTypeTribute;
+			RoFSlot.Type = invtype::typeTribute;
-			RoFSlot.Slot = serverSlot - EQEmu::legacy::TRIBUTE_BEGIN;
+			RoFSlot.Slot = serverSlot - EQEmu::invslot::TRIBUTE_BEGIN;
 		}
 
-		else if (serverSlot >= EQEmu::legacy::BANK_BEGIN && serverSlot <= EQEmu::legacy::BANK_BAGS_END) {
+		else if (serverSlot >= EQEmu::invslot::BANK_BEGIN && serverSlot <= EQEmu::invbag::BANK_BAGS_END) {
-			RoFSlot.Type = invtype::InvTypeBank;
+			RoFSlot.Type = invtype::typeBank;
-			TempSlot = serverSlot - EQEmu::legacy::BANK_BEGIN;
+			TempSlot = serverSlot - EQEmu::invslot::BANK_BEGIN;
 			RoFSlot.Slot = TempSlot;
 
 			if (TempSlot > 30) { // (> 30)
-				RoFSlot.Slot = int(TempSlot / EQEmu::inventory::ContainerCount) - 3;
+				RoFSlot.Slot = int(TempSlot / EQEmu::invbag::SLOT_COUNT) - 3;
-				RoFSlot.SubIndex = TempSlot - ((RoFSlot.Slot + 3) * EQEmu::inventory::ContainerCount);
+				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) {
+		else if (serverSlot >= EQEmu::invslot::SHARED_BANK_BEGIN && serverSlot <= EQEmu::invbag::SHARED_BANK_BAGS_END) {
-			RoFSlot.Type = invtype::InvTypeSharedBank;
+			RoFSlot.Type = invtype::typeSharedBank;
-			TempSlot = serverSlot - EQEmu::legacy::SHARED_BANK_BEGIN;
+			TempSlot = serverSlot - EQEmu::invslot::SHARED_BANK_BEGIN;
 			RoFSlot.Slot = TempSlot;
 
 			if (TempSlot > 30) { // (> 30)
-				RoFSlot.Slot = int(TempSlot / EQEmu::inventory::ContainerCount) - 3;
+				RoFSlot.Slot = int(TempSlot / EQEmu::invbag::SLOT_COUNT) - 3;
-				RoFSlot.SubIndex = TempSlot - ((RoFSlot.Slot + 3) * EQEmu::inventory::ContainerCount);
+				RoFSlot.SubIndex = TempSlot - ((RoFSlot.Slot + 3) * EQEmu::invbag::SLOT_COUNT);
 			}
 		}
 
-		else if (serverSlot >= EQEmu::legacy::TRADE_BEGIN && serverSlot <= EQEmu::legacy::TRADE_BAGS_END) {
+		else if (serverSlot >= EQEmu::invslot::TRADE_BEGIN && serverSlot <= EQEmu::invbag::TRADE_BAGS_END) {
-			RoFSlot.Type = invtype::InvTypeTrade;
+			RoFSlot.Type = invtype::typeTrade;
-			TempSlot = serverSlot - EQEmu::legacy::TRADE_BEGIN;
+			TempSlot = serverSlot - EQEmu::invslot::TRADE_BEGIN;
 			RoFSlot.Slot = TempSlot;
 
 			if (TempSlot > 30) {
-				RoFSlot.Slot = int(TempSlot / EQEmu::inventory::ContainerCount) - 3;
+				RoFSlot.Slot = int(TempSlot / EQEmu::invbag::SLOT_COUNT) - 3;
-				RoFSlot.SubIndex = TempSlot - ((RoFSlot.Slot + 3) * EQEmu::inventory::ContainerCount);
+				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) {
+		else if (serverSlot >= EQEmu::invslot::WORLD_BEGIN && serverSlot <= EQEmu::invslot::WORLD_END) {
-			RoFSlot.Type = invtype::InvTypeWorld;
+			RoFSlot.Type = invtype::typeWorld;
-			TempSlot = serverSlot - EQEmu::legacy::WORLD_BEGIN;
+			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)
+			if (serverSlot == EQEmu::invslot::SLOT_POWER_SOURCE)
-				RoFSlot.Slot = invslot::PossessionsPowerSource;
+				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.Slot = int(TempSlot / EQEmu::invbag::SLOT_COUNT) - 2;
-			RoFSlot.SubIndex = TempSlot - ((RoFSlot.Slot + 2) * EQEmu::inventory::ContainerCount);
+			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.Type == invtype::typePossessions && rofSlot.Slot < 57) { // Worn/Personal Inventory and Cursor (< 51)
-			if (rofSlot.Slot == invslot::PossessionsPowerSource)
+			if (rofSlot.Slot == invslot::slotPowerSource)
-				TempSlot = EQEmu::inventory::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
+			if (rofSlot.SubIndex >= EQEmu::invbag::SLOT_BEGIN) // Bag Slots
-				TempSlot = ((TempSlot + 3) * EQEmu::inventory::ContainerCount) + rofSlot.SubIndex + 1;
+				TempSlot = ((TempSlot + 3) * EQEmu::invbag::SLOT_COUNT) + rofSlot.SubIndex + 1;
 
 			ServerSlot = TempSlot;
 		}
 
-		else if (rofSlot.Type == invtype::InvTypeBank) {
+		else if (rofSlot.Type == invtype::typeBank) {
-			TempSlot = EQEmu::legacy::BANK_BEGIN;
+			TempSlot = EQEmu::invslot::BANK_BEGIN;
 
-			if (rofSlot.SubIndex >= EQEmu::inventory::containerBegin)
+			if (rofSlot.SubIndex >= EQEmu::invbag::SLOT_BEGIN)
-				TempSlot += ((rofSlot.Slot + 3) * EQEmu::inventory::ContainerCount) + rofSlot.SubIndex + 1;
+				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) {
+		else if (rofSlot.Type == invtype::typeSharedBank) {
-			TempSlot = EQEmu::legacy::SHARED_BANK_BEGIN;
+			TempSlot = EQEmu::invslot::SHARED_BANK_BEGIN;
 
-			if (rofSlot.SubIndex >= EQEmu::inventory::containerBegin)
+			if (rofSlot.SubIndex >= EQEmu::invbag::SLOT_BEGIN)
-				TempSlot += ((rofSlot.Slot + 3) * EQEmu::inventory::ContainerCount) + rofSlot.SubIndex + 1;
+				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) {
+		else if (rofSlot.Type == invtype::typeTrade) {
-			TempSlot = EQEmu::legacy::TRADE_BEGIN;
+			TempSlot = EQEmu::invslot::TRADE_BEGIN;
 
-			if (rofSlot.SubIndex >= EQEmu::inventory::containerBegin)
+			if (rofSlot.SubIndex >= EQEmu::invbag::SLOT_BEGIN)
-				TempSlot += ((rofSlot.Slot + 3) * EQEmu::inventory::ContainerCount) + rofSlot.SubIndex + 1;
+				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) {
+		else if (rofSlot.Type == invtype::typeWorld) {
-			TempSlot = EQEmu::legacy::WORLD_BEGIN;
+			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)
+			if (rofSlot.Slot == invslot::slotPowerSource)
-				TempSlot = EQEmu::inventory::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
+			if (rofSlot.SubIndex >= EQEmu::invbag::SLOT_BEGIN) // Bag Slots
-				TempSlot = ((TempSlot + 3) * EQEmu::inventory::ContainerCount) + rofSlot.SubIndex + 1;
+				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)
+			if (slot_id_in >= EQEmu::invslot::GENERAL_BEGIN && slot_id_in <= EQEmu::invslot::GENERAL_END)
-				SubSlotNumber = (((slot_id_in + 3) * EQEmu::inventory::ContainerCount) + index + 1);
+				SubSlotNumber = (((slot_id_in + 3) * EQEmu::invbag::SLOT_COUNT) + index + 1);
-			else if (slot_id_in >= EQEmu::legacy::BANK_BEGIN && slot_id_in <= EQEmu::legacy::BANK_END)
+			else if (slot_id_in >= EQEmu::invslot::BANK_BEGIN && slot_id_in <= EQEmu::invslot::BANK_END)
-				SubSlotNumber = (((slot_id_in - EQEmu::legacy::BANK_BEGIN) * EQEmu::inventory::ContainerCount) + EQEmu::legacy::BANK_BAGS_BEGIN + index);
+				SubSlotNumber = (((slot_id_in - EQEmu::invslot::BANK_BEGIN) * EQEmu::invbag::SLOT_COUNT) + EQEmu::invbag::BANK_BAGS_BEGIN + index);
-			else if (slot_id_in >= EQEmu::legacy::SHARED_BANK_BEGIN && slot_id_in <= EQEmu::legacy::SHARED_BANK_END)
+			else if (slot_id_in >= EQEmu::invslot::SHARED_BANK_BEGIN && slot_id_in <= EQEmu::invslot::SHARED_BANK_END)
-				SubSlotNumber = (((slot_id_in - EQEmu::legacy::SHARED_BANK_BEGIN) * EQEmu::inventory::ContainerCount) + EQEmu::legacy::SHARED_BANK_BAGS_BEGIN + index);
+				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.Type = invtype::typeCorpse;
-				RoF2Slot.Slot = serverSlot - EQEmu::legacy::CORPSE_BEGIN;
+				RoF2Slot.Slot = serverSlot - EQEmu::invslot::CORPSE_BEGIN;
 			}
 			else
 			{
-				RoF2Slot.Type = invtype::InvTypePossessions;
+				RoF2Slot.Type = invtype::typePossessions;
 				RoF2Slot.Slot = serverSlot;
 			}
 
-			if (serverSlot == EQEmu::inventory::slotPowerSource)
+			if (serverSlot == EQEmu::invslot::SLOT_POWER_SOURCE)
-				RoF2Slot.Slot = invslot::PossessionsPowerSource;
+				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)
+		else if (serverSlot >= EQEmu::invbag::GENERAL_BAGS_BEGIN && serverSlot <= EQEmu::invbag::CURSOR_BAG_END) { // (> 250 && < 341)
-			RoF2Slot.Type = invtype::InvTypePossessions;
+			RoF2Slot.Type = invtype::typePossessions;
 			TempSlot = serverSlot - 1;
-			RoF2Slot.Slot = int(TempSlot / EQEmu::inventory::ContainerCount) - 2;
+			RoF2Slot.Slot = int(TempSlot / EQEmu::invbag::SLOT_COUNT) - 2;
-			RoF2Slot.SubIndex = TempSlot - ((RoF2Slot.Slot + 2) * EQEmu::inventory::ContainerCount);
+			RoF2Slot.SubIndex = TempSlot - ((RoF2Slot.Slot + 2) * EQEmu::invbag::SLOT_COUNT);
 
-			if (RoF2Slot.Slot >= invslot::PossessionsGeneral9) // (> 30)
+			if (RoF2Slot.Slot >= invslot::slotGeneral9) // (> 30)
-				RoF2Slot.Slot = invslot::PossessionsCursor;
+				RoF2Slot.Slot = invslot::slotCursor;
 		}
 
-		else if (serverSlot >= EQEmu::legacy::TRIBUTE_BEGIN && serverSlot <= EQEmu::legacy::TRIBUTE_END) { // Tribute
+		else if (serverSlot >= EQEmu::invslot::TRIBUTE_BEGIN && serverSlot <= EQEmu::invslot::TRIBUTE_END) { // Tribute
-			RoF2Slot.Type = invtype::InvTypeTribute;
+			RoF2Slot.Type = invtype::typeTribute;
-			RoF2Slot.Slot = serverSlot - EQEmu::legacy::TRIBUTE_BEGIN;
+			RoF2Slot.Slot = serverSlot - EQEmu::invslot::TRIBUTE_BEGIN;
 		}
 
-		else if (serverSlot >= EQEmu::legacy::BANK_BEGIN && serverSlot <= EQEmu::legacy::BANK_BAGS_END) {
+		else if (serverSlot >= EQEmu::invslot::BANK_BEGIN && serverSlot <= EQEmu::invbag::BANK_BAGS_END) {
-			RoF2Slot.Type = invtype::InvTypeBank;
+			RoF2Slot.Type = invtype::typeBank;
-			TempSlot = serverSlot - EQEmu::legacy::BANK_BEGIN;
+			TempSlot = serverSlot - EQEmu::invslot::BANK_BEGIN;
 			RoF2Slot.Slot = TempSlot;
 
 			if (TempSlot > 30) { // (> 30)
-				RoF2Slot.Slot = int(TempSlot / EQEmu::inventory::ContainerCount) - 3;
+				RoF2Slot.Slot = int(TempSlot / EQEmu::invbag::SLOT_COUNT) - 3;
-				RoF2Slot.SubIndex = TempSlot - ((RoF2Slot.Slot + 3) * EQEmu::inventory::ContainerCount);
+				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) {
+		else if (serverSlot >= EQEmu::invslot::SHARED_BANK_BEGIN && serverSlot <= EQEmu::invbag::SHARED_BANK_BAGS_END) {
-			RoF2Slot.Type = invtype::InvTypeSharedBank;
+			RoF2Slot.Type = invtype::typeSharedBank;
-			TempSlot = serverSlot - EQEmu::legacy::SHARED_BANK_BEGIN;
+			TempSlot = serverSlot - EQEmu::invslot::SHARED_BANK_BEGIN;
 			RoF2Slot.Slot = TempSlot;
 
 			if (TempSlot > 30) { // (> 30)
-				RoF2Slot.Slot = int(TempSlot / EQEmu::inventory::ContainerCount) - 3;
+				RoF2Slot.Slot = int(TempSlot / EQEmu::invbag::SLOT_COUNT) - 3;
-				RoF2Slot.SubIndex = TempSlot - ((RoF2Slot.Slot + 3) * EQEmu::inventory::ContainerCount);
+				RoF2Slot.SubIndex = TempSlot - ((RoF2Slot.Slot + 3) * EQEmu::invbag::SLOT_COUNT);
 			}
 		}
 
-		else if (serverSlot >= EQEmu::legacy::TRADE_BEGIN && serverSlot <= EQEmu::legacy::TRADE_BAGS_END) {
+		else if (serverSlot >= EQEmu::invslot::TRADE_BEGIN && serverSlot <= EQEmu::invbag::TRADE_BAGS_END) {
-			RoF2Slot.Type = invtype::InvTypeTrade;
+			RoF2Slot.Type = invtype::typeTrade;
-			TempSlot = serverSlot - EQEmu::legacy::TRADE_BEGIN;
+			TempSlot = serverSlot - EQEmu::invslot::TRADE_BEGIN;
 			RoF2Slot.Slot = TempSlot;
 
 			if (TempSlot > 30) {
-				RoF2Slot.Slot = int(TempSlot / EQEmu::inventory::ContainerCount) - 3;
+				RoF2Slot.Slot = int(TempSlot / EQEmu::invbag::SLOT_COUNT) - 3;
-				RoF2Slot.SubIndex = TempSlot - ((RoF2Slot.Slot + 3) * EQEmu::inventory::ContainerCount);
+				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) {
+		else if (serverSlot >= EQEmu::invslot::WORLD_BEGIN && serverSlot <= EQEmu::invslot::WORLD_END) {
-			RoF2Slot.Type = invtype::InvTypeWorld;
+			RoF2Slot.Type = invtype::typeWorld;
-			TempSlot = serverSlot - EQEmu::legacy::WORLD_BEGIN;
+			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)
+			if (serverSlot == EQEmu::invslot::SLOT_POWER_SOURCE)
-				RoF2Slot.Slot = invslot::PossessionsPowerSource;
+				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.Slot = int(TempSlot / EQEmu::invbag::SLOT_COUNT) - 2;
-			RoF2Slot.SubIndex = TempSlot - ((RoF2Slot.Slot + 2) * EQEmu::inventory::ContainerCount);
+			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.Type == invtype::typePossessions && rof2Slot.Slot < 57) { // Worn/Personal Inventory and Cursor (< 51)
-			if (rof2Slot.Slot == invslot::PossessionsPowerSource)
+			if (rof2Slot.Slot == invslot::slotPowerSource)
-				TempSlot = EQEmu::inventory::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
+			if (rof2Slot.SubIndex >= EQEmu::invbag::SLOT_BEGIN) // Bag Slots
-				TempSlot = ((TempSlot + 3) * EQEmu::inventory::ContainerCount) + rof2Slot.SubIndex + 1;
+				TempSlot = ((TempSlot + 3) * EQEmu::invbag::SLOT_COUNT) + rof2Slot.SubIndex + 1;
 
 			ServerSlot = TempSlot;
 		}
 
-		else if (rof2Slot.Type == invtype::InvTypeBank) {
+		else if (rof2Slot.Type == invtype::typeBank) {
-			TempSlot = EQEmu::legacy::BANK_BEGIN;
+			TempSlot = EQEmu::invslot::BANK_BEGIN;
 
-			if (rof2Slot.SubIndex >= EQEmu::inventory::containerBegin)
+			if (rof2Slot.SubIndex >= EQEmu::invbag::SLOT_BEGIN)
-				TempSlot += ((rof2Slot.Slot + 3) * EQEmu::inventory::ContainerCount) + rof2Slot.SubIndex + 1;
+				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) {
+		else if (rof2Slot.Type == invtype::typeSharedBank) {
-			TempSlot = EQEmu::legacy::SHARED_BANK_BEGIN;
+			TempSlot = EQEmu::invslot::SHARED_BANK_BEGIN;
 
-			if (rof2Slot.SubIndex >= EQEmu::inventory::containerBegin)
+			if (rof2Slot.SubIndex >= EQEmu::invbag::SLOT_BEGIN)
-				TempSlot += ((rof2Slot.Slot + 3) * EQEmu::inventory::ContainerCount) + rof2Slot.SubIndex + 1;
+				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) {
+		else if (rof2Slot.Type == invtype::typeTrade) {
-			TempSlot = EQEmu::legacy::TRADE_BEGIN;
+			TempSlot = EQEmu::invslot::TRADE_BEGIN;
 
-			if (rof2Slot.SubIndex >= EQEmu::inventory::containerBegin)
+			if (rof2Slot.SubIndex >= EQEmu::invbag::SLOT_BEGIN)
-				TempSlot += ((rof2Slot.Slot + 3) * EQEmu::inventory::ContainerCount) + rof2Slot.SubIndex + 1;
+				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) {
+		else if (rof2Slot.Type == invtype::typeWorld) {
-			TempSlot = EQEmu::legacy::WORLD_BEGIN;
+			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) {
+		else if (rof2Slot.Type == invtype::typeCorpse) {
-			ServerSlot = rof2Slot.Slot + EQEmu::legacy::CORPSE_BEGIN;
+			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)
+			if (rof2Slot.Slot == invslot::slotPowerSource)
-				TempSlot = EQEmu::inventory::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
+			if (rof2Slot.SubIndex >= EQEmu::invbag::SLOT_BEGIN) // Bag Slots
-				TempSlot = ((TempSlot + 3) * EQEmu::inventory::ContainerCount) + rof2Slot.SubIndex + 1;
+				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:
+	case invtype::typePossessions:
-		return invtype::InvTypePossessionsSize;
+		return invtype::POSSESSIONS_SIZE;
-	case invtype::InvTypeBank:
+	case invtype::typeBank:
-		return invtype::InvTypeBankSize;
+		return invtype::BANK_SIZE;
-	case invtype::InvTypeSharedBank:
+	case invtype::typeSharedBank:
-		return invtype::InvTypeSharedBankSize;
+		return invtype::SHARED_BANK_SIZE;
-	case invtype::InvTypeTrade:
+	case invtype::typeTrade:
-		return invtype::InvTypeTradeSize;
+		return invtype::TRADE_SIZE;
-	case invtype::InvTypeWorld:
+	case invtype::typeWorld:
-		return invtype::InvTypeWorldSize;
+		return invtype::WORLD_SIZE;
-	case invtype::InvTypeLimbo:
+	case invtype::typeLimbo:
-		return invtype::InvTypeLimboSize;
+		return invtype::LIMBO_SIZE;
-	case invtype::InvTypeTribute:
+	case invtype::typeTribute:
-		return invtype::InvTypeTributeSize;
+		return invtype::TRIBUTE_SIZE;
-	case invtype::InvTypeTrophyTribute:
+	case invtype::typeTrophyTribute:
-		return invtype::InvTypeTrophyTributeSize;
+		return invtype::TROPHY_TRIBUTE_SIZE;
-	case invtype::InvTypeGuildTribute:
+	case invtype::typeGuildTribute:
-		return invtype::InvTypeGuildTributeSize;
+		return invtype::GUILD_TRIBUTE_SIZE;
-	case invtype::InvTypeMerchant:
+	case invtype::typeMerchant:
-		return invtype::InvTypeMerchantSize;
+		return invtype::MERCHANT_SIZE;
-	case invtype::InvTypeDeleted:
+	case invtype::typeDeleted:
-		return invtype::InvTypeDeletedSize;
+		return invtype::DELETED_SIZE;
-	case invtype::InvTypeCorpse:
+	case invtype::typeCorpse:
-		return invtype::InvTypeCorpseSize;
+		return invtype::CORPSE_SIZE;
-	case invtype::InvTypeBazaar:
+	case invtype::typeBazaar:
-		return invtype::InvTypeBazaarSize;
+		return invtype::BAZAAR_SIZE;
-	case invtype::InvTypeInspect:
+	case invtype::typeInspect:
-		return invtype::InvTypeInspectSize;
+		return invtype::INSPECT_SIZE;
-	case invtype::InvTypeRealEstate:
+	case invtype::typeRealEstate:
-		return invtype::InvTypeRealEstateSize;
+		return invtype::REAL_ESTATE_SIZE;
-	case invtype::InvTypeViewMODPC:
+	case invtype::typeViewMODPC:
-		return invtype::InvTypeViewMODPCSize;
+		return invtype::VIEW_MOD_PC_SIZE;
-	case invtype::InvTypeViewMODBank:
+	case invtype::typeViewMODBank:
-		return invtype::InvTypeViewMODBankSize;
+		return invtype::VIEW_MOD_BANK_SIZE;
-	case invtype::InvTypeViewMODSharedBank:
+	case invtype::typeViewMODSharedBank:
-		return invtype::InvTypeViewMODSharedBankSize;
+		return invtype::VIEW_MOD_SHARED_BANK_SIZE;
-	case invtype::InvTypeViewMODLimbo:
+	case invtype::typeViewMODLimbo:
-		return invtype::InvTypeViewMODLimboSize;
+		return invtype::VIEW_MOD_LIMBO_SIZE;
-	case invtype::InvTypeAltStorage:
+	case invtype::typeAltStorage:
-		return invtype::InvTypeAltStorageSize;
+		return invtype::ALT_STORAGE_SIZE;
-	case invtype::InvTypeArchived:
+	case invtype::typeArchived:
-		return invtype::InvTypeArchivedSize;
+		return invtype::ARCHIVED_SIZE;
-	case invtype::InvTypeMail:
+	case invtype::typeMail:
-		return invtype::InvTypeMailSize;
+		return invtype::MAIL_SIZE;
-	case invtype::InvTypeGuildTrophyTribute:
+	case invtype::typeGuildTrophyTribute:
-		return invtype::InvTypeGuildTrophyTributeSize;
+		return invtype::GUILD_TROPHY_TRIBUTE_SIZE;
-	case invtype::InvTypeKrono:
+	case invtype::typeKrono:
-		return invtype::InvTypeKronoSize;
+		return invtype::KRONO_SIZE;
-	case invtype::InvTypeOther:
+	case invtype::typeOther:
-		return invtype::InvTypeOtherSize;
+		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::typePossessions:
-	case invtype::InvTypeBank:
+	case invtype::typeBank:
-	case invtype::InvTypeSharedBank:
+	case invtype::typeSharedBank:
-	case invtype::InvTypeTrade:
+	case invtype::typeTrade:
-	case invtype::InvTypeWorld:
+	case invtype::typeWorld:
-	case invtype::InvTypeLimbo:
+	case invtype::typeLimbo:
-	case invtype::InvTypeTribute:
+	case invtype::typeTribute:
-	case invtype::InvTypeTrophyTribute:
+	case invtype::typeTrophyTribute:
-	case invtype::InvTypeGuildTribute:
+	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 {
+		} // namespace enum_
-			InvTypePossessions = InvTypeBegin,
+		using namespace enum_;
-			InvTypeBank,
+
-			InvTypeSharedBank,
+		const int16 POSSESSIONS_SIZE = 34;
-			InvTypeTrade,
+		const int16 BANK_SIZE = 24;
-			InvTypeWorld,
+		const int16 SHARED_BANK_SIZE = 2;
-			InvTypeLimbo,
+		const int16 TRADE_SIZE = 8;
-			InvTypeTribute,
+		const int16 WORLD_SIZE = 10;
-			InvTypeTrophyTribute,
+		const int16 LIMBO_SIZE = 36;
-			InvTypeGuildTribute,
+		const int16 TRIBUTE_SIZE = 5;
-			InvTypeMerchant,
+		const int16 TROPHY_TRIBUTE_SIZE = 0;//unknown
-			InvTypeDeleted,
+		const int16 GUILD_TRIBUTE_SIZE = 2;//unverified
-			InvTypeCorpse,
+		const int16 MERCHANT_SIZE = 200;
-			InvTypeBazaar,
+		const int16 DELETED_SIZE = 0;//unknown - "Recovery Tab"
-			InvTypeInspect,
+		const int16 CORPSE_SIZE = POSSESSIONS_SIZE;
-			InvTypeRealEstate,
+		const int16 BAZAAR_SIZE = 200;
-			InvTypeViewMODPC,
+		const int16 INSPECT_SIZE = 23;
-			InvTypeViewMODBank,
+		const int16 REAL_ESTATE_SIZE = 0;//unknown
-			InvTypeViewMODSharedBank,
+		const int16 VIEW_MOD_PC_SIZE = POSSESSIONS_SIZE;
-			InvTypeViewMODLimbo,
+		const int16 VIEW_MOD_BANK_SIZE = BANK_SIZE;
-			InvTypeAltStorage,
+		const int16 VIEW_MOD_SHARED_BANK_SIZE = SHARED_BANK_SIZE;
-			InvTypeArchived,
+		const int16 VIEW_MOD_LIMBO_SIZE = LIMBO_SIZE;
-			InvTypeMail,
+		const int16 ALT_STORAGE_SIZE = 0;//unknown - "Shroud Bank"
-			InvTypeGuildTrophyTribute,
+		const int16 ARCHIVED_SIZE = 0;//unknown
-			InvTypeKrono,
+		const int16 MAIL_SIZE = 0;//unknown
-			InvTypeOther,
+		const int16 GUILD_TROPHY_TRIBUTE_SIZE = 0;//unknown
-			InvTypeCount
+		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 {
+		} // namespace enum_
-			PossessionsCharm = InvSlotBegin,
+		using namespace enum_;
-			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
-		};
 
-		const int EquipmentBegin = PossessionsCharm;
+		const int16 SLOT_INVALID = IINVALID;
-		const int EquipmentEnd = PossessionsAmmo;
+		const int16 SLOT_BEGIN = INULL;
-		const int EquipmentCount = (EquipmentEnd - EquipmentBegin + 1);
 
-		const int GeneralBegin = PossessionsGeneral1;
+		const int16 POSSESSIONS_BEGIN = slotCharm;
-		const int GeneralEnd = PossessionsGeneral10;
+		const int16 POSSESSIONS_END = slotCursor;
-		const int GeneralCount = (GeneralEnd - GeneralBegin + 1);
+		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 {
+		const size_t SAY_LINK_BODY_SIZE = 56;
-		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 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

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:
+	case invtype::typePossessions:
-		return invtype::InvTypePossessionsSize;
+		return invtype::POSSESSIONS_SIZE;
-	case invtype::InvTypeBank:
+	case invtype::typeBank:
-		return invtype::InvTypeBankSize;
+		return invtype::BANK_SIZE;
-	case invtype::InvTypeSharedBank:
+	case invtype::typeSharedBank:
-		return invtype::InvTypeSharedBankSize;
+		return invtype::SHARED_BANK_SIZE;
-	case invtype::InvTypeTrade:
+	case invtype::typeTrade:
-		return invtype::InvTypeTradeSize;
+		return invtype::TRADE_SIZE;
-	case invtype::InvTypeWorld:
+	case invtype::typeWorld:
-		return invtype::InvTypeWorldSize;
+		return invtype::WORLD_SIZE;
-	case invtype::InvTypeLimbo:
+	case invtype::typeLimbo:
-		return invtype::InvTypeLimboSize;
+		return invtype::LIMBO_SIZE;
-	case invtype::InvTypeTribute:
+	case invtype::typeTribute:
-		return invtype::InvTypeTributeSize;
+		return invtype::TRIBUTE_SIZE;
-	case invtype::InvTypeTrophyTribute:
+	case invtype::typeTrophyTribute:
-		return invtype::InvTypeTrophyTributeSize;
+		return invtype::TROPHY_TRIBUTE_SIZE;
-	case invtype::InvTypeGuildTribute:
+	case invtype::typeGuildTribute:
-		return invtype::InvTypeGuildTributeSize;
+		return invtype::GUILD_TRIBUTE_SIZE;
-	case invtype::InvTypeMerchant:
+	case invtype::typeMerchant:
-		return invtype::InvTypeMerchantSize;
+		return invtype::MERCHANT_SIZE;
-	case invtype::InvTypeDeleted:
+	case invtype::typeDeleted:
-		return invtype::InvTypeDeletedSize;
+		return invtype::DELETED_SIZE;
-	case invtype::InvTypeCorpse:
+	case invtype::typeCorpse:
-		return invtype::InvTypeCorpseSize;
+		return invtype::CORPSE_SIZE;
-	case invtype::InvTypeBazaar:
+	case invtype::typeBazaar:
-		return invtype::InvTypeBazaarSize;
+		return invtype::BAZAAR_SIZE;
-	case invtype::InvTypeInspect:
+	case invtype::typeInspect:
-		return invtype::InvTypeInspectSize;
+		return invtype::INSPECT_SIZE;
-	case invtype::InvTypeRealEstate:
+	case invtype::typeRealEstate:
-		return invtype::InvTypeRealEstateSize;
+		return invtype::REAL_ESTATE_SIZE;
-	case invtype::InvTypeViewMODPC:
+	case invtype::typeViewMODPC:
-		return invtype::InvTypeViewMODPCSize;
+		return invtype::VIEW_MOD_PC_SIZE;
-	case invtype::InvTypeViewMODBank:
+	case invtype::typeViewMODBank:
-		return invtype::InvTypeViewMODBankSize;
+		return invtype::VIEW_MOD_BANK_SIZE;
-	case invtype::InvTypeViewMODSharedBank:
+	case invtype::typeViewMODSharedBank:
-		return invtype::InvTypeViewMODSharedBankSize;
+		return invtype::VIEW_MOD_SHARED_BANK_SIZE;
-	case invtype::InvTypeViewMODLimbo:
+	case invtype::typeViewMODLimbo:
-		return invtype::InvTypeViewMODLimboSize;
+		return invtype::VIEW_MOD_LIMBO_SIZE;
-	case invtype::InvTypeAltStorage:
+	case invtype::typeAltStorage:
-		return invtype::InvTypeAltStorageSize;
+		return invtype::ALT_STORAGE_SIZE;
-	case invtype::InvTypeArchived:
+	case invtype::typeArchived:
-		return invtype::InvTypeArchivedSize;
+		return invtype::ARCHIVED_SIZE;
-	case invtype::InvTypeMail:
+	case invtype::typeMail:
-		return invtype::InvTypeMailSize;
+		return invtype::MAIL_SIZE;
-	case invtype::InvTypeGuildTrophyTribute:
+	case invtype::typeGuildTrophyTribute:
-		return invtype::InvTypeGuildTrophyTributeSize;
+		return invtype::GUILD_TROPHY_TRIBUTE_SIZE;
-	case invtype::InvTypeOther:
+	case invtype::typeOther:
-		return invtype::InvTypeOtherSize;
+		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::typePossessions:
-	case invtype::InvTypeBank:
+	case invtype::typeBank:
-	case invtype::InvTypeSharedBank:
+	case invtype::typeSharedBank:
-	case invtype::InvTypeTrade:
+	case invtype::typeTrade:
-	case invtype::InvTypeWorld:
+	case invtype::typeWorld:
-	case invtype::InvTypeLimbo:
+	case invtype::typeLimbo:
-	case invtype::InvTypeTribute:
+	case invtype::typeTribute:
-	case invtype::InvTypeTrophyTribute:
+	case invtype::typeTrophyTribute:
-	case invtype::InvTypeGuildTribute:
+	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 {
+		} // namespace enum_
-			InvTypePossessions = InvTypeBegin,
+		using namespace enum_;
-			InvTypeBank,
+
-			InvTypeSharedBank,
+		const int16 POSSESSIONS_SIZE = 34;
-			InvTypeTrade,
+		const int16 BANK_SIZE = 24;
-			InvTypeWorld,
+		const int16 SHARED_BANK_SIZE = 2;
-			InvTypeLimbo,
+		const int16 TRADE_SIZE = 8;
-			InvTypeTribute,
+		const int16 WORLD_SIZE = 10;
-			InvTypeTrophyTribute,
+		const int16 LIMBO_SIZE = 36;
-			InvTypeGuildTribute,
+		const int16 TRIBUTE_SIZE = 5;
-			InvTypeMerchant,
+		const int16 TROPHY_TRIBUTE_SIZE = 0;//unknown
-			InvTypeDeleted,
+		const int16 GUILD_TRIBUTE_SIZE = 2;//unverified
-			InvTypeCorpse,
+		const int16 MERCHANT_SIZE = 200;
-			InvTypeBazaar,
+		const int16 DELETED_SIZE = 0;//unknown - "Recovery Tab"
-			InvTypeInspect,
+		const int16 CORPSE_SIZE = POSSESSIONS_SIZE;
-			InvTypeRealEstate,
+		const int16 BAZAAR_SIZE = 200;
-			InvTypeViewMODPC,
+		const int16 INSPECT_SIZE = 23;
-			InvTypeViewMODBank,
+		const int16 REAL_ESTATE_SIZE = 0;//unknown
-			InvTypeViewMODSharedBank,
+		const int16 VIEW_MOD_PC_SIZE = POSSESSIONS_SIZE;
-			InvTypeViewMODLimbo,
+		const int16 VIEW_MOD_BANK_SIZE = BANK_SIZE;
-			InvTypeAltStorage,
+		const int16 VIEW_MOD_SHARED_BANK_SIZE = SHARED_BANK_SIZE;
-			InvTypeArchived,
+		const int16 VIEW_MOD_LIMBO_SIZE = LIMBO_SIZE;
-			InvTypeMail,
+		const int16 ALT_STORAGE_SIZE = 0;//unknown - "Shroud Bank"
-			InvTypeGuildTrophyTribute,
+		const int16 ARCHIVED_SIZE = 0;//unknown
-			InvTypeOther,
+		const int16 MAIL_SIZE = 0;//unknown
-			InvTypeCount
+		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 {
+		} // namespace enum_
-			PossessionsCharm = InvSlotBegin,
+		using namespace enum_;
-			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
-		};
 
-		const int EquipmentBegin = PossessionsCharm;
+		const int16 SLOT_INVALID = IINVALID;
-		const int EquipmentEnd = PossessionsAmmo;
+		const int16 SLOT_BEGIN = INULL;
-		const int EquipmentCount = (EquipmentEnd - EquipmentBegin + 1);
 
-		const int GeneralBegin = PossessionsGeneral1;
+		const int16 POSSESSIONS_BEGIN = slotCharm;
-		const int GeneralEnd = PossessionsGeneral10;
+		const int16 POSSESSIONS_END = slotCursor;
-		const int GeneralCount = (GeneralEnd - GeneralBegin + 1);
+		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 {
+		const size_t SAY_LINK_BODY_SIZE = 55;
-		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 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)
+			if (eq->TotalChars > constants::CHARACTER_CREATION_LIMIT)
-				eq->TotalChars = constants::CharacterCreationLimit;
+				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)
+		if (eq->TotalChars > constants::CHARACTER_CREATION_LIMIT)
-			eq->TotalChars = constants::CharacterCreationLimit;
+			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)
+			if (slot_id_in >= EQEmu::invslot::GENERAL_BEGIN && slot_id_in <= EQEmu::invslot::GENERAL_END)
-				SubSlotNumber = (((slot_id_in + 3) * EQEmu::inventory::ContainerCount) + index + 1);
+				SubSlotNumber = (((slot_id_in + 3) * EQEmu::invbag::SLOT_COUNT) + index + 1);
-			else if (slot_id_in >= EQEmu::legacy::BANK_BEGIN && slot_id_in <= EQEmu::legacy::BANK_END)
+			else if (slot_id_in >= EQEmu::invslot::BANK_BEGIN && slot_id_in <= EQEmu::invslot::BANK_END)
-				SubSlotNumber = (((slot_id_in - EQEmu::legacy::BANK_BEGIN) * EQEmu::inventory::ContainerCount) + EQEmu::legacy::BANK_BAGS_BEGIN + index);
+				SubSlotNumber = (((slot_id_in - EQEmu::invslot::BANK_BEGIN) * EQEmu::invbag::SLOT_COUNT) + EQEmu::invbag::BANK_BAGS_BEGIN + index);
-			else if (slot_id_in >= EQEmu::legacy::SHARED_BANK_BEGIN && slot_id_in <= EQEmu::legacy::SHARED_BANK_END)
+			else if (slot_id_in >= EQEmu::invslot::SHARED_BANK_BEGIN && slot_id_in <= EQEmu::invslot::SHARED_BANK_END)
-				SubSlotNumber = (((slot_id_in - EQEmu::legacy::SHARED_BANK_BEGIN) * EQEmu::inventory::ContainerCount) + EQEmu::legacy::SHARED_BANK_BAGS_BEGIN + index);
+				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)
+		else if (serverSlot == EQEmu::invslot::SLOT_POWER_SOURCE)
-			SoDSlot = invslot::PossessionsPowerSource;
+			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)
+		else if (sodSlot == invslot::slotPowerSource)
-			ServerSlot = EQEmu::inventory::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:
+	case invtype::typePossessions:
-		return invtype::InvTypePossessionsSize;
+		return invtype::POSSESSIONS_SIZE;
-	case invtype::InvTypeBank:
+	case invtype::typeBank:
-		return invtype::InvTypeBankSize;
+		return invtype::BANK_SIZE;
-	case invtype::InvTypeSharedBank:
+	case invtype::typeSharedBank:
-		return invtype::InvTypeSharedBankSize;
+		return invtype::SHARED_BANK_SIZE;
-	case invtype::InvTypeTrade:
+	case invtype::typeTrade:
-		return invtype::InvTypeTradeSize;
+		return invtype::TRADE_SIZE;
-	case invtype::InvTypeWorld:
+	case invtype::typeWorld:
-		return invtype::InvTypeWorldSize;
+		return invtype::WORLD_SIZE;
-	case invtype::InvTypeLimbo:
+	case invtype::typeLimbo:
-		return invtype::InvTypeLimboSize;
+		return invtype::LIMBO_SIZE;
-	case invtype::InvTypeTribute:
+	case invtype::typeTribute:
-		return invtype::InvTypeTributeSize;
+		return invtype::TRIBUTE_SIZE;
-	case invtype::InvTypeGuildTribute:
+	case invtype::typeGuildTribute:
-		return invtype::InvTypeGuildTributeSize;
+		return invtype::GUILD_TRIBUTE_SIZE;
-	case invtype::InvTypeMerchant:
+	case invtype::typeMerchant:
-		return invtype::InvTypeMerchantSize;
+		return invtype::MERCHANT_SIZE;
-	case invtype::InvTypeCorpse:
+	case invtype::typeCorpse:
-		return invtype::InvTypeCorpseSize;
+		return invtype::CORPSE_SIZE;
-	case invtype::InvTypeBazaar:
+	case invtype::typeBazaar:
-		return invtype::InvTypeBazaarSize;
+		return invtype::BAZAAR_SIZE;
-	case invtype::InvTypeInspect:
+	case invtype::typeInspect:
-		return invtype::InvTypeInspectSize;
+		return invtype::INSPECT_SIZE;
-	case invtype::InvTypeViewMODPC:
+	case invtype::typeViewMODPC:
-		return invtype::InvTypeViewMODPCSize;
+		return invtype::VIEW_MOD_PC_SIZE;
-	case invtype::InvTypeViewMODBank:
+	case invtype::typeViewMODBank:
-		return invtype::InvTypeViewMODBankSize;
+		return invtype::VIEW_MOD_BANK_SIZE;
-	case invtype::InvTypeViewMODSharedBank:
+	case invtype::typeViewMODSharedBank:
-		return invtype::InvTypeViewMODSharedBankSize;
+		return invtype::VIEW_MOD_SHARED_BANK_SIZE;
-	case invtype::InvTypeViewMODLimbo:
+	case invtype::typeViewMODLimbo:
-		return invtype::InvTypeViewMODLimboSize;
+		return invtype::VIEW_MOD_LIMBO_SIZE;
-	case invtype::InvTypeAltStorage:
+	case invtype::typeAltStorage:
-		return invtype::InvTypeAltStorageSize;
+		return invtype::ALT_STORAGE_SIZE;
-	case invtype::InvTypeArchived:
+	case invtype::typeArchived:
-		return invtype::InvTypeArchivedSize;
+		return invtype::ARCHIVED_SIZE;
-	case invtype::InvTypeOther:
+	case invtype::typeOther:
-		return invtype::InvTypeOtherSize;
+		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::typePossessions:
-	case invtype::InvTypeBank:
+	case invtype::typeBank:
-	case invtype::InvTypeSharedBank:
+	case invtype::typeSharedBank:
-	case invtype::InvTypeTrade:
+	case invtype::typeTrade:
-	case invtype::InvTypeWorld:
+	case invtype::typeWorld:
-	case invtype::InvTypeLimbo:
+	case invtype::typeLimbo:
-	case invtype::InvTypeTribute:
+	case invtype::typeTribute:
-	case invtype::InvTypeGuildTribute:
+	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 {
+		} // namespace enum_
-			InvTypePossessions = InvTypeBegin,
+		using namespace enum_;
-			InvTypeBank,
+
-			InvTypeSharedBank,
+		const int16 POSSESSIONS_SIZE = 32;
-			InvTypeTrade,
+		const int16 BANK_SIZE = 24;
-			InvTypeWorld,
+		const int16 SHARED_BANK_SIZE = 2;
-			InvTypeLimbo,
+		const int16 TRADE_SIZE = 8;
-			InvTypeTribute,
+		const int16 WORLD_SIZE = 10;
-			InvTypeGuildTribute,
+		const int16 LIMBO_SIZE = 36;
-			InvTypeMerchant,
+		const int16 TRIBUTE_SIZE = 5;
-			InvTypeCorpse,
+		const int16 GUILD_TRIBUTE_SIZE = 2;
-			InvTypeBazaar,
+		const int16 MERCHANT_SIZE = 80;
-			InvTypeInspect,
+		const int16 CORPSE_SIZE = POSSESSIONS_SIZE;
-			InvTypeViewMODPC,
+		const int16 BAZAAR_SIZE = 80;
-			InvTypeViewMODBank,
+		const int16 INSPECT_SIZE = 23;
-			InvTypeViewMODSharedBank,
+		const int16 VIEW_MOD_PC_SIZE = POSSESSIONS_SIZE;
-			InvTypeViewMODLimbo,
+		const int16 VIEW_MOD_BANK_SIZE = BANK_SIZE;
-			InvTypeAltStorage,
+		const int16 VIEW_MOD_SHARED_BANK_SIZE = SHARED_BANK_SIZE;
-			InvTypeArchived,
+		const int16 VIEW_MOD_LIMBO_SIZE = LIMBO_SIZE;
-			InvTypeOther,
+		const int16 ALT_STORAGE_SIZE = 0;//unknown - "Shroud Bank"
-			InvTypeCount
+		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 {
+		} // namespace enum_
-			PossessionsCharm = InvSlotBegin,
+		using namespace enum_;
-			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
-		};
 
-		const int EquipmentBegin = PossessionsCharm;
+		const int16 SLOT_INVALID = IINVALID;
-		const int EquipmentEnd = PossessionsAmmo;
+		const int16 SLOT_BEGIN = INULL;
-		const int EquipmentCount = (EquipmentEnd - EquipmentBegin + 1);
 
-		const int GeneralBegin = PossessionsGeneral1;
+		const int16 POSSESSIONS_BEGIN = slotCharm;
-		const int GeneralEnd = PossessionsGeneral8;
+		const int16 POSSESSIONS_END = slotCursor;
-		const int GeneralCount = (GeneralEnd - GeneralBegin + 1);
+		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 {
+		const size_t SAY_LINK_BODY_SIZE = 50;
-		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 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)
+			if (eq->TotalChars > constants::CHARACTER_CREATION_LIMIT)
-				eq->TotalChars = constants::CharacterCreationLimit;
+				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)
+		if (eq->TotalChars > constants::CHARACTER_CREATION_LIMIT)
-			eq->TotalChars = constants::CharacterCreationLimit;
+			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)
+			if (slot_id_in >= EQEmu::invslot::GENERAL_BEGIN && slot_id_in <= EQEmu::invslot::GENERAL_END)
-				SubSlotNumber = (((slot_id_in + 3) * EQEmu::inventory::ContainerCount) + index + 1);
+				SubSlotNumber = (((slot_id_in + 3) * EQEmu::invbag::SLOT_COUNT) + index + 1);
-			else if (slot_id_in >= EQEmu::legacy::BANK_BEGIN && slot_id_in <= EQEmu::legacy::BANK_END)
+			else if (slot_id_in >= EQEmu::invslot::BANK_BEGIN && slot_id_in <= EQEmu::invslot::BANK_END)
-				SubSlotNumber = (((slot_id_in - EQEmu::legacy::BANK_BEGIN) * EQEmu::inventory::ContainerCount) + EQEmu::legacy::BANK_BAGS_BEGIN + index);
+				SubSlotNumber = (((slot_id_in - EQEmu::invslot::BANK_BEGIN) * EQEmu::invbag::SLOT_COUNT) + EQEmu::invbag::BANK_BAGS_BEGIN + index);
-			else if (slot_id_in >= EQEmu::legacy::SHARED_BANK_BEGIN && slot_id_in <= EQEmu::legacy::SHARED_BANK_END)
+			else if (slot_id_in >= EQEmu::invslot::SHARED_BANK_BEGIN && slot_id_in <= EQEmu::invslot::SHARED_BANK_END)
-				SubSlotNumber = (((slot_id_in - EQEmu::legacy::SHARED_BANK_BEGIN) * EQEmu::inventory::ContainerCount) + EQEmu::legacy::SHARED_BANK_BAGS_BEGIN + index);
+				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)
+		else if (serverSlot == EQEmu::invslot::SLOT_POWER_SOURCE)
-			SoFSlot = invslot::PossessionsPowerSource;
+			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)
+		else if (sofSlot == invslot::slotPowerSource)
-			ServerSlot = EQEmu::inventory::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:
+	case invtype::typePossessions:
-		return invtype::InvTypePossessionsSize;
+		return invtype::POSSESSIONS_SIZE;
-	case invtype::InvTypeBank:
+	case invtype::typeBank:
-		return invtype::InvTypeBankSize;
+		return invtype::BANK_SIZE;
-	case invtype::InvTypeSharedBank:
+	case invtype::typeSharedBank:
-		return invtype::InvTypeSharedBankSize;
+		return invtype::SHARED_BANK_SIZE;
-	case invtype::InvTypeTrade:
+	case invtype::typeTrade:
-		return invtype::InvTypeTradeSize;
+		return invtype::TRADE_SIZE;
-	case invtype::InvTypeWorld:
+	case invtype::typeWorld:
-		return invtype::InvTypeWorldSize;
+		return invtype::WORLD_SIZE;
-	case invtype::InvTypeLimbo:
+	case invtype::typeLimbo:
-		return invtype::InvTypeLimboSize;
+		return invtype::LIMBO_SIZE;
-	case invtype::InvTypeTribute:
+	case invtype::typeTribute:
-		return invtype::InvTypeTributeSize;
+		return invtype::TRIBUTE_SIZE;
-	case invtype::InvTypeGuildTribute:
+	case invtype::typeGuildTribute:
-		return invtype::InvTypeGuildTributeSize;
+		return invtype::GUILD_TRIBUTE_SIZE;
-	case invtype::InvTypeMerchant:
+	case invtype::typeMerchant:
-		return invtype::InvTypeMerchantSize;
+		return invtype::MERCHANT_SIZE;
-	case invtype::InvTypeCorpse:
+	case invtype::typeCorpse:
-		return invtype::InvTypeCorpseSize;
+		return invtype::CORPSE_SIZE;
-	case invtype::InvTypeBazaar:
+	case invtype::typeBazaar:
-		return invtype::InvTypeBazaarSize;
+		return invtype::BAZAAR_SIZE;
-	case invtype::InvTypeInspect:
+	case invtype::typeInspect:
-		return invtype::InvTypeInspectSize;
+		return invtype::INSPECT_SIZE;
-	case invtype::InvTypeViewMODPC:
+	case invtype::typeViewMODPC:
-		return invtype::InvTypeViewMODPCSize;
+		return invtype::VIEW_MOD_PC_SIZE;
-	case invtype::InvTypeViewMODBank:
+	case invtype::typeViewMODBank:
-		return invtype::InvTypeViewMODBankSize;
+		return invtype::VIEW_MOD_BANK_SIZE;
-	case invtype::InvTypeViewMODSharedBank:
+	case invtype::typeViewMODSharedBank:
-		return invtype::InvTypeViewMODSharedBankSize;
+		return invtype::VIEW_MOD_SHARED_BANK_SIZE;
-	case invtype::InvTypeViewMODLimbo:
+	case invtype::typeViewMODLimbo:
-		return invtype::InvTypeViewMODLimboSize;
+		return invtype::VIEW_MOD_LIMBO_SIZE;
-	case invtype::InvTypeAltStorage:
+	case invtype::typeAltStorage:
-		return invtype::InvTypeAltStorageSize;
+		return invtype::ALT_STORAGE_SIZE;
-	case invtype::InvTypeArchived:
+	case invtype::typeArchived:
-		return invtype::InvTypeArchivedSize;
+		return invtype::ARCHIVED_SIZE;
-	case invtype::InvTypeOther:
+	case invtype::typeOther:
-		return invtype::InvTypeOtherSize;
+		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::typePossessions:
-	case invtype::InvTypeBank:
+	case invtype::typeBank:
-	case invtype::InvTypeSharedBank:
+	case invtype::typeSharedBank:
-	case invtype::InvTypeTrade:
+	case invtype::typeTrade:
-	case invtype::InvTypeWorld:
+	case invtype::typeWorld:
-	case invtype::InvTypeLimbo:
+	case invtype::typeLimbo:
-	case invtype::InvTypeTribute:
+	case invtype::typeTribute:
-	case invtype::InvTypeGuildTribute:
+	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 {
+		} // namespace enum_
-			InvTypePossessions = InvTypeBegin,
+		using namespace enum_;
-			InvTypeBank,
+
-			InvTypeSharedBank,
+		const int16 POSSESSIONS_SIZE = 32;
-			InvTypeTrade,
+		const int16 BANK_SIZE = 24;
-			InvTypeWorld,
+		const int16 SHARED_BANK_SIZE = 2;
-			InvTypeLimbo,
+		const int16 TRADE_SIZE = 8;
-			InvTypeTribute,
+		const int16 WORLD_SIZE = 10;
-			InvTypeGuildTribute,
+		const int16 LIMBO_SIZE = 36;
-			InvTypeMerchant,
+		const int16 TRIBUTE_SIZE = 5;
-			InvTypeCorpse,
+		const int16 GUILD_TRIBUTE_SIZE = 2;
-			InvTypeBazaar,
+		const int16 MERCHANT_SIZE = 80;
-			InvTypeInspect,
+		const int16 CORPSE_SIZE = POSSESSIONS_SIZE;
-			InvTypeViewMODPC,
+		const int16 BAZAAR_SIZE = 80;
-			InvTypeViewMODBank,
+		const int16 INSPECT_SIZE = 23;
-			InvTypeViewMODSharedBank,
+		const int16 VIEW_MOD_PC_SIZE = POSSESSIONS_SIZE;
-			InvTypeViewMODLimbo,
+		const int16 VIEW_MOD_BANK_SIZE = BANK_SIZE;
-			InvTypeAltStorage,
+		const int16 VIEW_MOD_SHARED_BANK_SIZE = SHARED_BANK_SIZE;
-			InvTypeArchived,
+		const int16 VIEW_MOD_LIMBO_SIZE = LIMBO_SIZE;
-			InvTypeOther,
+		const int16 ALT_STORAGE_SIZE = 0;//unknown - "Shroud Bank"
-			InvTypeCount
+		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 {
+		} // namespace enum_
-			PossessionsCharm = InvSlotBegin,
+		using namespace enum_;
-			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
-		};
 
-		const int EquipmentBegin = PossessionsCharm;
+		const int16 SLOT_INVALID = IINVALID;
-		const int EquipmentEnd = PossessionsAmmo;
+		const int16 SLOT_BEGIN = INULL;
-		const int EquipmentCount = (EquipmentEnd - EquipmentBegin + 1);
 
-		const int GeneralBegin = PossessionsGeneral1;
+		const int16 POSSESSIONS_BEGIN = slotCharm;
-		const int GeneralEnd = PossessionsGeneral8;
+		const int16 POSSESSIONS_END = slotCursor;
-		const int GeneralCount = (GeneralEnd - GeneralBegin + 1);
+		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 {
+		const size_t SAY_LINK_BODY_SIZE = 50;
-		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 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:
+	case invtype::typePossessions:
-		return invtype::InvTypePossessionsSize;
+		return invtype::POSSESSIONS_SIZE;
-	case invtype::InvTypeBank:
+	case invtype::typeBank:
-		return invtype::InvTypeBankSize;
+		return invtype::BANK_SIZE;
-	case invtype::InvTypeSharedBank:
+	case invtype::typeSharedBank:
-		return invtype::InvTypeSharedBankSize;
+		return invtype::SHARED_BANK_SIZE;
-	case invtype::InvTypeTrade:
+	case invtype::typeTrade:
-		return invtype::InvTypeTradeSize;
+		return invtype::TRADE_SIZE;
-	case invtype::InvTypeWorld:
+	case invtype::typeWorld:
-		return invtype::InvTypeWorldSize;
+		return invtype::WORLD_SIZE;
-	case invtype::InvTypeLimbo:
+	case invtype::typeLimbo:
-		return invtype::InvTypeLimboSize;
+		return invtype::LIMBO_SIZE;
-	case invtype::InvTypeTribute:
+	case invtype::typeTribute:
-		return invtype::InvTypeTributeSize;
+		return invtype::TRIBUTE_SIZE;
-	case invtype::InvTypeGuildTribute:
+	case invtype::typeGuildTribute:
-		return invtype::InvTypeGuildTributeSize;
+		return invtype::GUILD_TRIBUTE_SIZE;
-	case invtype::InvTypeMerchant:
+	case invtype::typeMerchant:
-		return invtype::InvTypeMerchantSize;
+		return invtype::MERCHANT_SIZE;
-	case invtype::InvTypeCorpse:
+	case invtype::typeCorpse:
-		return invtype::InvTypeCorpseSize;
+		return invtype::CORPSE_SIZE;
-	case invtype::InvTypeBazaar:
+	case invtype::typeBazaar:
-		return invtype::InvTypeBazaarSize;
+		return invtype::BAZAAR_SIZE;
-	case invtype::InvTypeInspect:
+	case invtype::typeInspect:
-		return invtype::InvTypeInspectSize;
+		return invtype::INSPECT_SIZE;
-	case invtype::InvTypeViewMODPC:
+	case invtype::typeViewMODPC:
-		return invtype::InvTypeViewMODPCSize;
+		return invtype::VIEW_MOD_PC_SIZE;
-	case invtype::InvTypeViewMODBank:
+	case invtype::typeViewMODBank:
-		return invtype::InvTypeViewMODBankSize;
+		return invtype::VIEW_MOD_BANK_SIZE;
-	case invtype::InvTypeViewMODSharedBank:
+	case invtype::typeViewMODSharedBank:
-		return invtype::InvTypeViewMODSharedBankSize;
+		return invtype::VIEW_MOD_SHARED_BANK_SIZE;
-	case invtype::InvTypeViewMODLimbo:
+	case invtype::typeViewMODLimbo:
-		return invtype::InvTypeViewMODLimboSize;
+		return invtype::VIEW_MOD_LIMBO_SIZE;
-	case invtype::InvTypeAltStorage:
+	case invtype::typeAltStorage:
-		return invtype::InvTypeAltStorageSize;
+		return invtype::ALT_STORAGE_SIZE;
-	case invtype::InvTypeArchived:
+	case invtype::typeArchived:
-		return invtype::InvTypeArchivedSize;
+		return invtype::ARCHIVED_SIZE;
-	case invtype::InvTypeOther:
+	case invtype::typeOther:
-		return invtype::InvTypeOtherSize;
+		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::typePossessions:
-	case invtype::InvTypeBank:
+	case invtype::typeBank:
-	case invtype::InvTypeSharedBank:
+	case invtype::typeSharedBank:
-	case invtype::InvTypeTrade:
+	case invtype::typeTrade:
-	case invtype::InvTypeWorld:
+	case invtype::typeWorld:
-	case invtype::InvTypeLimbo:
+	case invtype::typeLimbo:
-	case invtype::InvTypeTribute:
+	case invtype::typeTribute:
-	case invtype::InvTypeGuildTribute:
+	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 {
+		} // namespace enum_
-			InvTypePossessions = InvTypeBegin,
+		using namespace enum_;
-			InvTypeBank,
+
-			InvTypeSharedBank,
+		const int16 POSSESSIONS_SIZE = 31;
-			InvTypeTrade,
+		const int16 BANK_SIZE = 16;
-			InvTypeWorld,
+		const int16 SHARED_BANK_SIZE = 2;
-			InvTypeLimbo,
+		const int16 TRADE_SIZE = 8;
-			InvTypeTribute,
+		const int16 WORLD_SIZE = 10;
-			InvTypeGuildTribute,
+		const int16 LIMBO_SIZE = 36;
-			InvTypeMerchant,
+		const int16 TRIBUTE_SIZE = 5;
-			InvTypeCorpse,
+		const int16 GUILD_TRIBUTE_SIZE = 2;
-			InvTypeBazaar,
+		const int16 MERCHANT_SIZE = 80;
-			InvTypeInspect,
+		const int16 CORPSE_SIZE = POSSESSIONS_SIZE;
-			InvTypeViewMODPC,
+		const int16 BAZAAR_SIZE = 80;
-			InvTypeViewMODBank,
+		const int16 INSPECT_SIZE = 22;
-			InvTypeViewMODSharedBank,
+		const int16 VIEW_MOD_PC_SIZE = POSSESSIONS_SIZE;
-			InvTypeViewMODLimbo,
+		const int16 VIEW_MOD_BANK_SIZE = BANK_SIZE;
-			InvTypeAltStorage,
+		const int16 VIEW_MOD_SHARED_BANK_SIZE = SHARED_BANK_SIZE;
-			InvTypeArchived,
+		const int16 VIEW_MOD_LIMBO_SIZE = LIMBO_SIZE;
-			InvTypeOther,
+		const int16 ALT_STORAGE_SIZE = 0;//unknown - "Shroud Bank"
-			InvTypeCount
+		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 {
+		} // namespace enum_
-			PossessionsCharm = InvSlotBegin,
+		using namespace enum_;
-			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
-		};
 
-		const int EquipmentBegin = PossessionsCharm;
+		const int16 SLOT_INVALID = IINVALID;
-		const int EquipmentEnd = PossessionsAmmo;
+		const int16 SLOT_BEGIN = INULL;
-		const int EquipmentCount = (EquipmentEnd - EquipmentBegin + 1);
 
-		const int GeneralBegin = PossessionsGeneral1;
+		const int16 POSSESSIONS_BEGIN = slotCharm;
-		const int GeneralEnd = PossessionsGeneral8;
+		const int16 POSSESSIONS_END = slotCursor;
-		const int GeneralCount = (GeneralEnd - GeneralBegin + 1);
+		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 {
+		const size_t SAY_LINK_BODY_SIZE = 45;
-		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 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)
+			if (eq->TotalChars > constants::CHARACTER_CREATION_LIMIT)
-				eq->TotalChars = constants::CharacterCreationLimit;
+				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)
+		if (eq->TotalChars > constants::CHARACTER_CREATION_LIMIT)
-			eq->TotalChars = constants::CharacterCreationLimit;
+			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)
+			if (slot_id_in >= EQEmu::invslot::GENERAL_BEGIN && slot_id_in <= EQEmu::invslot::GENERAL_END)
-				SubSlotNumber = (((slot_id_in + 3) * EQEmu::inventory::ContainerCount) + index + 1);
+				SubSlotNumber = (((slot_id_in + 3) * EQEmu::invbag::SLOT_COUNT) + index + 1);
-			else if (slot_id_in >= EQEmu::legacy::BANK_BEGIN && slot_id_in <= EQEmu::legacy::BANK_END)
+			else if (slot_id_in >= EQEmu::invslot::BANK_BEGIN && slot_id_in <= EQEmu::invslot::BANK_END)
-				SubSlotNumber = (((slot_id_in - EQEmu::legacy::BANK_BEGIN) * EQEmu::inventory::ContainerCount) + EQEmu::legacy::BANK_BAGS_BEGIN + index);
+				SubSlotNumber = (((slot_id_in - EQEmu::invslot::BANK_BEGIN) * EQEmu::invbag::SLOT_COUNT) + EQEmu::invbag::BANK_BAGS_BEGIN + index);
-			else if (slot_id_in >= EQEmu::legacy::SHARED_BANK_BEGIN && slot_id_in <= EQEmu::legacy::SHARED_BANK_END)
+			else if (slot_id_in >= EQEmu::invslot::SHARED_BANK_BEGIN && slot_id_in <= EQEmu::invslot::SHARED_BANK_END)
-				SubSlotNumber = (((slot_id_in - EQEmu::legacy::SHARED_BANK_BEGIN) * EQEmu::inventory::ContainerCount) + EQEmu::legacy::SHARED_BANK_BAGS_BEGIN + index);
+				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)
+		else if (serverSlot == EQEmu::invslot::SLOT_POWER_SOURCE)
-			UnderfootSlot = invslot::PossessionsPowerSource;
+			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)
+		else if (ufSlot == invslot::slotPowerSource)
-			ServerSlot = EQEmu::inventory::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:
+	case invtype::typePossessions:
-		return invtype::InvTypePossessionsSize;
+		return invtype::POSSESSIONS_SIZE;
-	case invtype::InvTypeBank:
+	case invtype::typeBank:
-		return invtype::InvTypeBankSize;
+		return invtype::BANK_SIZE;
-	case invtype::InvTypeSharedBank:
+	case invtype::typeSharedBank:
-		return invtype::InvTypeSharedBankSize;
+		return invtype::SHARED_BANK_SIZE;
-	case invtype::InvTypeTrade:
+	case invtype::typeTrade:
-		return invtype::InvTypeTradeSize;
+		return invtype::TRADE_SIZE;
-	case invtype::InvTypeWorld:
+	case invtype::typeWorld:
-		return invtype::InvTypeWorldSize;
+		return invtype::WORLD_SIZE;
-	case invtype::InvTypeLimbo:
+	case invtype::typeLimbo:
-		return invtype::InvTypeLimboSize;
+		return invtype::LIMBO_SIZE;
-	case invtype::InvTypeTribute:
+	case invtype::typeTribute:
-		return invtype::InvTypeTributeSize;
+		return invtype::TRIBUTE_SIZE;
-	case invtype::InvTypeGuildTribute:
+	case invtype::typeGuildTribute:
-		return invtype::InvTypeGuildTributeSize;
+		return invtype::GUILD_TRIBUTE_SIZE;
-	case invtype::InvTypeMerchant:
+	case invtype::typeMerchant:
-		return invtype::InvTypeMerchantSize;
+		return invtype::MERCHANT_SIZE;
-	case invtype::InvTypeCorpse:
+	case invtype::typeCorpse:
-		return invtype::InvTypeCorpseSize;
+		return invtype::CORPSE_SIZE;
-	case invtype::InvTypeBazaar:
+	case invtype::typeBazaar:
-		return invtype::InvTypeBazaarSize;
+		return invtype::BAZAAR_SIZE;
-	case invtype::InvTypeInspect:
+	case invtype::typeInspect:
-		return invtype::InvTypeInspectSize;
+		return invtype::INSPECT_SIZE;
-	case invtype::InvTypeViewMODPC:
+	case invtype::typeViewMODPC:
-		return invtype::InvTypeViewMODPCSize;
+		return invtype::VIEW_MOD_PC_SIZE;
-	case invtype::InvTypeViewMODBank:
+	case invtype::typeViewMODBank:
-		return invtype::InvTypeViewMODBankSize;
+		return invtype::VIEW_MOD_BANK_SIZE;
-	case invtype::InvTypeViewMODSharedBank:
+	case invtype::typeViewMODSharedBank:
-		return invtype::InvTypeViewMODSharedBankSize;
+		return invtype::VIEW_MOD_SHARED_BANK_SIZE;
-	case invtype::InvTypeViewMODLimbo:
+	case invtype::typeViewMODLimbo:
-		return invtype::InvTypeViewMODLimboSize;
+		return invtype::VIEW_MOD_LIMBO_SIZE;
-	case invtype::InvTypeAltStorage:
+	case invtype::typeAltStorage:
-		return invtype::InvTypeAltStorageSize;
+		return invtype::ALT_STORAGE_SIZE;
-	case invtype::InvTypeArchived:
+	case invtype::typeArchived:
-		return invtype::InvTypeArchivedSize;
+		return invtype::ARCHIVED_SIZE;
-	case invtype::InvTypeOther:
+	case invtype::typeOther:
-		return invtype::InvTypeOtherSize;
+		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::typePossessions:
-	case invtype::InvTypeBank:
+	case invtype::typeBank:
-	case invtype::InvTypeSharedBank:
+	case invtype::typeSharedBank:
-	case invtype::InvTypeTrade:
+	case invtype::typeTrade:
-	case invtype::InvTypeWorld:
+	case invtype::typeWorld:
-	case invtype::InvTypeLimbo:
+	case invtype::typeLimbo:
-	case invtype::InvTypeTribute:
+	case invtype::typeTribute:
-	case invtype::InvTypeGuildTribute:
+	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 {
+		} // namespace enum_
-			InvTypePossessions = InvTypeBegin,
+		using namespace enum_;
-			InvTypeBank,
+
-			InvTypeSharedBank,
+		const int16 POSSESSIONS_SIZE = 32;
-			InvTypeTrade,
+		const int16 BANK_SIZE = 24;
-			InvTypeWorld,
+		const int16 SHARED_BANK_SIZE = 2;
-			InvTypeLimbo,
+		const int16 TRADE_SIZE = 8;
-			InvTypeTribute,
+		const int16 WORLD_SIZE = 10;
-			InvTypeGuildTribute,
+		const int16 LIMBO_SIZE = 36;
-			InvTypeMerchant,
+		const int16 TRIBUTE_SIZE = 5;
-			InvTypeCorpse,
+		const int16 GUILD_TRIBUTE_SIZE = 2;
-			InvTypeBazaar,
+		const int16 MERCHANT_SIZE = 80;
-			InvTypeInspect,
+		const int16 CORPSE_SIZE = POSSESSIONS_SIZE;
-			InvTypeViewMODPC,
+		const int16 BAZAAR_SIZE = 80;
-			InvTypeViewMODBank,
+		const int16 INSPECT_SIZE = 23;
-			InvTypeViewMODSharedBank,
+		const int16 VIEW_MOD_PC_SIZE = POSSESSIONS_SIZE;
-			InvTypeViewMODLimbo,
+		const int16 VIEW_MOD_BANK_SIZE = BANK_SIZE;
-			InvTypeAltStorage,
+		const int16 VIEW_MOD_SHARED_BANK_SIZE = SHARED_BANK_SIZE;
-			InvTypeArchived,
+		const int16 VIEW_MOD_LIMBO_SIZE = LIMBO_SIZE;
-			InvTypeOther,
+		const int16 ALT_STORAGE_SIZE = 0;//unknown - "Shroud Bank"
-			InvTypeCount
+		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 {
+		} // namespace enum_
-			PossessionsCharm = InvSlotBegin,
+		using namespace enum_;
-			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
-		};
 
-		const int EquipmentBegin = PossessionsCharm;
+		const int16 SLOT_INVALID = IINVALID;
-		const int EquipmentEnd = PossessionsAmmo;
+		const int16 SLOT_BEGIN = INULL;
-		const int EquipmentCount = (EquipmentEnd - EquipmentBegin + 1);
 
-		const int GeneralBegin = PossessionsGeneral1;
+		const int16 POSSESSIONS_BEGIN = slotCharm;
-		const int GeneralEnd = PossessionsGeneral8;
+		const int16 POSSESSIONS_END = slotCursor;
-		const int GeneralCount = (GeneralEnd - GeneralBegin + 1);
+		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 {
+		const size_t SAY_LINK_BODY_SIZE = 50;
-		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 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 "global_define.h"
-#include "../common/useperl.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 "global_define.h"
-#include "../common/useperl.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 HUMAN:
-	case BARBARIAN:
+		case BARBARIAN:
-	case ERUDITE:
+		case ERUDITE:
-	case WOOD_ELF:
+		case WOOD_ELF:
-	case HIGH_ELF:
+		case HIGH_ELF:
-	case DARK_ELF:
+		case DARK_ELF:
-	case HALF_ELF:
+		case HALF_ELF:
-	case DWARF:
+		case DWARF:
-	case TROLL:
+		case TROLL:
-	case OGRE:
+		case OGRE:
-	case HALFLING:
+		case HALFLING:
-	case GNOME:
+		case GNOME:
-		return race_id;
+			return race_id;
-	case IKSAR:
+		case IKSAR:
-		return PLAYER_RACE_IKSAR;
+			return PLAYER_RACE_IKSAR;
-	case VAHSHIR:
+		case VAHSHIR:
-		return PLAYER_RACE_VAHSHIR;
+			return PLAYER_RACE_VAHSHIR;
-	case FROGLOK:
+		case FROGLOK:
-	case FROGLOK2:
+		case FROGLOK2:
-		return PLAYER_RACE_FROGLOK;
+			return PLAYER_RACE_FROGLOK;
-	case DRAKKIN:
+		case DRAKKIN:
-		return PLAYER_RACE_DRAKKIN;
+			return PLAYER_RACE_DRAKKIN;
-	default:
+		default:
-		return PLAYER_RACE_UNKNOWN; // watch
+			return PLAYER_RACE_UNKNOWN; // watch
 	}
 }
 
-uint32 GetPlayerRaceBit(uint16 race_id)
+uint32 GetPlayerRaceBit(uint16 race_id) {
-{
 	switch (race_id) {
-	case HUMAN:
+		case HUMAN:
-		return PLAYER_RACE_HUMAN_BIT;
+			return PLAYER_RACE_HUMAN_BIT;
-	case BARBARIAN:
+		case BARBARIAN:
-		return PLAYER_RACE_BARBARIAN_BIT;
+			return PLAYER_RACE_BARBARIAN_BIT;
-	case ERUDITE:
+		case ERUDITE:
-		return PLAYER_RACE_ERUDITE_BIT;
+			return PLAYER_RACE_ERUDITE_BIT;
-	case WOOD_ELF:
+		case WOOD_ELF:
-		return PLAYER_RACE_WOOD_ELF_BIT;
+			return PLAYER_RACE_WOOD_ELF_BIT;
-	case HIGH_ELF:
+		case HIGH_ELF:
-		return PLAYER_RACE_HIGH_ELF_BIT;
+			return PLAYER_RACE_HIGH_ELF_BIT;
-	case DARK_ELF:
+		case DARK_ELF:
-		return PLAYER_RACE_DARK_ELF_BIT;
+			return PLAYER_RACE_DARK_ELF_BIT;
-	case HALF_ELF:
+		case HALF_ELF:
-		return PLAYER_RACE_HALF_ELF_BIT;
+			return PLAYER_RACE_HALF_ELF_BIT;
-	case DWARF:
+		case DWARF:
-		return PLAYER_RACE_DWARF_BIT;
+			return PLAYER_RACE_DWARF_BIT;
-	case TROLL:
+		case TROLL:
-		return PLAYER_RACE_TROLL_BIT;
+			return PLAYER_RACE_TROLL_BIT;
-	case OGRE:
+		case OGRE:
-		return PLAYER_RACE_OGRE_BIT;
+			return PLAYER_RACE_OGRE_BIT;
-	case HALFLING:
+		case HALFLING:
-		return PLAYER_RACE_HALFLING_BIT;
+			return PLAYER_RACE_HALFLING_BIT;
-	case GNOME:
+		case GNOME:
-		return PLAYER_RACE_GNOME_BIT;
+			return PLAYER_RACE_GNOME_BIT;
-	case IKSAR:
+		case IKSAR:
-		return PLAYER_RACE_IKSAR_BIT;
+			return PLAYER_RACE_IKSAR_BIT;
-	case VAHSHIR:
+		case VAHSHIR:
-		return PLAYER_RACE_VAHSHIR_BIT;
+			return PLAYER_RACE_VAHSHIR_BIT;
-	case FROGLOK:
+		case FROGLOK:
-		return PLAYER_RACE_FROGLOK_BIT;
+			return PLAYER_RACE_FROGLOK_BIT;
-	case DRAKKIN:
+		case DRAKKIN:
-		return PLAYER_RACE_DRAKKIN_BIT;
+			return PLAYER_RACE_DRAKKIN_BIT;
-	default:
+		default:
-		return PLAYER_RACE_UNKNOWN_BIT;
+			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_HUMAN:
-	case PLAYER_RACE_BARBARIAN:
+		case PLAYER_RACE_BARBARIAN:
-	case PLAYER_RACE_ERUDITE:
+		case PLAYER_RACE_ERUDITE:
-	case PLAYER_RACE_WOOD_ELF:
+		case PLAYER_RACE_WOOD_ELF:
-	case PLAYER_RACE_HIGH_ELF:
+		case PLAYER_RACE_HIGH_ELF:
-	case PLAYER_RACE_DARK_ELF:
+		case PLAYER_RACE_DARK_ELF:
-	case PLAYER_RACE_HALF_ELF:
+		case PLAYER_RACE_HALF_ELF:
-	case PLAYER_RACE_DWARF:
+		case PLAYER_RACE_DWARF:
-	case PLAYER_RACE_TROLL:
+		case PLAYER_RACE_TROLL:
-	case PLAYER_RACE_OGRE:
+		case PLAYER_RACE_OGRE:
-	case PLAYER_RACE_HALFLING:
+		case PLAYER_RACE_HALFLING:
-	case PLAYER_RACE_GNOME:
+		case PLAYER_RACE_GNOME:
-		return player_race_value;
+			return player_race_value;
-	case PLAYER_RACE_IKSAR:
+		case PLAYER_RACE_IKSAR:
-		return IKSAR;
+			return IKSAR;
-	case PLAYER_RACE_VAHSHIR:
+		case PLAYER_RACE_VAHSHIR:
-		return VAHSHIR;
+			return VAHSHIR;
-	case PLAYER_RACE_FROGLOK:
+		case PLAYER_RACE_FROGLOK:
-		return FROGLOK;
+			return FROGLOK;
-	case PLAYER_RACE_DRAKKIN:
+		case PLAYER_RACE_DRAKKIN:
-		return DRAKKIN;
+			return DRAKKIN;
-	default:
+		default:
-		return PLAYER_RACE_UNKNOWN; // watch
+			return PLAYER_RACE_UNKNOWN; // watch
 	}
 }
 
@@ -1596,7 +1593,7 @@ float GetRaceGenderDefaultHeight(int race, int gender)
 
 	const auto size = sizeof(male_height) / sizeof(male_height[0]);
 
-	if (race > size)
+	if (race >= size)
 		return 6.0f;
 
 	if (gender == 1)

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());
+			Log(Logs::Detail, Logs::Rules, "Failed to find default ruleset '%s' for load operation. Canceling.",
-			return(false);
+			    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))
+			if (!SetRule(row[0], row[1], nullptr, false))
-			Log(Logs::Detail, Logs::Rules, "Unable to interpret rule record for %s", row[0]);
+				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);
+	std::string query   = StringFormat("SELECT rule_name, rule_value FROM rule_values WHERE ruleset_id=%d", ruleset_id);
-	auto results = database->QueryDatabase(query);
+	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))
+		if (!SetRule(row[0], row[1], nullptr, false))
-		Log(Logs::Detail, Logs::Rules, "Unable to interpret rule record for %s", row[0]);
+			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 "
+	std::string query = StringFormat(
-                                    "(ruleset_id, rule_name, rule_value) "
+			"REPLACE INTO rule_values "
-                                    " VALUES(%d, '%s', '%s')",
+			"(ruleset_id, rule_name, rule_value) "
-                                    m_activeRuleset, _GetRuleName(type, index), value_string);
+			" VALUES(%d, '%s', '%s')",
-    auto results = database->QueryDatabase(query);
+			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)
@@ -548,6 +550,7 @@ RULE_BOOL(Aggro, AllowTickPulling, false) // tick pulling is an exploit in an NP
 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)

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,
+									char_id, EQEmu::invslot::slotCursor,
-									EQEmu::legacy::CURSOR_BAG_BEGIN, EQEmu::legacy::CURSOR_BAG_END);
+									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::invslot::EQUIPMENT_BEGIN && slot_id <= EQEmu::invslot::EQUIPMENT_END) ||
-			slot_id == EQEmu::inventory::slotPowerSource) &&
+			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 &&
+				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)))
-						!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/version.h

@@ -30,7 +30,7 @@
 	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 9019
 #else

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
+  join(doc "Choose the type of build, options are: None(CMAKE_CXX_FLAGS or "
-    "Choose the type of build, options are: None(CMAKE_CXX_FLAGS or CMAKE_C_FLAGS used) Debug Release RelWithDebInfo MinSizeRel.")
+           "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)
+file(READ fmt/format.h format_h)
-if (NOT FMT_VERSION MATCHES "^([0-9]+).([0-9]+).([0-9]+)$")
+if (NOT format_h MATCHES "FMT_VERSION ([0-9]+)([0-9][0-9])([0-9][0-9])")
-  message(FATAL_ERROR "Invalid version format ${FMT_VERSION}.")
+  message(FATAL_ERROR "Cannot get FMT_VERSION from format.h.")
 endif ()
-set(CPACK_PACKAGE_VERSION_MAJOR ${CMAKE_MATCH_1})
+# Use math to skip leading zeros if any.
-set(CPACK_PACKAGE_VERSION_MINOR ${CMAKE_MATCH_2})
+math(EXPR CPACK_PACKAGE_VERSION_MAJOR ${CMAKE_MATCH_1})
-set(CPACK_PACKAGE_VERSION_PATCH ${CMAKE_MATCH_3})
+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!

libs/format/ChangeLog.rst

@@ -1,3 +1,113 @@
+4.0.0 - 2017-06-27
+------------------
+
+* Removed old compatibility headers ``cppformat/*.h`` and CMake options (`#527 <https://github.com/pull/527>`_). Thanks `@maddinat0r (Alex Martin) <https://github.com/maddinat0r>`_.
+
+* Added ``string.h`` containing ``fmt::to_string()`` as alternative to ``std::to_string()`` as well as other string writer functionality (`#326 <https://github.com/fmtlib/fmt/issues/326>`_ and `#441 <https://github.com/fmtlib/fmt/pull/441>`_):
+
+  .. code:: c++
+
+    #include "fmt/string.h"
+  
+    std::string answer = fmt::to_string(42);
+
+  Thanks to `@glebov-andrey (Andrey Glebov) <https://github.com/glebov-andrey>`_.
+
+* Moved ``fmt::printf()`` to new ``printf.h`` header and allowed ``%s`` as generic specifier (`#453 <https://github.com/fmtlib/fmt/pull/453>`_), made ``%.f`` more conformant to regular ``printf()`` (`#490 <https://github.com/fmtlib/fmt/pull/490>`_), added custom writer support (`#476 <https://github.com/fmtlib/fmt/issues/476>`_) and implemented missing custom argument formatting (`#339 <https://github.com/fmtlib/fmt/pull/339>`_ and `#340 <https://github.com/fmtlib/fmt/pull/340>`_):
+
+  .. code:: c++
+
+    #include "fmt/printf.h"
+ 
+    // %s format specifier can be used with any argument type.
+    fmt::printf("%s", 42);
+
+  Thanks `@mojoBrendan <https://github.com/mojoBrendan>`_, `@manylegged (Arthur Danskin) <https://github.com/manylegged>`_ and `@spacemoose (Glen Stark) <https://github.com/spacemoose>`_. See also `#360 <https://github.com/fmtlib/fmt/issues/360>`_, `#335 <https://github.com/fmtlib/fmt/issues/335>`_ and `#331 <https://github.com/fmtlib/fmt/issues/331>`_.
+
+* Added ``container.h`` containing a ``BasicContainerWriter`` to write to containers like ``std::vector`` (`#450 <https://github.com/fmtlib/fmt/pull/450>`_). Thanks `@polyvertex (Jean-Charles Lefebvre) <https://github.com/polyvertex>`_.
+
+* Added ``fmt::join()`` function that takes a range and formats its elements separated by a given string (`#466 <https://github.com/fmtlib/fmt/pull/466>`_):
+
+  .. code:: c++
+
+    #include "fmt/format.h"
+ 
+    std::vector<double> v = {1.2, 3.4, 5.6};
+    // Prints "(+01.20, +03.40, +05.60)".
+    fmt::print("({:+06.2f})", fmt::join(v.begin(), v.end(), ", "));
+
+  Thanks `@olivier80 <https://github.com/olivier80>`_.
+
+* Added support for custom formatting specifications to simplify customization of built-in formatting (`#444 <https://github.com/fmtlib/fmt/pull/444>`_). Thanks `@polyvertex (Jean-Charles Lefebvre) <https://github.com/polyvertex>`_. See also `#439 <https://github.com/fmtlib/fmt/issues/439>`_.
+
+* Added ``fmt::format_system_error()`` for error code formatting (`#323 <https://github.com/fmtlib/fmt/issues/323>`_ and `#526 <https://github.com/fmtlib/fmt/pull/526>`_). Thanks `@maddinat0r (Alex Martin) <https://github.com/maddinat0r>`_.
+
+* Added thread-safe ``fmt::localtime()`` and ``fmt::gmtime()`` as replacement for the standard version to ``time.h`` (`#396 <https://github.com/fmtlib/fmt/pull/396>`_). Thanks `@codicodi <https://github.com/codicodi>`_.
+
+* Internal improvements to ``NamedArg`` and ``ArgLists`` (`#389 <https://github.com/fmtlib/fmt/pull/389>`_ and `#390 <https://github.com/fmtlib/fmt/pull/390>`_). Thanks `@chronoxor <https://github.com/chronoxor>`_.
+
+* Fixed crash due to bug in ``FormatBuf`` (`#493 <https://github.com/fmtlib/fmt/pull/493>`_). Thanks `@effzeh <https://github.com/effzeh>`_. See also `#480 <https://github.com/fmtlib/fmt/issues/480>`_ and `#491 <https://github.com/fmtlib/fmt/issues/491>`_.
+
+* Fixed handling of wide strings in ``fmt::StringWriter``.
+
+* Improved compiler error messages (`#357 <https://github.com/fmtlib/fmt/issues/357>`_).
+
+* Fixed various warnings and issues with various compilers (`#494 <https://github.com/fmtlib/fmt/pull/494>`_, `#499 <https://github.com/fmtlib/fmt/pull/499>`_, `#483 <https://github.com/fmtlib/fmt/pull/483>`_, `#519 <https://github.com/fmtlib/fmt/pull/519>`_, `#485 <https://github.com/fmtlib/fmt/pull/485>`_, `#482 <https://github.com/fmtlib/fmt/pull/482>`_, `#475 <https://github.com/fmtlib/fmt/pull/475>`_, `#473 <https://github.com/fmtlib/fmt/pull/473>`_ and `#414 <https://github.com/fmtlib/fmt/pull/414>`_). Thanks `@chronoxor <https://github.com/chronoxor>`_, `@zhaohuaxishi <https://github.com/zhaohuaxishi>`_, `@pkestene (Pierre Kestener) <https://github.com/pkestene>`_, `@dschmidt (Dominik Schmidt) <https://github.com/dschmidt>`_ and `@0x414c (Alexey Gorishny) <https://github.com/0x414c>`_ .
+
+* Improved CMake: targets are now namespaced (`#511 <https://github.com/fmtlib/fmt/pull/511>`_ and `#513 <https://github.com/fmtlib/fmt/pull/513>`_), supported header-only ``printf.h`` (`#354 <https://github.com/fmtlib/fmt/pull/354>`_), fixed issue with minimal supported library subset (`#418 <https://github.com/fmtlib/fmt/issues/418>`_, `#419 <https://github.com/fmtlib/fmt/pull/419>`_ and `#420 <https://github.com/fmtlib/fmt/pull/420>`_). Thanks `@bjoernthiel (Bjoern Thiel) <https://github.com/bjoernthiel>`_,
+  `@niosHD (Mario Werner) <https://github.com/niosHD>`_, `@LogicalKnight (Sean LK) <https://github.com/LogicalKnight>`_ and `@alabuzhev (Alex Alabuzhev) <https://github.com/alabuzhev>`_.
+
+* Improved documentation. Thanks to `@pwm1234 (Phil) <https://github.com/pwm1234>`_ for `#393 <https://github.com/fmtlib/fmt/pull/393>`_.
+
+3.0.2 - 2017-06-14
+------------------
+
+* Added ``FMT_VERSION`` macro (`#411 <https://github.com/fmtlib/fmt/issues/411>`_).
+
+* Used ``FMT_NULL`` instead of literal ``0`` (`#409 <https://github.com/fmtlib/fmt/pull/409>`_). Thanks `@alabuzhev (Alex Alabuzhev) <https://github.com/alabuzhev>`_.
+
+* Added extern templates for ``format_float`` (`#413 <https://github.com/fmtlib/fmt/issues/413>`_).
+
+* Fixed implicit conversion issue (`#507 <https://github.com/fmtlib/fmt/issues/507>`_).
+
+* Fixed signbit detection (`#423 <https://github.com/fmtlib/fmt/issues/423>`_).
+
+* Fixed naming collision (`#425 <https://github.com/fmtlib/fmt/issues/425>`_).
+
+* Fixed missing intrinsic for C++/CLI (`#457 <https://github.com/fmtlib/fmt/pull/457>`_). Thanks `@calumr (Calum Robinson) <https://github.com/calumr>`_
+
+* Fixed Android detection (`#458 <https://github.com/fmtlib/fmt/pull/458>`_). Thanks `@Gachapen (Magnus Bjerke Vik) <https://github.com/Gachapen>`_.
+
+* Use lean ``windows.h`` if not in header-only mode (`#503 <https://github.com/fmtlib/fmt/pull/503>`_). Thanks `@Quentin01 (Quentin Buathier) <https://github.com/Quentin01>`_.
+
+* Fixed issue with CMake exporting C++11 flag (`#445 <https://github.com/fmtlib/fmt/pull/455>`_). Thanks `@EricWF (Eric) <https://github.com/EricWF>`_.
+
+* Fixed issue with nvcc and MSVC compiler bug and MinGW (`#505 <https://github.com/fmtlib/fmt/issues/505>`_).
+
+* Fixed DLL issues (`#469 <https://github.com/fmtlib/fmt/pull/469>`_ and `#502 <https://github.com/fmtlib/fmt/pull/502>`_). Thanks `@richardeakin (Richard Eakin) <https://github.com/richardeakin>`_ and `@AndreasSchoenle (Andreas Schönle) <https://github.com/AndreasSchoenle>`_.
+
+* Fixed test compilation under FreeBSD (`#433 <https://github.com/fmtlib/fmt/issues/433>`_).
+
+* Fixed various warnings (`#403 <https://github.com/fmtlib/fmt/pull/403>`_, `#410 <https://github.com/fmtlib/fmt/pull/410>`_ and `#510 <https://github.com/fmtlib/fmt/pull/510>`_). Thanks `@Lecetem <https://github.com/Lectem>`_, `@chenhayat (Chen Hayat) <https://github.com/chenhayat>`_ and `@trozen <https://github.com/trozen>`_.
+
+* Removed redundant include (`#479 <https://github.com/fmtlib/fmt/issues/479>`_).
+
+* Fixed documentation issues.
+
+3.0.1 - 2016-11-01
+------------------
+* Fixed handling of thousands seperator (`#353 <https://github.com/fmtlib/fmt/issues/353>`_)
+
+* Fixed handling of ``unsigned char`` strings (`#373 <https://github.com/fmtlib/fmt/issues/373>`_)
+
+* Corrected buffer growth when formatting time (`#367 <https://github.com/fmtlib/fmt/issues/367>`_)
+
+* Removed warnings under MSVC and clang (`#318 <https://github.com/fmtlib/fmt/issues/318>`_, `#250 <https://github.com/fmtlib/fmt/issues/250>`_, also merged `#385 <https://github.com/fmtlib/fmt/pull/385>`_ and `#361 <https://github.com/fmtlib/fmt/pull/361>`_). Thanks `@jcelerier (Jean-Michaël Celerier) <https://github.com/jcelerier>`_ and `@nmoehrle (Nils Moehrle) <https://github.com/nmoehrle>`_.
+
+* Fixed compilation issues under Android (`#327 <https://github.com/fmtlib/fmt/pull/327>`_, `#345 <https://github.com/fmtlib/fmt/issues/345>`_ and `#381 <https://github.com/fmtlib/fmt/pull/381>`_), FreeBSD (`#358 <https://github.com/fmtlib/fmt/pull/358>`_), Cygwin (`#388 <https://github.com/fmtlib/fmt/issues/388>`_), MinGW (`#355 <https://github.com/fmtlib/fmt/issues/355>`_) as well as other issues (`#350 <https://github.com/fmtlib/fmt/issues/350>`_, `#366 <https://github.com/fmtlib/fmt/issues/355>`_, `#348 <https://github.com/fmtlib/fmt/pull/348>`_, `#402 <https://github.com/fmtlib/fmt/pull/402>`_, `#405 <https://github.com/fmtlib/fmt/pull/405>`_). Thanks to `@dpantele (Dmitry) <https://github.com/dpantele>`_, `@hghwng (Hugh Wang) <https://github.com/hghwng>`_, `@arvedarved (Tilman Keskinöz) <https://github.com/arvedarved>`_, `@LogicalKnight (Sean) <https://github.com/LogicalKnight>`_ and `@JanHellwig (Jan Hellwig) <https://github.com/janhellwig>`_.
+ 
+* Fixed some documentation issues and extended specification (`#320 <https://github.com/fmtlib/fmt/issues/320>`_, `#333 <https://github.com/fmtlib/fmt/pull/333>`_, `#347 <https://github.com/fmtlib/fmt/issues/347>`_, `#362 <https://github.com/fmtlib/fmt/pull/362>`_). Thanks to `@smellman (Taro Matsuzawa aka. btm) <https://github.com/smellman>`_.
+
 3.0.0 - 2016-05-07
 ------------------
 

libs/format/README.rst

@@ -20,9 +20,11 @@ alternative to IOStreams.
 Features
 --------
 
-* Two APIs: faster concatenation-based write API and slower (but still
+* Two APIs: faster concatenation-based `write API
-  very fast) replacement-based format API with positional arguments for
+  <http://fmtlib.net/latest/api.html#write-api>`_ and slower,
-  localization.
+  but still very fast, replacement-based `format API
+  <http://fmtlib.net/latest/api.html#format-api>`_ with positional arguments
+  for localization.
 * Write API similar to the one used by IOStreams but stateless allowing
   faster implementation.
 * Format API with `format string syntax
@@ -35,10 +37,10 @@ Features
 * Support for user-defined types.
 * High speed: performance of the format API is close to that of
   glibc's `printf <http://en.cppreference.com/w/cpp/io/c/fprintf>`_
-  and better than performance of IOStreams. See `Speed tests`_ and
+  and better than the performance of IOStreams. See `Speed tests`_ and
   `Fast integer to string conversion in C++
   <http://zverovich.net/2013/09/07/integer-to-string-conversion-in-cplusplus.html>`_.
-* Small code size both in terms of source code (format consists of a single
+* Small code size both in terms of source code (the core library consists of a single
   header file and a single source file) and compiled code.
   See `Compile time and code bloat`_.
 * Reliability: the library has an extensive set of `unit tests
@@ -89,6 +91,8 @@ An object of any user-defined type for which there is an overloaded
 
 .. code:: c++
 
+    #include "fmt/ostream.h"
+
     class Date {
       int year_, month_, day_;
      public:
@@ -132,6 +136,12 @@ Projects using this library
 * `AMPL/MP <https://github.com/ampl/mp>`_:
   An open-source library for mathematical programming
 
+* `CUAUV <http://cuauv.org/>`_: Cornell University's autonomous underwater vehicle
+
+* `Drake <http://drake.mit.edu/>`_: A planning, control, and analysis toolbox for nonlinear dynamical systems (MIT)
+
+* `Envoy <https://lyft.github.io/envoy/>`_: C++ L7 proxy and communication bus (Lyft)
+
 * `HarpyWar/pvpgn <https://github.com/pvpgn/pvpgn-server>`_:
   Player vs Player Gaming Network with tweaks
 
@@ -139,6 +149,8 @@ Projects using this library
 
 * `Keypirinha <http://keypirinha.com/>`_: A semantic launcher for Windows
 
+* `Kodi <https://kodi.tv/>`_ (formerly xbmc): Home theater software
+
 * `Lifeline <https://github.com/peter-clark/lifeline>`_: A 2D game
 
 * `MongoDB Smasher <https://github.com/duckie/mongo_smasher>`_: A small tool to generate randomized datasets
@@ -158,6 +170,12 @@ Projects using this library
 * `Salesforce Analytics Cloud <http://www.salesforce.com/analytics-cloud/overview/>`_:
   Business intelligence software
 
+* `Scylla <http://www.scylladb.com/>`_: A Cassandra-compatible NoSQL data store that can handle
+  1 million transactions per second on a single server
+
+* `Seastar <http://www.seastar-project.org/>`_: An advanced, open-source C++ framework for
+  high-performance server applications on modern hardware
+
 * `spdlog <https://github.com/gabime/spdlog>`_: Super fast C++ logging library
 
 * `Stellar <https://www.stellar.org/>`_: Financial platform
@@ -390,6 +408,11 @@ It only applies if you distribute the documentation of fmt.
 Acknowledgments
 ---------------
 
+The fmt library is maintained by Victor Zverovich (`vitaut <https://github.com/vitaut>`_)
+and Jonathan Müller (`foonathan <https://github.com/foonathan>`_) with contributions from many
+other people. See `Contributors <https://github.com/fmtlib/fmt/graphs/contributors>`_ and `Releases <https://github.com/fmtlib/fmt/releases>`_ for some of the names. Let us know if your contribution
+is not listed or mentioned incorrectly and we'll make it right.
+
 The benchmark section of this readme file and the performance tests are taken
 from the excellent `tinyformat <https://github.com/c42f/tinyformat>`_ library
 written by Chris Foster.  Boost Format library is acknowledged transitively

libs/format/cppformat/format.h

@@ -1,2 +0,0 @@
-#include "../fmt/format.h"
-#warning Including cppformat/format.h is deprecated. Include fmt/format.h instead.

libs/format/cppformat/posix.h

@@ -1,2 +0,0 @@
-#include "../fmt/posix.h"
-#warning Including cppformat/posix.h is deprecated. Include fmt/posix.h instead.

libs/format/doc/CMakeLists.txt

@@ -5,6 +5,8 @@ if (NOT DOXYGEN)
 endif ()
 
 add_custom_target(doc
-  COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/build.py ${FMT_VERSION})
+  COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/build.py ${FMT_VERSION}
+  SOURCES build.py conf.py _templates/layout.html)
 
-install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/html/ DESTINATION share/doc/fmt)
+install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/html/
+        DESTINATION share/doc/fmt OPTIONAL)

libs/format/doc/_static/breathe.css

@@ -0,0 +1,28 @@
+
+/* -- breathe specific styles ----------------------------------------------- */
+
+/* So enum value descriptions are displayed inline to the item */
+.breatheenumvalues li tt + p {
+  display: inline;
+}
+
+/* So parameter descriptions are displayed inline to the item */
+.breatheparameterlist li tt + p {
+  display: inline;
+}
+
+.container .breathe-sectiondef {
+  width: inherit;
+}
+
+.github-btn {
+  border: 0;
+  overflow: hidden;
+}
+
+.jumbotron {
+  background-size: 100% 4px;
+  background-repeat: repeat-y;
+  color: white;
+  text-align: center;
+}

libs/format/doc/_templates/layout.html

@@ -8,8 +8,9 @@
 {# Google Analytics #}
 <script>
   (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
-    (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
+    (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();
-    m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
+    a=s.createElement(o),m=s.getElementsByTagName(o)[0];a.async=1;
+    a.src=g;m.parentNode.insertBefore(a,m)
   })(window,document,'script','//www.google-analytics.com/analytics.js','ga');
   ga('create', 'UA-20116650-4', 'fmtlib.net');
   ga('send', 'pageview');
@@ -17,9 +18,11 @@
 {% endblock %}
 
 {%- macro searchform(classes, button) %}
-<form class="{{classes}}" role="search" action="{{ pathto('search') }}" method="get">
+<form class="{{classes}}" role="search" action="{{ pathto('search') }}"
+      method="get">
   <div class="form-group">
-    <input type="text" name="q" class="form-control" {{ 'placeholder="Search"' if not button }} >
+    <input type="text" name="q" class="form-control"
+           {{ 'placeholder="Search"' if not button }} >
   </div>
   <input type="hidden" name="check_keywords" value="yes" />
   <input type="hidden" name="area" value="default" />
@@ -36,7 +39,8 @@
       <div class="navbar-content">
         {# Brand and toggle get grouped for better mobile display #}
         <div class="navbar-header">
-          <button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target=".navbar-collapse">
+          <button type="button" class="navbar-toggle collapsed"
+                  data-toggle="collapse" data-target=".navbar-collapse">
             <span class="sr-only">Toggle navigation</span>
             <span class="icon-bar"></span>
             <span class="icon-bar"></span>
@@ -49,18 +53,19 @@
         <div class="collapse navbar-collapse">
           <ul class="nav navbar-nav">
             <li class="dropdown">
-              {# TODO: update versions automatically #}
+              <a href="#" class="dropdown-toggle" data-toggle="dropdown"
-              <a href="#" class="dropdown-toggle" data-toggle="dropdown" role="button"
+                 role="button" aria-expanded="false">{{ version }}
-                 aria-expanded="false">{{ version }} <span class="caret"></span></a>
+                <span class="caret"></span></a>
               <ul class="dropdown-menu" role="menu">
-                <li><a href="http://fmtlib.net/2.0.0/">2.0.0</a></li>
+                {% for v in versions.split(',') %}
-                <li><a href="http://fmtlib.net/1.1.0/">1.1.0</a></li>
+                <li><a href="http://fmtlib.net/{{v}}">{{v}}</a></li>
-                <li><a href="http://fmtlib.net/1.0.0/">1.0.0</a></li>
+                {% endfor %}
               </ul>
             </li>
             {% for name in ['Contents', 'Usage', 'API', 'Syntax'] %}
               {% if pagename == name.lower() %}
-              <li class="active"><a href="{{name.lower()}}.html">{{name}} <span class="sr-only">(current)</span></a></li>
+              <li class="active"><a href="{{name.lower()}}.html">{{name}}
+                <span class="sr-only">(current)</span></a></li>
               {%else%}
               <li><a href="{{name.lower()}}.html">{{name}}</a></li>
               {%endif%}
@@ -75,20 +80,25 @@
   </div> {# /.tb-container #}
 </nav>
 {% if pagename == "index" %}
+{% set download_url = 'https://github.com/fmtlib/fmt/releases/download' %}
 <div class="jumbotron">
   <div class="tb-container">
     <h1>{fmt}</h1>
     <p class="lead">Small, safe and fast formatting library</p>
     <div class="btn-group" role="group">
+      {% set name = 'fmt' if version.split('.')[0]|int >= 3 else 'cppformat' %}
       <a class="btn btn-success"
-          href="https://github.com/fmtlib/fmt/releases/download/2.0.0/cppformat-2.0.0.zip">
+         href="{{download_url}}/{{version}}/{{name}}-{{version}}.zip">
-            <span class="glyphicon glyphicon-download"></span> Download
+           <span class="glyphicon glyphicon-download"></span> Download
       </a>
-      <button type="button" class="btn btn-success dropdown-toggle" data-toggle="dropdown"><span class="caret"></span></button>
+      <button type="button" class="btn btn-success dropdown-toggle"
+        data-toggle="dropdown"><span class="caret"></span></button>
       <ul class="dropdown-menu">
-        <li><a href="https://github.com/fmtlib/fmt/releases/download/2.0.0/cppformat-2.0.0.zip">Version 2.0.0</a></li>
+      {% for v in versions.split(',') %}
-        <li><a href="https://github.com/fmtlib/fmt/releases/download/1.1.0/cppformat-1.1.0.zip">Version 1.1.0</a></li>
+      {% set name = 'fmt' if v.split('.')[0]|int >= 3 else 'cppformat' %}
-        <li><a href="https://github.com/fmtlib/fmt/releases/download/1.0.0/cppformat-1.0.0.zip">Version 1.0.0</a></li>
+        <li><a href="{{download_url}}/{{v}}/{{name}}-{{v}}.zip">Version {{v}}
+          </a></li>
+      {% endfor %}
       </ul>
     </div>
   </div>
@@ -105,14 +115,15 @@
 {% block content %}
 <div class="tb-container">
   <div class="row">
-    {# TODO: integrate sidebar
+    {# Sidebar is currently disabled.
     <div class="bs-sidebar">
       <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
         <div class="sphinxsidebarwrapper">
           {%- block sidebarlogo %}
           {%- if logo %}
             <p class="logo"><a href="{{ pathto(master_doc) }}">
-              <img class="logo" src="{{ pathto('_static/' + logo, 1) }}" alt="Logo"/>
+              <img class="logo" src="{{ pathto('_static/' + logo, 1) }}"
+                   alt="Logo"/>
             </a></p>
           {%- endif %}
           {%- endblock %}

libs/format/doc/api.rst

@@ -11,8 +11,8 @@ namespace is usually omitted in examples.
 Format API
 ==========
 
-The following functions use :ref:`format string syntax <syntax>` similar
+The following functions defined in ``fmt/format.h`` use :ref:`format string
-to the one used by Python's `str.format
+syntax <syntax>` similar to the one used by Python's `str.format
 <http://docs.python.org/3/library/stdtypes.html#str.format>`_ function.
 They take *format_str* and *args* as arguments.
 
@@ -22,6 +22,11 @@ arguments in the resulting string.
 
 *args* is an argument list representing arbitrary arguments.
 
+The `performance of the format API
+<https://github.com/fmtlib/fmt/blob/master/README.rst#speed-tests>`_ is close
+to that of glibc's ``printf`` and better than the performance of IOStreams.
+For even better speed use the `write API`_.
+
 .. _format:
 
 .. doxygenfunction:: format(CStringRef, ArgList)
@@ -40,8 +45,9 @@ arguments in the resulting string.
 Date and time formatting
 ------------------------
 
-The library supports `strftime <http://en.cppreference.com/w/cpp/chrono/c/strftime>`_-like
+The library supports `strftime
-date and time formatting::
+<http://en.cppreference.com/w/cpp/chrono/c/strftime>`_-like date and time
+formatting::
 
   #include "fmt/time.h"
 
@@ -52,6 +58,36 @@ date and time formatting::
 The format string syntax is described in the documentation of
 `strftime <http://en.cppreference.com/w/cpp/chrono/c/strftime>`_.
 
+Formatting user-defined types
+-----------------------------
+
+A custom ``format_arg`` function may be implemented and used to format any
+user-defined type. That is how date and time formatting described in the
+previous section is implemented in :file:`fmt/time.h`. The following example
+shows how to implement custom formatting for a user-defined structure.
+
+::
+
+  struct MyStruct { double a, b; };
+
+  void format_arg(fmt::BasicFormatter<char> &f,
+    const char *&format_str, const MyStruct &s) {
+    f.writer().write("[MyStruct: a={:.1f}, b={:.2f}]", s.a, s.b);
+  }
+
+  MyStruct m = { 1, 2 };
+  std::string s = fmt::format("m={}", n);
+  // s == "m=[MyStruct: a=1.0, b=2.00]"
+
+Note in the example above the ``format_arg`` function ignores the contents of
+``format_str`` so the type will always be formatted as specified. See
+``format_arg`` in :file:`fmt/time.h` for an advanced example of how to use
+the ``format_str`` argument to customize the formatted output.
+
+This section shows how to define a custom format function for a user-defined
+type. The next section describes how to get ``fmt`` to use a conventional stream
+output ``operator<<`` when one is defined for a user-defined type.
+
 ``std::ostream`` support
 ------------------------
 
@@ -63,7 +99,7 @@ formatting of user-defined types that have overloaded ``operator<<``::
   class Date {
     int year_, month_, day_;
   public:
-    Date(int year, int month, int day) : year_(year), month_(month), day_(day) {}
+    Date(int year, int month, int day): year_(year), month_(month), day_(day) {}
 
     friend std::ostream &operator<<(std::ostream &os, const Date &d) {
       return os << d.year_ << '-' << d.month_ << '-' << d.day_;
@@ -75,8 +111,6 @@ formatting of user-defined types that have overloaded ``operator<<``::
 
 .. doxygenfunction:: print(std::ostream&, CStringRef, ArgList)
 
-.. doxygenfunction:: fprintf(std::ostream&, CStringRef, ArgList)
-
 Argument formatters
 -------------------
 
@@ -86,7 +120,7 @@ custom argument formatter class::
   // A custom argument formatter that formats negative integers as unsigned
   // with the ``x`` format specifier.
   class CustomArgFormatter :
-    public fmt::BasicArgFormatter<CustomArgFormatter, char>  {
+    public fmt::BasicArgFormatter<CustomArgFormatter, char> {
     public:
     CustomArgFormatter(fmt::BasicFormatter<char, CustomArgFormatter> &f,
                        fmt::FormatSpec &s, const char *fmt)
@@ -120,22 +154,43 @@ custom argument formatter class::
 .. doxygenclass:: fmt::ArgFormatter
    :members:
 
-Printf formatting functions
+Printf formatting
----------------------------
+-----------------
 
+The header ``fmt/printf.h`` provides ``printf``-like formatting functionality.
 The following functions use `printf format string syntax
 <http://pubs.opengroup.org/onlinepubs/009695399/functions/fprintf.html>`_ with
-a POSIX extension for positional arguments.
+the POSIX extension for positional arguments. Unlike their standard
+counterparts, the ``fmt`` functions are type-safe and throw an exception if an
+argument type doesn't match its format specification.
 
 .. doxygenfunction:: printf(CStringRef, ArgList)
 
 .. doxygenfunction:: fprintf(std::FILE *, CStringRef, ArgList)
 
+.. doxygenfunction:: fprintf(std::ostream&, CStringRef, ArgList)
+
 .. doxygenfunction:: sprintf(CStringRef, ArgList)
 
+.. doxygenclass:: fmt::PrintfFormatter
+   :members:
+
+.. doxygenclass:: fmt::BasicPrintfArgFormatter
+   :members:
+
+.. doxygenclass:: fmt::PrintfArgFormatter
+   :members:
+
 Write API
 =========
 
+The write API provides classes for writing formatted data into character
+streams. It is usually faster than the `format API`_ but, as IOStreams,
+may result in larger compiled code size. The main writer class is
+`~fmt::BasicMemoryWriter` which stores its output in a memory buffer and
+provides direct access to it. It is possible to create custom writers that
+store output elsewhere by subclassing `~fmt::BasicWriter`.
+
 .. doxygenclass:: fmt::BasicWriter
    :members:
 
@@ -145,6 +200,12 @@ Write API
 .. doxygenclass:: fmt::BasicArrayWriter
    :members:
 
+.. doxygenclass:: fmt::BasicStringWriter
+   :members:
+
+.. doxygenclass:: fmt::BasicContainerWriter
+   :members:
+
 .. doxygenfunction:: bin(int)
 
 .. doxygenfunction:: oct(int)
@@ -169,6 +230,8 @@ Utilities
 .. doxygenclass:: fmt::ArgList
    :members:
 
+.. doxygenfunction:: fmt::to_string(const T&)
+
 .. doxygenclass:: fmt::BasicStringRef
    :members:
 
@@ -185,6 +248,8 @@ System errors
 .. doxygenclass:: fmt::SystemError
    :members:
 
+.. doxygenfunction:: fmt::format_system_error
+
 .. doxygenclass:: fmt::WindowsError
    :members:
 
@@ -202,7 +267,8 @@ A custom allocator class can be specified as a template argument to
 It is also possible to write a formatting function that uses a custom
 allocator::
 
-    typedef std::basic_string<char, std::char_traits<char>, CustomAllocator> CustomString;
+    typedef std::basic_string<char, std::char_traits<char>, CustomAllocator>
+            CustomString;
 
     CustomString format(CustomAllocator alloc, fmt::CStringRef format_str,
                         fmt::ArgList args) {

libs/format/doc/basic-bootstrap/layout.html

@@ -90,7 +90,8 @@
         VERSION:     '{{ release|e }}',
         COLLAPSE_INDEX: false,
         FILE_SUFFIX: '{{ '' if no_search_suffix else file_suffix }}',
-        HAS_SOURCE:  {{ has_source|lower }}
+        HAS_SOURCE:  {{ has_source|lower }},
+        SOURCELINK_SUFFIX:  '{{ sourcelink_suffix }}'
       };
     </script>
     {%- for scriptfile in script_files %}

libs/format/doc/build.py

@@ -8,30 +8,35 @@ from distutils.version import LooseVersion
 
 def pip_install(package, commit=None, **kwargs):
   "Install package using pip."
+  min_version = kwargs.get('min_version')
+  if min_version:
+    from pkg_resources import get_distribution, DistributionNotFound
+    try:
+      installed_version = get_distribution(os.path.basename(package)).version
+      if LooseVersion(installed_version) >= min_version:
+        print('{} {} already installed'.format(package, min_version))
+        return
+    except DistributionNotFound:
+      pass
   if commit:
-    check_version = kwargs.get('check_version', '')
+    package = 'git+https://github.com/{0}.git@{1}'.format(package, commit)
-    #output = check_output(['pip', 'show', package.split('/')[1]])
+  print('Installing {0}'.format(package))
-    #if check_version in output:
+  check_call(['pip', 'install', package])
-    #  print('{} already installed'.format(package))
-    #  return
-    package = 'git+git://github.com/{0}.git@{1}'.format(package, commit)
-  print('Installing {}'.format(package))
-  check_call(['pip', 'install', '--upgrade', package])
 
-def build_docs(version='dev'):
+def create_build_env(dirname='virtualenv'):
   # Create virtualenv.
-  doc_dir = os.path.dirname(os.path.realpath(__file__))
+  if not os.path.exists(dirname):
-  virtualenv_dir = 'virtualenv'
+    check_call(['virtualenv', dirname])
-  check_call(['virtualenv', virtualenv_dir])
   import sysconfig
   scripts_dir = os.path.basename(sysconfig.get_path('scripts'))
-  activate_this_file = os.path.join(virtualenv_dir, scripts_dir,
+  activate_this_file = os.path.join(dirname, scripts_dir, 'activate_this.py')
-                                    'activate_this.py')
   with open(activate_this_file) as f:
     exec(f.read(), dict(__file__=activate_this_file))
+  # Import get_distribution after activating virtualenv to get info about
+  # the correct packages.
+  from pkg_resources import get_distribution, DistributionNotFound
   # Upgrade pip because installation of sphinx with pip 1.1 available on Travis
   # is broken (see #207) and it doesn't support the show command.
-  from pkg_resources import get_distribution, DistributionNotFound
   pip_version = get_distribution('pip').version
   if LooseVersion(pip_version) < LooseVersion('1.5.4'):
     print("Updating pip")
@@ -46,27 +51,35 @@ def build_docs(version='dev'):
   except DistributionNotFound:
     pass
   # Install Sphinx and Breathe.
-  pip_install('fmtlib/sphinx',
+  pip_install('sphinx-doc/sphinx', '12b83372ac9316e8cbe86e7fed889296a4cc29ee',
-              '12dde8afdb0a7bb5576e2656692c3478c69d8cc3',
+              min_version='1.4.1.dev20160531')
-              check_version='1.4a0.dev-20151013')
   pip_install('michaeljones/breathe',
-              '1c9d7f80378a92cffa755084823a78bb38ee4acc')
+              '6b1c5bb7a1866f15fc328b8716258354b10c1daa',
+              min_version='4.2.0')
+
+def build_docs(version='dev', **kwargs):
+  doc_dir = kwargs.get('doc_dir', os.path.dirname(os.path.realpath(__file__)))
+  work_dir = kwargs.get('work_dir', '.')
+  include_dir = kwargs.get('include_dir',
+                           os.path.join(os.path.dirname(doc_dir), 'fmt'))
   # Build docs.
   cmd = ['doxygen', '-']
   p = Popen(cmd, stdin=PIPE)
+  doxyxml_dir = os.path.join(work_dir, 'doxyxml')
   p.communicate(input=r'''
       PROJECT_NAME      = fmt
       GENERATE_LATEX    = NO
       GENERATE_MAN      = NO
       GENERATE_RTF      = NO
       CASE_SENSE_NAMES  = NO
-      INPUT             = {0}/format.h {0}/ostream.h
+      INPUT             = {0}/container.h {0}/format.h {0}/ostream.h \
+                          {0}/printf.h {0}/string.h
       QUIET             = YES
       JAVADOC_AUTOBRIEF = YES
       AUTOLINK_SUPPORT  = NO
       GENERATE_HTML     = NO
       GENERATE_XML      = YES
-      XML_OUTPUT        = doxyxml
+      XML_OUTPUT        = {1}
       ALIASES           = "rst=\verbatim embed:rst"
       ALIASES          += "endrst=\endverbatim"
       MACRO_EXPANSION   = YES
@@ -76,24 +89,29 @@ def build_docs(version='dev'):
                           FMT_USE_USER_DEFINED_LITERALS=1 \
                           FMT_API=
       EXCLUDE_SYMBOLS   = fmt::internal::* StringValue write_str
-    '''.format(os.path.join(os.path.dirname(doc_dir), 'fmt')).encode('UTF-8'))
+    '''.format(include_dir, doxyxml_dir).encode('UTF-8'))
   if p.returncode != 0:
     raise CalledProcessError(p.returncode, cmd)
+  html_dir = os.path.join(work_dir, 'html')
+  versions = ['3.0.0', '2.0.0', '1.1.0']
   check_call(['sphinx-build',
-              '-Dbreathe_projects.format=' + os.path.join(os.getcwd(), 'doxyxml'),
+              '-Dbreathe_projects.format=' + os.path.abspath(doxyxml_dir),
-              '-Dversion=' + version, '-Drelease=' + version, '-Aversion=' + version,
+              '-Dversion=' + version, '-Drelease=' + version,
-              '-b', 'html', doc_dir, 'html'])
+              '-Aversion=' + version, '-Aversions=' + ','.join(versions),
+              '-b', 'html', doc_dir, html_dir])
   try:
     check_call(['lessc', '--clean-css',
                 '--include-path=' + os.path.join(doc_dir, 'bootstrap'),
                 os.path.join(doc_dir, 'fmt.less'),
-                'html/_static/fmt.css'])
+                os.path.join(html_dir, '_static', 'fmt.css')])
   except OSError as e:
     if e.errno != errno.ENOENT:
       raise
-    print('lessc not found; make sure that Less (http://lesscss.org/) is installed')
+    print('lessc not found; make sure that Less (http://lesscss.org/) ' +
+          'is installed')
     sys.exit(1)
-  return 'html'
+  return html_dir
 
 if __name__ == '__main__':
+  create_build_env()
   build_docs(sys.argv[1])

libs/format/doc/conf.py

@@ -228,8 +228,7 @@ latex_documents = [
 # One entry per manual page. List of tuples
 # (source start file, name, description, authors, manual section).
 man_pages = [
-    ('index', 'format', u'format Documentation',
+    ('index', 'fmt', u'fmt documentation', [u'Victor Zverovich'], 1)
-     [u'Victor Zverovich'], 1)
 ]
 
 # If true, show URL addresses after external links.
@@ -242,8 +241,8 @@ man_pages = [
 # (source start file, target name, title, author,
 #  dir menu entry, description, category)
 texinfo_documents = [
-  ('index', 'format', u'format Documentation',
+  ('index', 'fmt', u'fmt documentation',
-   u'Victor Zverovich', 'format', 'One line description of project.',
+   u'Victor Zverovich', 'fmt', 'One line description of project.',
    'Miscellaneous'),
 ]
 

libs/format/doc/html/_sources/api.txt

@@ -11,8 +11,8 @@ namespace is usually omitted in examples.
 Format API
 ==========
 
-The following functions use :ref:`format string syntax <syntax>` similar
+The following functions defined in ``fmt/format.h`` use :ref:`format string
-to the one used by Python's `str.format
+syntax <syntax>` similar to the one used by Python's `str.format
 <http://docs.python.org/3/library/stdtypes.html#str.format>`_ function.
 They take *format_str* and *args* as arguments.
 
@@ -22,6 +22,11 @@ arguments in the resulting string.
 
 *args* is an argument list representing arbitrary arguments.
 
+The `performance of the format API
+<https://github.com/fmtlib/fmt/blob/master/README.rst#speed-tests>`_ is close
+to that of glibc's ``printf`` and better than the performance of IOStreams.
+For even better speed use the `write API`_.
+
 .. _format:
 
 .. doxygenfunction:: format(CStringRef, ArgList)
@@ -40,8 +45,9 @@ arguments in the resulting string.
 Date and time formatting
 ------------------------
 
-The library supports `strftime <http://en.cppreference.com/w/cpp/chrono/c/strftime>`_-like
+The library supports `strftime
-date and time formatting::
+<http://en.cppreference.com/w/cpp/chrono/c/strftime>`_-like date and time
+formatting::
 
   #include "fmt/time.h"
 
@@ -52,6 +58,36 @@ date and time formatting::
 The format string syntax is described in the documentation of
 `strftime <http://en.cppreference.com/w/cpp/chrono/c/strftime>`_.
 
+Formatting user-defined types
+-----------------------------
+
+A custom ``format_arg`` function may be implemented and used to format any
+user-defined type. That is how date and time formatting described in the
+previous section is implemented in :file:`fmt/time.h`. The following example
+shows how to implement custom formatting for a user-defined structure.
+
+::
+
+  struct MyStruct { double a, b; };
+
+  void format_arg(fmt::BasicFormatter<char> &f,
+    const char *&format_str, const MyStruct &s) {
+    f.writer().write("[MyStruct: a={:.1f}, b={:.2f}]", s.a, s.b);
+  }
+
+  MyStruct m = { 1, 2 };
+  std::string s = fmt::format("m={}", n);
+  // s == "m=[MyStruct: a=1.0, b=2.00]"
+
+Note in the example above the ``format_arg`` function ignores the contents of
+``format_str`` so the type will always be formatted as specified. See
+``format_arg`` in :file:`fmt/time.h` for an advanced example of how to use
+the ``format_str`` argument to customize the formatted output.
+
+This section shows how to define a custom format function for a user-defined
+type. The next section describes how to get ``fmt`` to use a conventional stream
+output ``operator<<`` when one is defined for a user-defined type.
+
 ``std::ostream`` support
 ------------------------
 
@@ -63,7 +99,7 @@ formatting of user-defined types that have overloaded ``operator<<``::
   class Date {
     int year_, month_, day_;
   public:
-    Date(int year, int month, int day) : year_(year), month_(month), day_(day) {}
+    Date(int year, int month, int day): year_(year), month_(month), day_(day) {}
 
     friend std::ostream &operator<<(std::ostream &os, const Date &d) {
       return os << d.year_ << '-' << d.month_ << '-' << d.day_;
@@ -75,8 +111,6 @@ formatting of user-defined types that have overloaded ``operator<<``::
 
 .. doxygenfunction:: print(std::ostream&, CStringRef, ArgList)
 
-.. doxygenfunction:: fprintf(std::ostream&, CStringRef, ArgList)
-
 Argument formatters
 -------------------
 
@@ -86,7 +120,7 @@ custom argument formatter class::
   // A custom argument formatter that formats negative integers as unsigned
   // with the ``x`` format specifier.
   class CustomArgFormatter :
-    public fmt::BasicArgFormatter<CustomArgFormatter, char>  {
+    public fmt::BasicArgFormatter<CustomArgFormatter, char> {
     public:
     CustomArgFormatter(fmt::BasicFormatter<char, CustomArgFormatter> &f,
                        fmt::FormatSpec &s, const char *fmt)
@@ -120,22 +154,43 @@ custom argument formatter class::
 .. doxygenclass:: fmt::ArgFormatter
    :members:
 
-Printf formatting functions
+Printf formatting
----------------------------
+-----------------
 
+The header ``fmt/printf.h`` provides ``printf``-like formatting functionality.
 The following functions use `printf format string syntax
 <http://pubs.opengroup.org/onlinepubs/009695399/functions/fprintf.html>`_ with
-a POSIX extension for positional arguments.
+the POSIX extension for positional arguments. Unlike their standard
+counterparts, the ``fmt`` functions are type-safe and throw an exception if an
+argument type doesn't match its format specification.
 
 .. doxygenfunction:: printf(CStringRef, ArgList)
 
 .. doxygenfunction:: fprintf(std::FILE *, CStringRef, ArgList)
 
+.. doxygenfunction:: fprintf(std::ostream&, CStringRef, ArgList)
+
 .. doxygenfunction:: sprintf(CStringRef, ArgList)
 
+.. doxygenclass:: fmt::PrintfFormatter
+   :members:
+
+.. doxygenclass:: fmt::BasicPrintfArgFormatter
+   :members:
+
+.. doxygenclass:: fmt::PrintfArgFormatter
+   :members:
+
 Write API
 =========
 
+The write API provides classes for writing formatted data into character
+streams. It is usually faster than the `format API`_ but, as IOStreams,
+may result in larger compiled code size. The main writer class is
+`~fmt::BasicMemoryWriter` which stores its output in a memory buffer and
+provides direct access to it. It is possible to create custom writers that
+store output elsewhere by subclassing `~fmt::BasicWriter`.
+
 .. doxygenclass:: fmt::BasicWriter
    :members:
 
@@ -145,6 +200,12 @@ Write API
 .. doxygenclass:: fmt::BasicArrayWriter
    :members:
 
+.. doxygenclass:: fmt::BasicStringWriter
+   :members:
+
+.. doxygenclass:: fmt::BasicContainerWriter
+   :members:
+
 .. doxygenfunction:: bin(int)
 
 .. doxygenfunction:: oct(int)
@@ -169,6 +230,8 @@ Utilities
 .. doxygenclass:: fmt::ArgList
    :members:
 
+.. doxygenfunction:: fmt::to_string(const T&)
+
 .. doxygenclass:: fmt::BasicStringRef
    :members:
 
@@ -185,6 +248,8 @@ System errors
 .. doxygenclass:: fmt::SystemError
    :members:
 
+.. doxygenfunction:: fmt::format_system_error
+
 .. doxygenclass:: fmt::WindowsError
    :members:
 
@@ -202,7 +267,8 @@ A custom allocator class can be specified as a template argument to
 It is also possible to write a formatting function that uses a custom
 allocator::
 
-    typedef std::basic_string<char, std::char_traits<char>, CustomAllocator> CustomString;
+    typedef std::basic_string<char, std::char_traits<char>, CustomAllocator>
+            CustomString;
 
     CustomString format(CustomAllocator alloc, fmt::CStringRef format_str,
                         fmt::ArgList args) {