Exports continue, mob and some constants

The server code is unsigned for bad reasons :P

.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")
@@ -279,6 +261,9 @@ IF(EQEMU_BUILD_PERL)
 ENDIF(EQEMU_BUILD_PERL)
 IF(EQEMU_BUILD_LUA)
 	ADD_DEFINITIONS(-DLUA_EQEMU)
+	IF(MSVC) 
+		ADD_DEFINITIONS(/bigobj)
+	ENDIF()
 ENDIF(EQEMU_BUILD_LUA)
 
 OPTION(EQEMU_USE_MAP_MMFS "Create and use Zone Map MMF files." OFF)
@@ -342,7 +327,8 @@ IF(EQEMU_BUILD_LUA)
 
 	FIND_PACKAGE(Boost REQUIRED)
 	INCLUDE_DIRECTORIES(SYSTEM "${LUA_INCLUDE_DIR}" "${Boost_INCLUDE_DIRS}")
-	INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/luabind")
+	INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/libs/luabind")
+	INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/libs/sol")
 
 	OPTION(EQEMU_SANITIZE_LUA_LIBS "Sanitize Lua Libraries (Remove OS and IO standard libraries from being able to run)." ON)
 	IF(EQEMU_SANITIZE_LUA_LIBS)

GPL.txt

@@ -1,339 +0,0 @@
-		    GNU GENERAL PUBLIC LICENSE
-		       Version 2, June 1991
-
- Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
- 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-			    Preamble
-
-  The licenses for most software are designed to take away your
-freedom to share and change it.  By contrast, the GNU General Public
-License is intended to guarantee your freedom to share and change free
-software--to make sure the software is free for all its users.  This
-General Public License applies to most of the Free Software
-Foundation's software and to any other program whose authors commit to
-using it.  (Some other Free Software Foundation software is covered by
-the GNU Lesser General Public License instead.)  You can apply it to
-your programs, too.
-
-  When we speak of free software, we are referring to freedom, not
-price.  Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-this service 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.
-
-  To protect your rights, we need to make restrictions that forbid
-anyone to deny you these rights or to ask you to surrender the rights.
-These restrictions translate to certain responsibilities for you if you
-distribute copies of the software, or if you modify it.
-
-  For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must give the recipients all the rights that
-you have.  You must make sure that they, too, receive or can get the
-source code.  And you must show them these terms so they know their
-rights.
-
-  We protect your rights with two steps: (1) copyright the software, and
-(2) offer you this license which gives you legal permission to copy,
-distribute and/or modify the software.
-
-  Also, for each author's protection and ours, we want to make certain
-that everyone understands that there is no warranty for this free
-software.  If the software is modified by someone else and passed on, we
-want its recipients to know that what they have is not the original, so
-that any problems introduced by others will not reflect on the original
-authors' reputations.
-
-  Finally, any free program is threatened constantly by software
-patents.  We wish to avoid the danger that redistributors of a free
-program will individually obtain patent licenses, in effect making the
-program proprietary.  To prevent this, we have made it clear that any
-patent must be licensed for everyone's free use or not licensed at all.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.
-
-		    GNU GENERAL PUBLIC LICENSE
-   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-
-  0. This License applies to any program or other work which contains
-a notice placed by the copyright holder saying it may be distributed
-under the terms of this General Public License.  The "Program", below,
-refers to any such program or work, and a "work based on the Program"
-means either the Program or any derivative work under copyright law:
-that is to say, a work containing the Program or a portion of it,
-either verbatim or with modifications and/or translated into another
-language.  (Hereinafter, translation is included without limitation in
-the term "modification".)  Each licensee is addressed as "you".
-
-Activities other than copying, distribution and modification are not
-covered by this License; they are outside its scope.  The act of
-running the Program is not restricted, and the output from the Program
-is covered only if its contents constitute a work based on the
-Program (independent of having been made by running the Program).
-Whether that is true depends on what the Program does.
-
-  1. You may copy and distribute verbatim copies of the Program's
-source code as you receive it, in any medium, provided that you
-conspicuously and appropriately publish on each copy an appropriate
-copyright notice and disclaimer of warranty; keep intact all the
-notices that refer to this License and to the absence of any warranty;
-and give any other recipients of the Program a copy of this License
-along with the Program.
-
-You may charge a fee for the physical act of transferring a copy, and
-you may at your option offer warranty protection in exchange for a fee.
-
-  2. You may modify your copy or copies of the Program or any portion
-of it, thus forming a work based on the Program, and copy and
-distribute such modifications or work under the terms of Section 1
-above, provided that you also meet all of these conditions:
-
-    a) You must cause the modified files to carry prominent notices
-    stating that you changed the files and the date of any change.
-
-    b) You must cause any work that you distribute or publish, that in
-    whole or in part contains or is derived from the Program or any
-    part thereof, to be licensed as a whole at no charge to all third
-    parties under the terms of this License.
-
-    c) If the modified program normally reads commands interactively
-    when run, you must cause it, when started running for such
-    interactive use in the most ordinary way, to print or display an
-    announcement including an appropriate copyright notice and a
-    notice that there is no warranty (or else, saying that you provide
-    a warranty) and that users may redistribute the program under
-    these conditions, and telling the user how to view a copy of this
-    License.  (Exception: if the Program itself is interactive but
-    does not normally print such an announcement, your work based on
-    the Program is not required to print an announcement.)
-
-These requirements apply to the modified work as a whole.  If
-identifiable sections of that work are not derived from the Program,
-and can be reasonably considered independent and separate works in
-themselves, then this License, and its terms, do not apply to those
-sections when you distribute them as separate works.  But when you
-distribute the same sections as part of a whole which is a work based
-on the Program, the distribution of the whole must be on the terms of
-this License, whose permissions for other licensees extend to the
-entire whole, and thus to each and every part regardless of who wrote it.
-
-Thus, it is not the intent of this section to claim rights or contest
-your rights to work written entirely by you; rather, the intent is to
-exercise the right to control the distribution of derivative or
-collective works based on the Program.
-
-In addition, mere aggregation of another work not based on the Program
-with the Program (or with a work based on the Program) on a volume of
-a storage or distribution medium does not bring the other work under
-the scope of this License.
-
-  3. You may copy and distribute the Program (or a work based on it,
-under Section 2) in object code or executable form under the terms of
-Sections 1 and 2 above provided that you also do one of the following:
-
-    a) Accompany it with the complete corresponding machine-readable
-    source code, which must be distributed under the terms of Sections
-    1 and 2 above on a medium customarily used for software interchange; or,
-
-    b) Accompany it with a written offer, valid for at least three
-    years, to give any third party, for a charge no more than your
-    cost of physically performing source distribution, a complete
-    machine-readable copy of the corresponding source code, to be
-    distributed under the terms of Sections 1 and 2 above on a medium
-    customarily used for software interchange; or,
-
-    c) Accompany it with the information you received as to the offer
-    to distribute corresponding source code.  (This alternative is
-    allowed only for noncommercial distribution and only if you
-    received the program in object code or executable form with such
-    an offer, in accord with Subsection b above.)
-
-The source code for a work means the preferred form of the work for
-making modifications to it.  For an executable work, complete source
-code means all the source code for all modules it contains, plus any
-associated interface definition files, plus the scripts used to
-control compilation and installation of the executable.  However, as a
-special exception, the source code distributed need not include
-anything that is normally distributed (in either source or binary
-form) with the major components (compiler, kernel, and so on) of the
-operating system on which the executable runs, unless that component
-itself accompanies the executable.
-
-If distribution of executable or object code is made by offering
-access to copy from a designated place, then offering equivalent
-access to copy the source code from the same place counts as
-distribution of the source code, even though third parties are not
-compelled to copy the source along with the object code.
-
-  4. You may not copy, modify, sublicense, or distribute the Program
-except as expressly provided under this License.  Any attempt
-otherwise to copy, modify, sublicense or distribute the Program is
-void, and will automatically terminate your rights under this License.
-However, parties who have received copies, or rights, from you under
-this License will not have their licenses terminated so long as such
-parties remain in full compliance.
-
-  5. You are not required to accept this License, since you have not
-signed it.  However, nothing else grants you permission to modify or
-distribute the Program or its derivative works.  These actions are
-prohibited by law if you do not accept this License.  Therefore, by
-modifying or distributing the Program (or any work based on the
-Program), you indicate your acceptance of this License to do so, and
-all its terms and conditions for copying, distributing or modifying
-the Program or works based on it.
-
-  6. Each time you redistribute the Program (or any work based on the
-Program), the recipient automatically receives a license from the
-original licensor to copy, distribute or modify the Program subject to
-these terms and conditions.  You may not impose any further
-restrictions on the recipients' exercise of the rights granted herein.
-You are not responsible for enforcing compliance by third parties to
-this License.
-
-  7. If, as a consequence of a court judgment or allegation of patent
-infringement or for any other reason (not limited to patent issues),
-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
-distribute so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you
-may not distribute the Program at all.  For example, if a patent
-license would not permit royalty-free redistribution of the Program by
-all those who receive copies directly or indirectly through you, then
-the only way you could satisfy both it and this License would be to
-refrain entirely from distribution of the Program.
-
-If any portion of this section is held invalid or unenforceable under
-any particular circumstance, the balance of the section is intended to
-apply and the section as a whole is intended to apply in other
-circumstances.
-
-It is not the purpose of this section to induce you to infringe any
-patents or other property right claims or to contest validity of any
-such claims; this section has the sole purpose of protecting the
-integrity of the free software distribution system, which is
-implemented by public license practices.  Many people have made
-generous contributions to the wide range of software distributed
-through that system in reliance on consistent application of that
-system; it is up to the author/donor to decide if he or she is willing
-to distribute software through any other system and a licensee cannot
-impose that choice.
-
-This section is intended to make thoroughly clear what is believed to
-be a consequence of the rest of this License.
-
-  8. If the distribution and/or use of the Program is restricted in
-certain countries either by patents or by copyrighted interfaces, the
-original copyright holder who places the Program under this License
-may add an explicit geographical distribution limitation excluding
-those countries, so that distribution is permitted only in or among
-countries not thus excluded.  In such case, this License incorporates
-the limitation as if written in the body of this License.
-
-  9. The Free Software Foundation may publish revised and/or new versions
-of the 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 a version number of this License which applies to it and "any
-later version", you have the option of following the terms and conditions
-either of that version or of any later version published by the Free
-Software Foundation.  If the Program does not specify a version number of
-this License, you may choose any version ever published by the Free Software
-Foundation.
-
-  10. If you wish to incorporate parts of the Program into other free
-programs whose distribution conditions are different, write to the author
-to ask for permission.  For software which is copyrighted by the Free
-Software Foundation, write to the Free Software Foundation; we sometimes
-make exceptions for this.  Our decision will be guided by the two goals
-of preserving the free status of all derivatives of our free software and
-of promoting the sharing and reuse of software generally.
-
-			    NO WARRANTY
-
-  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, 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.
-
-  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
-REDISTRIBUTE 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.
-
-		     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
-convey 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 2 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, write to the Free Software Foundation, Inc.,
-    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-Also add information on how to contact you by electronic and paper mail.
-
-If the program is interactive, make it output a short notice like this
-when it starts in an interactive mode:
-
-    Gnomovision version 69, Copyright (C) year name of author
-    Gnomovision 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, the commands you use may
-be called something other than `show w' and `show c'; they could even be
-mouse-clicks or menu items--whatever suits your program.
-
-You should also get your employer (if you work as a programmer) or your
-school, if any, to sign a "copyright disclaimer" for the program, if
-necessary.  Here is a sample; alter the names:
-
-  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
-  `Gnomovision' (which makes passes at compilers) written by James Hacker.
-
-  <signature of Ty Coon>, 1 April 1989
-  Ty Coon, President of Vice
-
-This 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.

LICENSE

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

LICENSE.md

@@ -1,12 +0,0 @@
-The server code and utilities are released under GPLv3.
-
-We also include some small libraries for convienence that may be under different licensing:
-
-SocketLib - GPL
-LibXML - ZLib License
-StackWalker - New BSD License
-ZLib - ZLib License
-MySQL - GPL
-Perl - GPL / ActiveState (under the assumption that this is a free project).
-CPPUnit - GLP
-StringUtilities - Apache

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)   |
 
 ***
 
@@ -17,10 +17,7 @@
 |:---:|:---:|:---:|
 |**Install Count**|![Windows Install Count](http://analytics.akkadius.com/?install_count&windows_count)|![Linux Install Count](http://analytics.akkadius.com/?install_count&linux_count)| 
 ### > Windows 
-* [Easy Install](http://wiki.eqemulator.org/p?Akkas_PEQ_Server_Installer&frm=Main#from-scratch-installation-instructions-windows)
+* [Install](https://github.com/EQEmu/Server/wiki/Windows-Server)
-* [Advanced Setup](http://wiki.eqemulator.org/p?Complete_Windows-based_Server_Setup_Guide)
-
-
 
 ### > Debian/Ubuntu/CentOS/Fedora
 * You can use curl or wget to kick off the installer (whichever your OS has)
@@ -53,7 +50,23 @@ forum, although pull requests will be much quicker and easier on all parties.
  - **User Discord Channel**: `#general`
  - **Developer Discord Channel**: `#eqemucoders`
 
-Resources
+## Resources
----
 - [EQEmulator Forums](http://www.eqemulator.org/forums)
-- [EQEmulator Wiki](http://wiki.eqemulator.org/i?M=Wiki)
+- [EQEmulator Wiki](https://github.com/EQEmu/Server/wiki)
+
+## Related Repositories
+* [ProjectEQ Quests](https://github.com/ProjectEQ/projecteqquests)
+* [Maps](https://github.com/Akkadius/EQEmuMaps)
+* [Installer Resources](https://github.com/Akkadius/EQEmuInstall)
+* [Zone Utilities](https://github.com/EQEmu/zone-utilities) - Various utilities and libraries for parsing, rendering and manipulating EQ Zone files.
+
+## Other License Info
+
+* The server code and utilities are released under **GPLv3**
+* We also include some small libraries for convienence that may be under different licensing
+  * SocketLib - GPL LibXML
+  * zlib - zlib license
+  * MariaDB/MySQL - GPL
+  * GPL Perl - GPL / ActiveState (under the assumption that this is a free project)
+  * CPPUnit - GLP StringUtilities - Apache
+  * LUA - MIT

appveyor-bots.yml

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

appveyor-no-bots.yml

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

changelog.txt

@@ -1,5 +1,146 @@
 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
+	- Currently, you will need to manually re-join channels
+
+== 03/04/2018 ==
+Uleat: Updated UCS versioning
+	- SoF and higher clients have a new opcode identified (update your *.conf files)
+	- Rework of previous ucs connectivity code
+	- Unrelated: Zone::weatherSend() now takes an optional parameter for singular updates (as in client entering zone)
+	-- prior to this, every client already in-zone received a weather update packet whenever a new client zoned in
+
+== 02/18/2018 ==
+Uleat: Bug reporting fix and overhaul.
+	- Fixed bug reporting for SoD+ clients
+	- Added ability to disable bug reporting (set rule 'Bugs:ReportingSystemActive' to 'false')
+	- Implemented a more detailed reporting system (set rule 'Bugs:UseOldReportingMethod' to 'false')
+	-- New system is not currently compatible with script-based monitoring
+	- Soft-removal of defunct 'Petition Bug' system
+
+== 02/14/2018 ==
+mackal: Fix Heading -- Quests broken
+
+Please report any other issues with heading, most things were tested and worked
+
+You can use eqemu_server.pl to run a conversion to fix your headings in quests.
+Some may need manual review.
+
+== 02/10/2018 ==
+mackal: Add Global Loot system
+
+This will allow us to implement global loot similarly to how it works on live
+This system reuses our current loottable tables which the global_loot table references.
+The limits for the rules to govern if a table should be rolled are min level, max level, rare,
+raid, race, class, bodytype, and zone
+
+race, class, bodytype, and zone are a pipe | separated list of IDs.
+
+== 01/31/2018 ==
+Uleat: Re-work of Bot::AI_Process(). Overall behavior is much improved.
+	- Removed a 'ton' of unneeded packet updates
+	- Added a 'leash' to the distance a bot can travel
+	- Added a 'main assist' feature to target control (set using group roles)
+	- Added combat 'jitter' movement to complement the existing rogue movement
+	- Attack can now be aborted if target contains no leash owner nor bot hate and leash owner turns off auto-attack
+	- Please report any issues with the bot AI code
+	
+Added a work-around for heal rotations crashing the server - under certain conditions.
+
+== 01/28/2018 ==
+Mackal: Spell AI tweaks
+
+AI spells are treated as "innate" spells (devs use this term, and I think this is what they mean by it)
+These spells are spammed by the NPC, lots of encounters on live work like this and this will greatly reduce
+the need to do quest scripting on these types of encounters.
+
+You can safely run update npc_spells_entries set priority = priority + 1 where priority >= 0; if you want to disable this new behavior
+
+== 10/08/2017 ==
+Mackal: Rework regens
+
+Regen will now match whats reported by modern clients, besides where they lie due to known bugs
+
+HP and END regens are now based on the BaseData.txt values allowing easy customization
+Those cases:
+	- The client always applies hunger penalties, it appears they don't exist anymore on live you can turn them on with a rule
+	- The way the client gets buff mana/end regen benefits incorrectly applies the bard mod making these values lie sometimes
+
+== 9/17/2017 ==
+Akkadius: Add model/race offset to FixZ calc (KLS)
+Akkadius: Fix 95% of food/water consumption issues, if there are additional modifiers for race/class combos - those will need to be applied
+
+Stages should be put in place if not already:
+https://wiki.project1999.com/Food_and_drink#Stages_of_Hunger_and_Thirst
+
+Values stored in the database are 0-6000, previously we capped it at 6000 but previous math would have normal values in the 60k+ range in order for food to be consumed at a reasonable rate. We are now using more native logic where 1 = 1 minute, following logic:
+
+(Minutes)
+0 -  5	- This is a snack.
+6 -  20	- This is a meal.
+21 - 30	- This is a hearty meal.
+31 - 40	- This is a banquet size meal.
+41 - 50	- This meal is a feast!
+51 - 60	- This is an enduring meal!
+61 - X	- This is a miraculous meal!
 
 == 7/14/2017 ==
 Akkadius: HP Update tuning - HP Updates are now forced when a client is targeted

common/CMakeLists.txt

@@ -14,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
@@ -61,6 +60,7 @@ SET(common_sources
 	rdtsc.cpp
 	rulesys.cpp
 	say_link.cpp
+	serialize_buffer.cpp
 	serverinfo.cpp
 	shareddb.cpp
 	skills.cpp
@@ -124,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
@@ -192,6 +191,7 @@ SET(common_headers
 	ruletypes.h
 	say_link.h
 	seperator.h
+	serialize_buffer.h
 	serverinfo.h
 	servertalk.h
 	shareddb.h

common/base_data.h

@@ -24,8 +24,8 @@ struct BaseDataStruct
 	double base_hp;
 	double base_mana;
 	double base_end;
-	double unk1;
+	double hp_regen;
-	double unk2;
+	double end_regen;
 	double hp_factor;
 	double mana_factor;
 	double endurance_factor;

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/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];
@@ -472,16 +475,6 @@ bool Database::CheckDatabaseConversions() {
 	CheckDatabaseConvertPPDeblob();
 	CheckDatabaseConvertCorpseDeblob();
 
-	/* Fetch EQEmu Server script */
-	if (!std::ifstream("eqemu_server.pl")){
-		std::cout << "Pulling down automatic database upgrade script..." << std::endl;
-#ifdef _WIN32
-		system("perl -MLWP::UserAgent -e \"require LWP::UserAgent;  my $ua = LWP::UserAgent->new; $ua->timeout(10); $ua->env_proxy; my $response = $ua->get('https://raw.githubusercontent.com/EQEmu/Server/master/utils/scripts/eqemu_server.pl'); if ($response->is_success){ open(FILE, '> eqemu_server.pl'); print FILE $response->decoded_content; close(FILE); }\"");
-#else
-		system("wget --no-check-certificate -O eqemu_server.pl https://raw.githubusercontent.com/EQEmu/Server/master/utils/scripts/eqemu_server.pl");
-#endif
-	}
-
 	/* Run EQEmu Server script (Checks for database updates) */
 	system("perl eqemu_server.pl ran_from_world");
 
@@ -1415,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

@@ -18,3 +18,103 @@
 */
 
 #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:
+		return "Video";
+	case catAudio:
+		return "Audio";
+	case catPathing:
+		return "Pathing";
+	case catQuest:
+		return "Quest";
+	case catTradeskills:
+		return "Tradeskills";
+	case catSpellStacking:
+		return "Spell stacking";
+	case catDoorsPortals:
+		return "Doors/Portals";
+	case catItems:
+		return "Items";
+	case catNPC:
+		return "NPC";
+	case catDialogs:
+		return "Dialogs";
+	case catLoNTCG:
+		return "LoN - TCG";
+	case catMercenaries:
+		return "Mercenaries";
+	case catOther:
+	default:
+		return "Other";
+	}
+}
+
+EQEmu::bug::CategoryID EQEmu::bug::CategoryNameToCategoryID(const char* category_name) {
+	if (!category_name)
+		return catOther;
+
+	if (!strcmp(category_name, "Video"))
+		return catVideo;
+	if (!strcmp(category_name, "Audio"))
+		return catAudio;
+	if (!strcmp(category_name, "Pathing"))
+		return catPathing;
+	if (!strcmp(category_name, "Quest"))
+		return catQuest;
+	if (!strcmp(category_name, "Tradeskills"))
+		return catTradeskills;
+	if (!strcmp(category_name, "Spell stacking"))
+		return catSpellStacking;
+	if (!strcmp(category_name, "Doors/Portals"))
+		return catDoorsPortals;
+	if (!strcmp(category_name, "Items"))
+		return catItems;
+	if (!strcmp(category_name, "NPC"))
+		return catNPC;
+	if (!strcmp(category_name, "Dialogs"))
+		return catDialogs;
+	if (!strcmp(category_name, "LoN - TCG"))
+		return catLoNTCG;
+	if (!strcmp(category_name, "Mercenaries"))
+		return catMercenaries;
+	
+	return catOther;
+}

common/emu_constants.h

@@ -21,100 +21,173 @@
 #define COMMON_EMU_CONSTANTS_H
 
 #include "eq_limits.h"
-#include "emu_legacy.h"
 #include "emu_versions.h"
 
-#include <string>
+#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 SayLinkBodySize = RoF2::constants::SayLinkBodySize;
+		using RoF2::invtype::POSSESSIONS_SIZE;
+		using RoF2::invtype::BANK_SIZE;
+		using RoF2::invtype::SHARED_BANK_SIZE;
+		using RoF2::invtype::TRADE_SIZE;
+		using RoF2::invtype::WORLD_SIZE;
+		using RoF2::invtype::LIMBO_SIZE;
+		using RoF2::invtype::TRIBUTE_SIZE;
+		using RoF2::invtype::TROPHY_TRIBUTE_SIZE;
+		using RoF2::invtype::GUILD_TRIBUTE_SIZE;
+		using RoF2::invtype::MERCHANT_SIZE;
+		using RoF2::invtype::DELETED_SIZE;
+		using RoF2::invtype::CORPSE_SIZE;
+		using RoF2::invtype::BAZAAR_SIZE;
+		using RoF2::invtype::INSPECT_SIZE;
+		using RoF2::invtype::REAL_ESTATE_SIZE;
+		using RoF2::invtype::VIEW_MOD_PC_SIZE;
+		using RoF2::invtype::VIEW_MOD_BANK_SIZE;
+		using RoF2::invtype::VIEW_MOD_SHARED_BANK_SIZE;
+		using RoF2::invtype::VIEW_MOD_LIMBO_SIZE;
+		using RoF2::invtype::ALT_STORAGE_SIZE;
+		using RoF2::invtype::ARCHIVED_SIZE;
+		using RoF2::invtype::MAIL_SIZE;
+		using RoF2::invtype::GUILD_TROPHY_TRIBUTE_SIZE;
+		using RoF2::invtype::KRONO_SIZE;
+		using RoF2::invtype::OTHER_SIZE;
+
+		using Titanium::invtype::TRADE_NPC_SIZE;
+
+		using RoF2::invtype::TYPE_INVALID;
+		using RoF2::invtype::TYPE_BEGIN;
+		using RoF2::invtype::TYPE_END;
+		using RoF2::invtype::TYPE_COUNT;
+
+		int16 GetInvTypeSize(int16 inv_type);
+		using RoF2::invtype::GetInvTypeName;
+
+	} // namespace invtype
+
+	namespace invslot {
+		using namespace Titanium::invslot::enum_;
+
+		const int16 SLOT_POWER_SOURCE = 9999;
+
+		using RoF2::invslot::SLOT_INVALID;
+		using RoF2::invslot::SLOT_BEGIN;
+
+		using Titanium::invslot::POSSESSIONS_BEGIN;
+		using Titanium::invslot::POSSESSIONS_END;
+		using SoF::invslot::POSSESSIONS_COUNT;
+
+		using Titanium::invslot::EQUIPMENT_BEGIN;
+		using Titanium::invslot::EQUIPMENT_END;
+		using Titanium::invslot::EQUIPMENT_COUNT;
+
+		using Titanium::invslot::GENERAL_BEGIN;
+		using Titanium::invslot::GENERAL_END;
+		using Titanium::invslot::GENERAL_COUNT;
+
+		using Titanium::invslot::BONUS_BEGIN;
+		using Titanium::invslot::BONUS_STAT_END;
+		using Titanium::invslot::BONUS_SKILL_END;
+
+		using Titanium::invslot::BANK_BEGIN;
+		using SoF::invslot::BANK_END;
+
+		using Titanium::invslot::SHARED_BANK_BEGIN;
+		using Titanium::invslot::SHARED_BANK_END;
+
+		using Titanium::invslot::TRADE_BEGIN;
+		using Titanium::invslot::TRADE_END;
+
+		using Titanium::invslot::TRADE_NPC_END;
+
+		using Titanium::invslot::WORLD_BEGIN;
+		using Titanium::invslot::WORLD_END;
+
+		using Titanium::invslot::TRIBUTE_BEGIN;
+		using Titanium::invslot::TRIBUTE_END;
+
+		using Titanium::invslot::GUILD_TRIBUTE_BEGIN;
+		using Titanium::invslot::GUILD_TRIBUTE_END;
+
+		const int16 CORPSE_BEGIN = invslot::slotGeneral1;
+		const int16 CORPSE_END = CORPSE_BEGIN + invslot::slotCursor;
+
+		using RoF2::invslot::POSSESSIONS_BITMASK;
+		using RoF2::invslot::CORPSE_BITMASK;
+
+		using RoF2::invslot::GetInvPossessionsSlotName;
+		using RoF2::invslot::GetInvSlotName;
+
+	} // namespace invslot
+
+	namespace invbag {
+		using Titanium::invbag::SLOT_INVALID;
+		using Titanium::invbag::SLOT_BEGIN;
+		using Titanium::invbag::SLOT_END;
+		using Titanium::invbag::SLOT_COUNT;
+
+		using Titanium::invbag::GENERAL_BAGS_BEGIN;
+		const int16 GENERAL_BAGS_COUNT = invslot::GENERAL_COUNT * SLOT_COUNT;
+		const int16 GENERAL_BAGS_END = (GENERAL_BAGS_BEGIN + GENERAL_BAGS_COUNT) - 1;
+
+		const int16 GENERAL_BAGS_8_COUNT = 8 * SLOT_COUNT;
+		const int16 GENERAL_BAGS_8_END = (GENERAL_BAGS_BEGIN + GENERAL_BAGS_8_COUNT) - 1;
+
+		const int16 CURSOR_BAG_BEGIN = 331;
+		const int16 CURSOR_BAG_COUNT = SLOT_COUNT;
+		const int16 CURSOR_BAG_END = (CURSOR_BAG_BEGIN + CURSOR_BAG_COUNT) - 1;
+
+		using Titanium::invbag::BANK_BAGS_BEGIN;
+		const int16 BANK_BAGS_COUNT = (invtype::BANK_SIZE * SLOT_COUNT);
+		const int16 BANK_BAGS_END = (BANK_BAGS_BEGIN + BANK_BAGS_COUNT) - 1;
+
+		const int16 BANK_BAGS_16_COUNT = 16 * SLOT_COUNT;
+		const int16 BANK_BAGS_16_END = (BANK_BAGS_BEGIN + BANK_BAGS_16_COUNT) - 1;
+
+		using Titanium::invbag::SHARED_BANK_BAGS_BEGIN;
+		const int16 SHARED_BANK_BAGS_COUNT = invtype::SHARED_BANK_SIZE * SLOT_COUNT;
+		const int16 SHARED_BANK_BAGS_END = (SHARED_BANK_BAGS_BEGIN + SHARED_BANK_BAGS_COUNT) - 1;
+
+		using Titanium::invbag::TRADE_BAGS_BEGIN;
+		const int16 TRADE_BAGS_COUNT = invtype::TRADE_SIZE * SLOT_COUNT;
+		const int16 TRADE_BAGS_END = (TRADE_BAGS_BEGIN + TRADE_BAGS_COUNT) - 1;
+
+		using Titanium::invbag::GetInvBagIndexName;
+
+	} // namespace invbag
+
+	namespace invaug {
+		using RoF2::invaug::SOCKET_INVALID;
+		using RoF2::invaug::SOCKET_BEGIN;
+		using RoF2::invaug::SOCKET_END;
+		using RoF2::invaug::SOCKET_COUNT;
+
+		using RoF2::invaug::GetInvAugIndexName;
+
+	} // namespace invaug
+
+	namespace constants {
+		const EQEmu::versions::ClientVersion CHARACTER_CREATION_CLIENT = EQEmu::versions::ClientVersion::Titanium;
+
+		using RoF2::constants::CHARACTER_CREATION_LIMIT;
+		
+		const size_t SAY_LINK_OPENER_SIZE = 1;
+		using RoF2::constants::SAY_LINK_BODY_SIZE;
+		const size_t SAY_LINK_TEXT_SIZE = 256; // this may be varied until it breaks something (tested:374) - the others are constant
+		const size_t SAY_LINK_CLOSER_SIZE = 1;
+		const size_t SAY_LINK_MAXIMUM_SIZE = (SAY_LINK_OPENER_SIZE + SAY_LINK_BODY_SIZE + SAY_LINK_TEXT_SIZE + SAY_LINK_CLOSER_SIZE);
 
 		const int LongBuffs = RoF2::constants::LongBuffs;
 		const int ShortBuffs = RoF2::constants::ShortBuffs;
@@ -126,6 +199,52 @@ 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,
+			catVideo,
+			catAudio,
+			catPathing,
+			catQuest,
+			catTradeskills,
+			catSpellStacking,
+			catDoorsPortals,
+			catItems,
+			catNPC,
+			catDialogs,
+			catLoNTCG,
+			catMercenaries
+		};
+
+		enum OptionalInfoFlag : uint32 {
+			infoNoOptionalInfo = 0x0,
+			infoCanDuplicate = 0x1,
+			infoCrashBug = 0x2,
+			infoTargetInfo = 0x4,
+			infoCharacterFlags = 0x8,
+			infoUnknownValue = 0xFFFFFFF0
+		};
+
+		const char* CategoryIDToCategoryName(CategoryID category_id);
+		CategoryID CategoryNameToCategoryID(const char* category_name);
+
+	} // namespace bug
+
 	enum class CastingSlot : uint32 {
 		Gem1       = 0,
 		Gem2       = 1,

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_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;
-
-		static const size_t TEXT_LINK_BODY_LENGTH = 56;
-	}
-
-}
-
-#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/emu_oplist.h

@@ -9,6 +9,7 @@ N(OP_AcceptNewTask),
 N(OP_AckPacket),
 N(OP_Action),
 N(OP_Action2),
+N(OP_AddNimbusEffect),
 N(OP_AdventureData),
 N(OP_AdventureDetails),
 N(OP_AdventureFinish),
@@ -339,6 +340,7 @@ N(OP_MOTD),
 N(OP_MoveCoin),
 N(OP_MoveDoor),
 N(OP_MoveItem),
+N(OP_MoveMultipleItems),
 N(OP_MoveLogDisregard),
 N(OP_MoveLogRequest),
 N(OP_MultiLineMsg),
@@ -391,6 +393,7 @@ N(OP_PVPLeaderBoardReply),
 N(OP_PVPLeaderBoardRequest),
 N(OP_PVPStats),
 N(OP_QueryResponseThing),
+N(OP_QueryUCSServerStatus),
 N(OP_RaidInvite),
 N(OP_RaidJoin),
 N(OP_RaidUpdate),

common/emu_versions.h

@@ -28,7 +28,7 @@
 namespace EQEmu
 {
 	namespace versions {
-		enum class ClientVersion {
+		enum class ClientVersion : uint32 {
 			Unknown = 0,
 			Client62,	// Build: 'Aug  4 2005 15:40:59'
 			Titanium,	// Build: 'Oct 31 2005 10:33:37'
@@ -72,7 +72,7 @@ namespace EQEmu
 		uint32 ConvertClientVersionToExpansion(ClientVersion client_version);
 
 
-		enum class MobVersion {
+		enum class MobVersion : uint32 {
 			Unknown = 0,
 			Client62,
 			Titanium,
@@ -121,6 +121,20 @@ namespace EQEmu
 		ClientVersion ConvertOfflinePCMobVersionToClientVersion(MobVersion mob_version);
 		MobVersion ConvertClientVersionToOfflinePCMobVersion(ClientVersion client_version);
 
+
+		enum UCSVersion : char {
+			ucsUnknown = '\0',
+			ucsClient62Chat = 'A',
+			ucsClient62Mail = 'a',
+			ucsTitaniumChat = 'B',
+			ucsTitaniumMail = 'b',
+			ucsSoFCombined = 'C',
+			ucsSoDCombined = 'D',
+			ucsUFCombined = 'E',
+			ucsRoFCombined = 'F',
+			ucsRoF2Combined = 'G'
+		};
+
 	} /*versions*/
 
 } /*EQEmu*/

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

@@ -280,7 +280,7 @@ union
 								// horse: 0=brown, 1=white, 2=black, 3=tan
 };
 /*0340*/ uint32 spawnId;		// Spawn Id
-/*0344*/ uint8 unknown0344[3];
+/*0344*/ float bounding_radius; // used in melee, overrides calc
 /*0347*/ uint8 IsMercenary;
 /*0348*/ EQEmu::TintProfile equipment_tint;
 /*0384*/ uint8	lfg;			// 0=off, 1=lfg on
@@ -551,6 +551,7 @@ struct BlockedBuffs_Struct
 /*86*/ uint16 Flags;
 };
 
+// same for adding
 struct RemoveNimbusEffect_Struct
 {
 /*00*/ uint32 spawnid;			// Spawn ID
@@ -730,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
@@ -744,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
@@ -854,6 +855,7 @@ static const uint32 MAX_PP_REF_SPELLBOOK = 480;	// Set for Player Profile size r
 static const uint32 MAX_PP_REF_MEMSPELL = 9; // Set for Player Profile size retain
 
 static const uint32 MAX_PP_SKILL		= PACKET_SKILL_ARRAY_SIZE;	// 100 - actual skills buffer size
+static const uint32 MAX_PP_INNATE_SKILL	= 25;
 static const uint32 MAX_PP_AA_ARRAY		= 240;
 static const uint32 MAX_GROUP_MEMBERS	= 6;
 static const uint32 MAX_RECAST_TYPES	= 20;
@@ -993,7 +995,8 @@ struct PlayerProfile_Struct
 /*4768*/	int32				platinum_shared;	// Platinum shared between characters
 /*4772*/	uint8				unknown4808[24];
 /*4796*/	uint32				skills[MAX_PP_SKILL];	// [400] List of skills	// 100 dword buffer
-/*5196*/	uint8				unknown5132[184];
+/*5196*/	uint32				InnateSkills[MAX_PP_INNATE_SKILL];
+/*5296*/	uint8				unknown5132[84];
 /*5380*/	uint32				pvp2;				//
 /*5384*/	uint32				unknown5420;		//
 /*5388*/	uint32				pvptype;			//
@@ -1046,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];
@@ -1073,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;
@@ -1250,21 +1253,22 @@ struct Action_Struct
 {
  /* 00 */	uint16 target;	// id of target
  /* 02 */	uint16 source;	// id of caster
- /* 04 */	uint16 level; // level of caster
+ /* 04 */	uint16 level; // level of caster for spells, OSX dump says attack rating, guess spells use it for level
- /* 06 */	uint16 instrument_mod;
+ /* 06 */	uint32 instrument_mod; // OSX dump says base damage, spells use it for bard song (different from newer clients)
- /* 08 */	uint32 bard_focus_id;
+ /* 10 */	float force;
- /* 12 */	uint16 unknown16;
+ /* 14 */	float hit_heading;
-// some kind of sequence that's the same in both actions
+ /* 18 */	float hit_pitch;
-// as well as the combat damage, to tie em together?
+ /* 22 */	uint8 type;		// 231 (0xE7) for spells, skill
- /* 14 */	uint32 sequence;
+ /* 23 */	uint16 unknown23; // OSX says min_damage
- /* 18 */	uint32 unknown18;
+ /* 25 */	uint16 unknown25; // OSX says tohit
- /* 22 */	uint8 type;		// 231 (0xE7) for spells
- /* 23 */	uint32 unknown23;
  /* 27 */	uint16 spell;	// spell id being cast
- /* 29 */	uint8 unknown29;
+ /* 29 */	uint8 spell_level;
 // this field seems to be some sort of success flag, if it's 4
- /* 30 */	uint8 buff_unknown;	// if this is 4, a buff icon is made
+ /* 30 */	uint8 effect_flag;	// if this is 4, a buff icon is made
- /* 31 */
+// newer clients have some data for setting LaunchSpellData when effect_flag & 4
+// /* 31 */	uint8 spell_gem;
+// /* 32 */	uint32 inventory_slot;
+// /* 36 */	uint32 item_cast_type;
 };
 
 // this is what prints the You have been struck. and the regular
@@ -1274,12 +1278,12 @@ struct CombatDamage_Struct
 {
 /* 00 */	uint16	target;
 /* 02 */	uint16	source;
-/* 04 */	uint8	type; //slashing, etc. 231 (0xE7) for spells
+/* 04 */	uint8	type; //slashing, etc. 231 (0xE7) for spells, skill
 /* 05 */	uint16	spellid;
 /* 07 */	uint32	damage;
 /* 11 */	float force;
-/* 15 */	float meleepush_xy;	// see above notes in Action_Struct
+/* 15 */	float hit_heading;	// see above notes in Action_Struct
-/* 19 */	float meleepush_z;
+/* 19 */	float hit_pitch;
 /* 23 */	uint32 special; // 2 = Rampage, 1 = Wild Rampage
 };
 
@@ -1779,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;
@@ -3320,23 +3333,32 @@ struct GuildMakeLeader{
 	char	target[64];
 };
 
-struct BugStruct{
+struct BugReport_Struct {
-/*0000*/	char	chartype[64];
+/*0000*/	uint32	category_id;
-/*0064*/	char	name[96];
+/*0004*/	char	category_name[64];
-/*0160*/	char	ui[128];
+/*0068*/	char	reporter_name[64];
-/*0288*/	float	x;
+/*0132*/	char	unused_0132[32];
-/*0292*/	float	y;
+/*0164*/	char	ui_path[128];
-/*0296*/	float	z;
+/*0292*/	float	pos_x;
-/*0300*/	float	heading;
+/*0296*/	float	pos_y;
-/*0304*/	uint32	unknown304;
+/*0300*/	float	pos_z;
-/*0308*/	char	unknown308[160];
+/*0304*/	uint32	heading;
-/*0468*/	char	target_name[64];
+/*0308*/	uint32	unused_0308;
-/*0532*/	uint32	type;
+/*0312*/	uint32	time_played;
-/*0536*/	char	unknown536[2052];
+/*0316*/	char	padding_0316[8];
-/*2584*/	char	bug[2048];
+/*0324*/	uint32	target_id;
-/*4632*/	char	unknown4632[6];
+/*0328*/	char	padding_0328[140];
-/*4638*/	char	system_info[4094];
+/*0468*/	uint32	unknown_0468;	// seems to always be '0'
+/*0472*/	char	target_name[64];
+/*0536*/	uint32	optional_info_mask;
+
+// this looks like a butchered 8k buffer with 2 trailing dword fields
+/*0540*/	char	unused_0540[2052];
+/*2592*/	char	bug_report[2050];
+/*4642*/	char	system_info[4098];
+/*8740*/
 };
+
 struct Make_Pet_Struct { //Simple struct for getting pet info
 	uint8 level;
 	uint8 class_;
@@ -3363,20 +3385,21 @@ struct Ground_Spawn{
 struct Ground_Spawns {
 	struct Ground_Spawn spawn[50]; //Assigned max number to allow
 };
-struct PetitionBug_Struct{
+
-	uint32	petition_number;
+//struct PetitionBug_Struct{
-	uint32	unknown4;
+//	uint32	petition_number;
-	char	accountname[64];
+//	uint32	unknown4;
-	uint32	zoneid;
+//	char	accountname[64];
-	char	name[64];
+//	uint32	zoneid;
-	uint32	level;
+//	char	name[64];
-	uint32	class_;
+//	uint32	level;
-	uint32	race;
+//	uint32	class_;
-	uint32	unknown152[3];
+//	uint32	race;
-	uint32	time;
+//	uint32	unknown152[3];
-	uint32	unknown168;
+//	uint32	time;
-	char	text[1028];
+//	uint32	unknown168;
-};
+//	char	text[1028];
+//};
 
 struct ApproveZone_Struct {
 	char	name[64];
@@ -3435,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;
 };
 
@@ -3768,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
@@ -3822,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 {
@@ -3883,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
@@ -4764,6 +4787,7 @@ struct BuffIconEntry_Struct
 	uint32 spell_id;
 	int32 tics_remaining;
 	uint32 num_hits;
+	char caster[64];
 };
 
 struct BuffIcon_Struct
@@ -4773,6 +4797,7 @@ struct BuffIcon_Struct
 	uint16 count;
 	uint8 type; // 0 = self buff window, 1 = self target window, 4 = group, 5 = PC, 7 = NPC
 	int32 tic_timer;
+	int32 name_lengths; // so ahh we kind of do these packets hacky, this is the total length of all the names to make creating the real packets in the translators easier
 	BuffIconEntry_Struct entries[0];
 };
 
@@ -5351,6 +5376,23 @@ struct AuraDestory_Struct {
 };
 // I think we can assume it's just action for 2, client doesn't seem to do anything with the rest of the data in that case
 
+struct SayLinkBodyFrame_Struct {
+/*000*/	char ActionID[1];
+/*001*/	char ItemID[5];
+/*006*/	char Augment1[5];
+/*011*/	char Augment2[5];
+/*016*/	char Augment3[5];
+/*021*/	char Augment4[5];
+/*026*/	char Augment5[5];
+/*031*/	char Augment6[5];
+/*036*/	char IsEvolving[1];
+/*037*/	char EvolveGroup[4];
+/*041*/	char EvolveLevel[2];
+/*043*/	char OrnamentIcon[5];
+/*048*/	char Hash[8];
+/*056*/
+};
+
 // Restore structure packing to default
 #pragma pack()
 

common/eqemu_config.cpp

@@ -23,351 +23,112 @@
 #include <iostream>
 #include <sstream>
 
-std::string EQEmuConfig::ConfigFile = "eqemu_config.xml";
+std::string EQEmuConfig::ConfigFile = "eqemu_config.json";
 EQEmuConfig *EQEmuConfig::_config = nullptr;
 
-void EQEmuConfig::do_world(TiXmlElement *ele)
+void EQEmuConfig::parse_config() {
-{
+	
-	const char *text;
+	ShortName = _root["server"]["world"].get("shortname", "").asString();
-	TiXmlElement * sub_ele;;
+	LongName = _root["server"]["world"].get("longname", "").asString();
-	text = ParseTextBlock(ele, "shortname");
+	WorldAddress = _root["server"]["world"].get("address", "").asString();
-	if (text) {
+	LocalAddress = _root["server"]["world"].get("localaddress", "").asString();
-		ShortName = text;
+	MaxClients = atoi(_root["server"]["world"].get("maxclients", "-1").asString().c_str());
-	}
+	SharedKey = _root["server"]["world"].get("key", "").asString();
-	text = ParseTextBlock(ele, "longname");
+	LoginCount = 0;
-	if (text) {
+
-		LongName = text;
+	if (_root["server"]["world"]["loginserver"].isObject()) {
-	}
+		LoginHost = _root["server"]["world"]["loginserver"].get("host", "login.eqemulator.net").asString();
-	text = ParseTextBlock(ele, "address", true);
+		LoginPort = atoi(_root["server"]["world"]["loginserver"].get("port", "5998").asString().c_str());
-	if (text) {
+		LoginLegacy = false;
-		WorldAddress = text;
+		if (_root["server"]["world"]["loginserver"].get("legacy", "0").asString() == "1") LoginLegacy = true;
-	}
+		LoginAccount = _root["server"]["world"]["loginserver"].get("account", "").asString();
-	text = ParseTextBlock(ele, "localaddress", true);
+		LoginPassword = _root["server"]["world"]["loginserver"].get("password", "").asString();
-	if (text) {
-		LocalAddress = text;
-	}
-	text = ParseTextBlock(ele, "maxclients", true);
-	if (text) {
-		MaxClients = atoi(text);
-	}
-	// Get the <key> element
-	text = ParseTextBlock(ele, "key", true);
-	if (text) {
-		SharedKey = text;
-	}
-	// Get the <loginserver> element
-	sub_ele = ele->FirstChildElement("loginserver");
-	if (sub_ele) {
-		text = ParseTextBlock(sub_ele, "host", true);
-		if (text) {
-			LoginHost = text;
-		}
-		text = ParseTextBlock(sub_ele, "port", true);
-		if (text) {
-			LoginPort = atoi(text);
-		}
-		text = ParseTextBlock(sub_ele, "legacy", true);
-		if (text) {
-			LoginLegacy = atoi(text) > 0 ? true : false;
-		}
-		text = ParseTextBlock(sub_ele, "account", true);
-		if (text) {
-			LoginAccount = text;
-		}
-		text = ParseTextBlock(sub_ele, "password", true);
-		if (text) {
-			LoginPassword = text;
-		}
 	} else {
 		char str[32];
+		loginlist.Clear();
 		do {
 			sprintf(str, "loginserver%i", ++LoginCount);
-			sub_ele = ele->FirstChildElement(str);
+			if (!_root["server"]["world"][str].isObject()) {
-			if (sub_ele) {
+				break;
+			}
+
 			auto loginconfig = new LoginConfig;
-				text = ParseTextBlock(sub_ele, "host", true);
+			loginconfig->LoginHost = _root["server"]["world"][str].get("host", "login.eqemulator.net").asString();
-				if (text) {
+			loginconfig->LoginPort = atoi(_root["server"]["world"][str].get("port", "5998").asString().c_str());
-					loginconfig->LoginHost = text;
+			loginconfig->LoginAccount = _root["server"]["world"][str].get("account", "").asString();
-				}
+			loginconfig->LoginPassword = _root["server"]["world"][str].get("password", "").asString();
-				text = ParseTextBlock(sub_ele, "port", true);
+
-				if (text) {
+			loginconfig->LoginLegacy = false;
-					loginconfig->LoginPort = atoi(text);
+			if (_root["server"]["world"][str].get("legacy", "0").asString() == "1") loginconfig->LoginLegacy = true;
-				}
-				text = ParseTextBlock(sub_ele, "legacy", true);
-				if (text) {
-					loginconfig->LoginLegacy = atoi(text) > 0 ? true : false;
-				}
-				text = ParseTextBlock(sub_ele, "account", true);
-				if (text) {
-					loginconfig->LoginAccount = text;
-				}
-				text = ParseTextBlock(sub_ele, "password", true);
-				if (text) {
-					loginconfig->LoginPassword = text;
-				}
 			loginlist.Insert(loginconfig);
-			}
+		} while (LoginCount < 100);
-		} while (sub_ele);
-	}
-	// Check for locked
-	sub_ele = ele->FirstChildElement("locked");
-	if (sub_ele != nullptr) {
-		Locked = true;
-	}
-	// Get the <tcp> element
-	sub_ele = ele->FirstChildElement("tcp");
-	if (sub_ele != nullptr) {
-		text = sub_ele->Attribute("ip");
-		if (text) {
-			WorldIP = text;
-		}
-		text = sub_ele->Attribute("port");
-		if (text) {
-			WorldTCPPort = atoi(text);
-		}
-	}
-
-	sub_ele = ele->FirstChildElement("telnet");
-	if (sub_ele != nullptr) {
-		text = sub_ele->Attribute("ip");
-		if (text) {
-			TelnetIP = text;
-		}
-		text = sub_ele->Attribute("port");
-		if (text) {
-			TelnetTCPPort = atoi(text);
-		}
-		text = sub_ele->Attribute("enabled");
-		if (text && !strcasecmp(text, "true")) {
-			TelnetEnabled = true;
-		}
-	}
-
-	// Get the <http> element
-	sub_ele = ele->FirstChildElement("http");
-	if (sub_ele != nullptr) {
-//		text = sub_ele->Attribute("ip");
-//		if (text)
-//			WorldIP=text;
-		text = sub_ele->Attribute("mimefile");
-		if (text) {
-			WorldHTTPMimeFile = text;
-		}
-		text = sub_ele->Attribute("port");
-		if (text) {
-			WorldHTTPPort = atoi(text);
-		}
-		text = sub_ele->Attribute("enabled");
-		if (text && !strcasecmp(text, "true")) {
-			WorldHTTPEnabled = true;
-		}
-	}
-}
-
-void EQEmuConfig::do_chatserver(TiXmlElement *ele)
-{
-	const char *text;
-	text = ParseTextBlock(ele, "host", true);
-	if (text) {
-		ChatHost = text;
-	}
-	text = ParseTextBlock(ele, "port", true);
-	if (text) {
-		ChatPort = atoi(text);
-	}
-}
-
-void EQEmuConfig::do_mailserver(TiXmlElement *ele)
-{
-	const char *text;
-	text = ParseTextBlock(ele, "host", true);
-	if (text) {
-		MailHost = text;
-	}
-	text = ParseTextBlock(ele, "port", true);
-	if (text) {
-		MailPort = atoi(text);
-	}
-}
-
-void EQEmuConfig::do_database(TiXmlElement *ele)
-{
-	const char *text;
-	text = ParseTextBlock(ele, "host", true);
-	if (text) {
-		DatabaseHost = text;
-	}
-	text = ParseTextBlock(ele, "port", true);
-	if (text) {
-		DatabasePort = atoi(text);
-	}
-	text = ParseTextBlock(ele, "username", true);
-	if (text) {
-		DatabaseUsername = text;
-	}
-	text = ParseTextBlock(ele, "password", true);
-	if (text) {
-		DatabasePassword = text;
-	}
-	text = ParseTextBlock(ele, "db", true);
-	if (text) {
-		DatabaseDB = text;
-	}
 	}
 	
 	
-void EQEmuConfig::do_qsdatabase(TiXmlElement *ele)
+	//<locked> from xml converts to json as locked: "", so i default to "false". 
-{
+	//The only way to enable locked is by switching to true, meaning this value is always false until manually set true
-	const char *text;
+	Locked = false;
-	text = ParseTextBlock(ele, "host", true);
+	if (_root["server"]["world"].get("locked", "false").asString() == "true") Locked = true;
-	if (text) {
+	WorldIP = _root["server"]["world"]["tcp"].get("host", "127.0.0.1").asString();
-		QSDatabaseHost = text;
+	WorldTCPPort = atoi(_root["server"]["world"]["tcp"].get("port", "9000").asString().c_str());
-	}
-	text = ParseTextBlock(ele, "port", true);
-	if (text) {
-		QSDatabasePort = atoi(text);
-	}
-	text = ParseTextBlock(ele, "username", true);
-	if (text) {
-		QSDatabaseUsername = text;
-	}
-	text = ParseTextBlock(ele, "password", true);
-	if (text) {
-		QSDatabasePassword = text;
-	}
-	text = ParseTextBlock(ele, "db", true);
-	if (text) {
-		QSDatabaseDB = text;
-	}
-}
 	
-void EQEmuConfig::do_zones(TiXmlElement *ele)
+	TelnetIP = _root["server"]["world"]["telnet"].get("ip", "127.0.0.1").asString();
-{
+	TelnetTCPPort = atoi(_root["server"]["world"]["telnet"].get("port", "9001").asString().c_str());
-	const char *text;
+	TelnetEnabled = false;
-	TiXmlElement *sub_ele;
+	if (_root["server"]["world"]["telnet"].get("enabled", "false").asString() == "true") TelnetEnabled = true;
-//	TiXmlNode *node,*sub_node;
-	text = ParseTextBlock(ele, "defaultstatus", true);
-	if (text) {
-		DefaultStatus = atoi(text);
-	}
-	// Get the <ports> element
-	sub_ele = ele->FirstChildElement("ports");
-	if (sub_ele != nullptr) {
-		text = sub_ele->Attribute("low");
-		if (text) {
-			ZonePortLow = atoi(text);
-		};
-		text = sub_ele->Attribute("high");
-		if (text) {
-			ZonePortHigh = atoi(text);
-		}
-	}
-}
 
-void EQEmuConfig::do_files(TiXmlElement *ele)
+	WorldHTTPMimeFile = _root["server"]["world"]["http"].get("mimefile", "mime.types").asString();
-{
+	WorldHTTPPort = atoi(_root["server"]["world"]["http"].get("port", "9080").asString().c_str());
-	const char *text;
+	WorldHTTPEnabled = false;
-	text = ParseTextBlock(ele, "spells", true);
+	if (_root["server"]["world"]["http"].get("enabled", "false").asString() == "true") WorldHTTPEnabled = true;
-	if (text) {
-		SpellsFile = text;
-	}
-	text = ParseTextBlock(ele, "opcodes", true);
-	if (text) {
-		OpCodesFile = text;
-	}
-	text = ParseTextBlock(ele, "plugin.pl", true);
-	if (text) {
-		PluginPlFile = text;
-	}
-}
 
-void EQEmuConfig::do_directories(TiXmlElement *ele)
+	ChatHost = _root["server"]["chatserver"].get("host", "eqchat.eqemulator.net").asString();
-{
+	ChatPort = atoi(_root["server"]["chatserver"].get("port", "7778").asString().c_str());
-	const char *text;
-	text = ParseTextBlock(ele, "maps", true);
-	if (text) {
-		MapDir = text;
-		if ( MapDir.back() != '/' )
-			MapDir += '/';
-	}
-	text = ParseTextBlock(ele, "quests", true);
-	if (text) {
-		QuestDir = text;
-		if ( QuestDir.back() != '/' )
-			QuestDir += '/';
-	}
-	text = ParseTextBlock(ele, "plugins", true);
-	if (text) {
-		PluginDir = text;
-		if ( PluginDir.back() != '/' )
-			PluginDir += '/';
-	}
-	text = ParseTextBlock(ele, "lua_modules", true);
-	if (text) {
-		LuaModuleDir = text;
-		if ( LuaModuleDir.back() != '/' )
-			LuaModuleDir += '/';
-	}
-	text = ParseTextBlock(ele, "patches", true);
-	if (text) {
-		PatchDir = text;
-		if ( PatchDir.back() != '/' )
-			PatchDir += '/';
-	}
-	text = ParseTextBlock(ele, "shared_memory", true);
-	if (text) {
-		SharedMemDir = text;
-		if ( SharedMemDir.back() != '/' )
-			SharedMemDir += '/';
-	}
-	//Not Fully Implemented yet LogDir
-	text = ParseTextBlock(ele, "logs", true);
-	if (text) {
-		LogDir = text;
-		if ( LogDir.back() != '/' )
-			LogDir += '/';
-	}
-}
 
-void EQEmuConfig::do_launcher(TiXmlElement *ele)
+	MailHost = _root["server"]["mailserver"].get("host", "eqmail.eqemulator.net").asString();
-{
+	MailPort = atoi(_root["server"]["mailserver"].get("port", "7778").asString().c_str());
-	const char *text;
-	TiXmlElement *sub_ele;
-	text = ParseTextBlock(ele, "logprefix", true);
-	if (text) {
-		LogPrefix = text;
-	}
-	text = ParseTextBlock(ele, "logsuffix", true);
-	if (text) {
-		LogSuffix = text;
-	}
-	// Get the <exe> element
-	text = ParseTextBlock(ele, "exe", true);
-	if (text) {
-		ZoneExe = text;
-	}
-	// Get the <timers> element
-	sub_ele = ele->FirstChildElement("timers");
-	if (sub_ele != nullptr) {
-		text = sub_ele->Attribute("restart");
-		if (text) {
-			RestartWait = atoi(text);
-		}
-		text = sub_ele->Attribute("reterminate");
-		if (text) {
-			TerminateWait = atoi(text);
-		}
-		text = sub_ele->Attribute("initial");
-		if (text) {
-			InitialBootWait = atoi(text);
-		}
-		text = sub_ele->Attribute("interval");
-		if (text) {
-			ZoneBootInterval = atoi(text);
-		}
-	}
-}
 
+	DatabaseUsername = _root["server"]["database"].get("username", "eq").asString();
+	DatabasePassword = _root["server"]["database"].get("password", "eq").asString();
+	DatabaseHost = _root["server"]["database"].get("host", "localhost").asString();
+	DatabasePort = atoi(_root["server"]["database"].get("port", "3306").asString().c_str());
+	DatabaseDB = _root["server"]["database"].get("db", "eq").asString();	
+
+	QSDatabaseHost = _root["server"]["qsdatabase"].get("host", "localhost").asString();
+	QSDatabasePort = atoi(_root["server"]["qsdatabase"].get("port", "3306").asString().c_str());
+	QSDatabaseUsername = _root["server"]["qsdatabase"].get("username", "eq").asString();
+	QSDatabasePassword = _root["server"]["qsdatabase"].get("password", "eq").asString();
+	QSDatabaseDB = _root["server"]["qsdatabase"].get("db", "eq").asString();
+
+	DefaultStatus = atoi(_root["server"]["zones"].get("defaultstatus", 0).asString().c_str());
+	ZonePortLow = atoi(_root["server"]["zones"]["ports"].get("low", "7000").asString().c_str());
+	ZonePortHigh = atoi(_root["server"]["zones"]["ports"].get("high", "7999").asString().c_str());
+
+	SpellsFile = _root["server"]["files"].get("spells", "spells_us.txt").asString();
+	OpCodesFile = _root["server"]["files"].get("opcodes", "opcodes.conf").asString();
+	PluginPlFile = _root["server"]["files"].get("plugin.pl", "plugin.pl").asString();
+
+	MapDir = _root["server"]["directories"].get("maps", "Maps/").asString();
+	QuestDir = _root["server"]["directories"].get("quests", "quests/").asString();
+	PluginDir = _root["server"]["directories"].get("plugins", "plugins/").asString();
+	LuaModuleDir = _root["server"]["directories"].get("lua_modules", "lua_modules/").asString();
+	PatchDir = _root["server"]["directories"].get("patches", "./").asString();
+	SharedMemDir = _root["server"]["directories"].get("shared_memory", "shared/").asString();
+	LogDir = _root["server"]["directories"].get("logs", "logs/").asString();
+
+	LogPrefix = _root["server"]["launcher"].get("logprefix", "logs/zone-").asString();
+	LogSuffix = _root["server"]["launcher"].get("logsuffix", ".log").asString();
+	RestartWait = atoi(_root["server"]["launcher"]["timers"].get("restart", "10000").asString().c_str());
+	TerminateWait = atoi(_root["server"]["launcher"]["timers"].get("reterminate", "10000").asString().c_str());
+	InitialBootWait = atoi(_root["server"]["launcher"]["timers"].get("initial", "20000").asString().c_str());
+	ZoneBootInterval = atoi(_root["server"]["launcher"]["timers"].get("interval", "2000").asString().c_str());
+#ifdef WIN32
+	ZoneExe = _root["server"]["launcher"].get("exe", "zone.exe").asString();
+#else
+	ZoneExe = _root["server"]["launcher"].get("exe", "./zone").asString();
+#endif
+
+}
 std::string EQEmuConfig::GetByName(const std::string &var_name) const
 {
 	if (var_name == "ShortName") {
@@ -564,4 +325,3 @@ void EQEmuConfig::Dump() const
 	std::cout << "DefaultStatus = " << (int)DefaultStatus << std::endl;
 //	std::cout << "DynamicCount = " << DynamicCount << std::endl;
 }
-

common/eqemu_config.h

@@ -18,8 +18,9 @@
 #ifndef __EQEmuConfig_H
 #define __EQEmuConfig_H
 
-#include "xml_parser.h"
+#include "json/json.h"
 #include "linked_list.h"
+#include <fstream>
 
 struct LoginConfig {
 	std::string LoginHost;
@@ -29,7 +30,7 @@ struct LoginConfig {
 	bool LoginLegacy;
 };
 
-class EQEmuConfig : public XMLParser
+class EQEmuConfig
 {
 	public:
 		virtual std::string GetByName(const std::string &var_name) const;
@@ -115,88 +116,14 @@ class EQEmuConfig : public XMLParser
 	protected:
 
 		static EQEmuConfig *_config;
-
+		Json::Value _root;
 		static std::string ConfigFile;
 
-#define ELEMENT(name) \
+		void parse_config();
-	void do_##name(TiXmlElement *ele);
-#include "eqemu_config_elements.h"
-
 
 		EQEmuConfig()
 		{			
-			// import the needed handler prototypes
-#define ELEMENT(name) \
-	Handlers[#name]=(ElementHandler)&EQEmuConfig::do_##name;
-#include "eqemu_config_elements.h"
-			// Set sane defaults
-			// Login server
-			LoginHost = "login.eqemulator.net";
-			LoginPort = 5998;
-			LoginLegacy = false;
-			// World
-			Locked = false;
-			WorldTCPPort = 9000;
-			TelnetTCPPort = 9001;
-			TelnetEnabled = false;
-			WorldHTTPEnabled = false;
-			WorldHTTPPort = 9080;
-			WorldHTTPMimeFile = "mime.types";
-			SharedKey = "";	//blank disables authentication
-			// Mail
-			ChatHost = "eqchat.eqemulator.net";
-			ChatPort = 7778;
-			// Mail
-			MailHost = "eqmail.eqemulator.net";
-			MailPort = 7779;
-			// Mysql
-			DatabaseHost = "localhost";
-			DatabasePort = 3306;
-			DatabaseUsername = "eq";
-			DatabasePassword = "eq";
-			DatabaseDB = "eq";
-			// QueryServ Database
-			QSDatabaseHost = "localhost";
-			QSDatabasePort = 3306;
-			QSDatabaseUsername = "eq";
-			QSDatabasePassword = "eq";
-			QSDatabaseDB = "eq";
-			// Files
-			SpellsFile = "spells_us.txt";
-			OpCodesFile = "opcodes.conf";
-			PluginPlFile = "plugin.pl";
-			// Dirs
-			MapDir = "Maps/";
-			QuestDir = "quests/";
-			PluginDir = "plugins/";
-			LuaModuleDir = "lua_modules/";
-			PatchDir = "./";
-			SharedMemDir = "shared/";
-			LogDir = "logs/";
 
-			// Launcher
-			LogPrefix = "logs/zone-";
-			LogSuffix = ".log";
-			RestartWait = 10000;		//milliseconds
-			TerminateWait = 10000;		//milliseconds
-			InitialBootWait = 20000;	//milliseconds
-			ZoneBootInterval = 2000;	//milliseconds
-			#ifdef WIN32
-			ZoneExe = "zone.exe";
-			#else
-			ZoneExe = "./zone";
-			#endif
-			// Zones
-			ZonePortLow = 7000;
-			ZonePortHigh = 7999;
-			DefaultStatus = 0;
-			// For where zones need to connect to.
-			WorldIP = "127.0.0.1";
-			TelnetIP = "127.0.0.1";
-			// Dynamics to start
-			//DynamicCount=5;
-			MaxClients = -1;
-			LoginCount = 0;
 		}
 		virtual ~EQEmuConfig() {}
 
@@ -205,9 +132,7 @@ class EQEmuConfig : public XMLParser
 		// Produce a const singleton
 		static const EQEmuConfig *get()
 		{
-			if (_config == nullptr) {
 			LoadConfig();
-			}
 			return (_config);
 		}
 
@@ -221,10 +146,28 @@ class EQEmuConfig : public XMLParser
 		static bool LoadConfig()
 		{
 			if (_config != nullptr) {
-				delete _config;
+				return true;
 			}
 			_config = new EQEmuConfig;
-			return _config->ParseFile(EQEmuConfig::ConfigFile.c_str(), "server");
+
+			return parseFile();
+		}
+
+		// Load config file and parse data
+		static bool parseFile() {
+			if (_config == nullptr) {
+				return LoadConfig();
+			}
+
+			std::ifstream fconfig(EQEmuConfig::ConfigFile, std::ifstream::binary);
+			try {
+				fconfig >> _config->_root;
+				_config->parse_config();
+			}
+			catch (std::exception) {
+				return false;
+			}			
+			return true;
 		}
 
 		void Dump() const;

common/eqemu_logsys.h

@@ -88,6 +88,9 @@ enum LogCategory {
 	Headless_Client,
 	HP_Update,
 	FixZ,
+	Food,
+	Traps,
+	NPCRoamBox,
 	MaxCategoryID	/* Don't Remove this*/
 };
 
@@ -140,7 +143,10 @@ static const char* LogCategoryName[LogCategory::MaxCategoryID] = {
 	"Client Login",
 	"Headless Client",
 	"HP Update",
-	"FixZ"
+	"FixZ",
+	"Food",
+	"Traps",
+	"NPC Roam Box"
 };
 }
 

common/event_sub.cpp

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

common/event_sub.h

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

common/features.h

@@ -154,6 +154,7 @@ enum {	//timer settings, all in milliseconds
 	AIscanarea_delay = 6000,
 	AIfeignremember_delay = 500,
 	AItarget_check_duration = 500,
+	AI_scan_door_open_interval = 1000,
 	// AIClientScanarea_delay = 750,	//used in REVERSE_AGGRO
 	AIassistcheck_delay = 3000,		//now often a fighting NPC will yell for help
 	AI_check_signal_timer_delay = 500, // How often EVENT_SIGNAL checks are processed
@@ -219,6 +220,9 @@ enum {	//some random constants
 //the square of the maximum range at whihc you could possibly use NPC services (shop, tribute, etc)
 #define USE_NPC_RANGE2 200*200		//arbitrary right now
 
+// Squared range for rampage 75.0 * 75.0 for now
+#define NPC_RAMPAGE_RANGE2 5625.0f
+
 //the formula for experience for killing a mob.
 //level is the only valid variable to use
 #define EXP_FORMULA level*level*75*35/10
@@ -276,6 +280,11 @@ enum {
 #define SAYLINK_ITEM_ID 0xFFFFF
 
 
+// consumption timers for food/drink here instead of rules because the client
+// uses these. Times in ms.
+#define CONSUMPTION_TIMER 46000
+#define CONSUMPTION_MNK_TIMER 92000
+
 /*
 
 Developer configuration

common/glm/glm/simd/platform.h

@@ -111,7 +111,8 @@
 #define GLM_COMPILER_GCC70			0x02000A00
 #define GLM_COMPILER_GCC71			0x02000B00
 #define GLM_COMPILER_GCC72			0x02000C00
-#define GLM_COMPILER_GCC80			0x02000D00
+#define GLM_COMPILER_GCC73			0x02000D00
+#define GLM_COMPILER_GCC80			0x02000E00
 
 // CUDA
 #define GLM_COMPILER_CUDA			0x10000000
@@ -283,6 +284,8 @@
 #		define GLM_COMPILER (GLM_COMPILER_GCC71)
 #	elif (__GNUC__ == 7) && (__GNUC_MINOR__ == 2)
 #		define GLM_COMPILER (GLM_COMPILER_GCC72)
+#	elif (__GNUC__ == 7) && (__GNUC_MINOR__ == 3)
+#		define GLM_COMPILER (GLM_COMPILER_GCC73)
 #	elif (__GNUC__ >= 8)
 #		define GLM_COMPILER (GLM_COMPILER_GCC80)
 #	else

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

@@ -194,32 +194,70 @@ uint32 rnd_hash( time_t t, clock_t c )
 
 float EQ13toFloat(int d)
 {
-	return ( float(d)/float(1<<2));
+	return static_cast<float>(d) / 64.0f;
-}
-
-float NewEQ13toFloat(int d)
-{
-	return ( float(d)/float(1<<6));
 }
 
 float EQ19toFloat(int d)
 {
-	return ( float(d)/float(1<<3));
+	return static_cast<float>(d) / 8.0f;
 }
 
 int FloatToEQ13(float d)
 {
-	return int(d*float(1<<2));
+	return static_cast<int>(d * 64.0f);
-}
-
-int NewFloatToEQ13(float d)
-{
-	return int(d*float(1<<6));
 }
 
 int FloatToEQ19(float d)
 {
-	return int(d*float(1<<3));
+	return static_cast<int>(d * 8.0f);
+}
+
+float EQ12toFloat(int d)
+{
+	return static_cast<float>(d) / 4.0f;
+}
+
+int FloatToEQ12(float d)
+{
+	return static_cast<int>((d + 2048.0f) * 4.0f) % 2048;
+}
+
+float EQ10toFloat(int d)
+{
+	return static_cast<float>(d) / 20.0f;
+}
+
+int FloatToEQ10(float d)
+{
+	return static_cast<int>(d * 20.0f);
+}
+
+float EQSpeedRunToFloat(int d)
+{
+	return static_cast<float>(d) / 40.0f;
+}
+
+int FloatToEQSpeedRun(float d)
+{
+	return static_cast<int>(d * 40.0f);
+}
+
+float FixHeading(float in)
+{
+	int i = 0;
+	if (in >= 512.0f) {
+		do {
+			in -= 512.0f;
+		} while (in >= 512.0f && i++ <= 5);
+	}
+	i = 0;
+	if (in < 0.0f) {
+		do {
+			in += 512.0f;
+		} while (in < 0.0f && i++ <= 5);
+	}
+
+	return in;
 }
 
 /*
@@ -237,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

@@ -50,14 +50,26 @@ uint32	ResolveIP(const char* hostname, char* errbuf = 0);
 bool	ParseAddress(const char* iAddress, uint32* oIP, uint16* oPort, char* errbuf = 0);
 void	CoutTimestamp(bool ms = true);
 float EQ13toFloat(int d);
-float NewEQ13toFloat(int d);
 float EQ19toFloat(int d);
 float EQHtoFloat(int d);
 int FloatToEQ13(float d);
-int NewFloatToEQ13(float d);
 int FloatToEQ19(float d);
 int FloatToEQH(float d);
-uint32 SwapBits21and22(uint32 mask);
+
+float EQ12toFloat(int d);
+int FloatToEQ12(float d);
+
+float EQ10toFloat(int d);
+int FloatToEQ10(float d);
+
+// this is also a 10 bit float
+float EQSpeedRunToFloat(int d);
+int FloatToEQSpeedRun(float d);
+
+// brings heading back into EQ angles range
+float FixHeading(float in);
+
+uint32 SwapBits21And22(uint32 mask);
 uint32 Catch22(uint32 mask);
 
 // macro to catch fp errors (provided by noudness)

common/mysql_request_result.h

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

common/net/console_server_connection.cpp

@@ -1,9 +1,9 @@
 #include "console_server.h"
-#include "../common/util/uuid.h"
+#include "../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

@@ -165,7 +165,7 @@ void EQ::Net::DaybreakConnectionManager::ProcessResend()
 {
 	auto iter = m_connections.begin();
 	while (iter != m_connections.end()) {
-		auto connection = iter->second;
+		auto &connection = iter->second;
 		auto status = connection->m_status;
 
 		switch (status)
@@ -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
 		{

common/patches/rof.cpp

@@ -57,11 +57,11 @@ namespace RoF
 	static inline uint32 RoFToServerTypelessSlot(structs::TypelessInventorySlot_Struct rofSlot);
 	static inline uint32 RoFToServerCorpseSlot(uint32 rofCorpseSlot);
 
-	// server to client text link converter
+	// server to client say link converter
-	static inline void ServerToRoFTextLink(std::string& rofTextLink, const std::string& serverTextLink);
+	static inline void ServerToRoFSayLink(std::string& rofSayLink, const std::string& serverSayLink);
 
-	// client to server text link converter
+	// client to server say link converter
-	static inline void RoFToServerTextLink(std::string& serverTextLink, const std::string& rofTextLink);
+	static inline void RoFToServerSayLink(std::string& serverSayLink, const std::string& rofSayLink);
 
 	static inline CastingSlot ServerToRoFCastingSlot(EQEmu::CastingSlot slot);
 	static inline EQEmu::CastingSlot RoFToServerCastingSlot(CastingSlot slot);
@@ -163,22 +163,23 @@ namespace RoF
 		OUT(level);
 		eq->unknown06 = 0;
 		eq->instrument_mod = 1.0f + (emu->instrument_mod - 10) / 10.0f;
-		eq->bard_focus_id = emu->bard_focus_id;
+		OUT(force);
-		eq->knockback_angle = emu->sequence;
+		OUT(hit_heading);
-		eq->unknown22 = 0;
+		OUT(hit_pitch);
 		OUT(type);
 		eq->damage = 0;
 		eq->unknown31 = 0;
 		OUT(spell);
-		eq->level2 = eq->level;
+		OUT(spell_level);
-		eq->effect_flag = emu->buff_unknown;
+		OUT(effect_flag);
-		eq->unknown39 = 14;
+		eq->spell_gem = 0;
-		eq->unknown43 = 0;
+		eq->slot.Type = INVALID_INDEX;
-		eq->unknown44 = 17;
+		eq->slot.Unknown02 = 0;
-		eq->unknown45 = 0;
+		eq->slot.Slot = INVALID_INDEX;
-		eq->unknown46 = -1;
+		eq->slot.SubIndex = INVALID_INDEX;
-		eq->unknown50 = 0;
+		eq->slot.AugIndex = INVALID_INDEX;
-		eq->unknown54 = 0;
+		eq->slot.Unknown01 = 0;
+		eq->item_cast_type = 0;
 
 		FINISH_ENCODE();
 	}
@@ -460,7 +461,7 @@ namespace RoF
 	{
 		SETUP_VAR_ENCODE(BuffIcon_Struct);
 
-		uint32 sz = 12 + (17 * emu->count);
+		uint32 sz = 12 + (17 * emu->count) + emu->name_lengths; // 17 includes nullterm
 		__packet->size = sz;
 		__packet->pBuffer = new unsigned char[sz];
 		memset(__packet->pBuffer, 0, sz);
@@ -476,7 +477,7 @@ namespace RoF
 			__packet->WriteUInt32(emu->entries[i].spell_id);
 			__packet->WriteUInt32(emu->entries[i].tics_remaining);
 			__packet->WriteUInt32(emu->entries[i].num_hits); // Unknown
-			__packet->WriteString("");
+			__packet->WriteString(emu->entries[i].caster);
 		}
 		__packet->WriteUInt8(emu->type); // Unknown
 
@@ -520,7 +521,7 @@ namespace RoF
 
 		std::string old_message = emu->message;
 		std::string new_message;
-		ServerToRoFTextLink(new_message, old_message);
+		ServerToRoFSayLink(new_message, old_message);
 
 		//in->size = strlen(emu->sender) + 1 + strlen(emu->targetname) + 1 + strlen(emu->message) + 1 + 36;
 		in->size = strlen(emu->sender) + strlen(emu->targetname) + new_message.length() + 39;
@@ -659,8 +660,8 @@ namespace RoF
 		OUT(spellid);
 		OUT(damage);
 		OUT(force);
-		OUT(meleepush_xy);
+		OUT(hit_heading);
-		OUT(meleepush_z);
+		OUT(hit_pitch);
 		OUT(special);
 
 		FINISH_ENCODE();
@@ -847,7 +848,7 @@ namespace RoF
 
 		std::string old_message = emu->message;
 		std::string new_message;
-		ServerToRoFTextLink(new_message, old_message);
+		ServerToRoFSayLink(new_message, old_message);
 
 		//if (new_message.length() > 512) // length restricted in packet building function due vari-length name size (no nullterm)
 		//	new_message = new_message.substr(0, 512);
@@ -899,7 +900,7 @@ namespace RoF
 
 		for (int i = 0; i < 9; ++i) {
 			if (old_message_array[i].length() == 0) { break; }
-			ServerToRoFTextLink(new_message_array[i], old_message_array[i]);
+			ServerToRoFSayLink(new_message_array[i], old_message_array[i]);
 			new_message_size += new_message_array[i].length() + 1;
 		}
 
@@ -1862,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.
@@ -2184,11 +2071,11 @@ namespace RoF
 			outapp->WriteUInt32(emu->skills[r]);
 		}
 
-		outapp->WriteUInt32(25);			// Unknown count
+		outapp->WriteUInt32(structs::MAX_PP_INNATE_SKILL);			// Innate Skills count
 
-		for (uint32 r = 0; r < 25; r++)
+		for (uint32 r = 0; r < structs::MAX_PP_INNATE_SKILL; r++)
 		{
-			outapp->WriteUInt32(0);			// Unknown
+			outapp->WriteUInt32(emu->InnateSkills[r]);			// Innate Skills (regen, slam, etc)
 		}
 
 		outapp->WriteUInt32(structs::MAX_PP_DISCIPLINES);	// Discipline count
@@ -2337,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) {
@@ -2355,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) {
@@ -2379,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);
@@ -2500,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);
@@ -2993,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);
@@ -3295,7 +3182,7 @@ namespace RoF
 		std::string old_message = &emu->message[strlen(emu->sayer)];
 		std::string new_message;
 
-		ServerToRoFTextLink(new_message, old_message);
+		ServerToRoFSayLink(new_message, old_message);
 
 		//in->size = 3 + 4 + 4 + strlen(emu->sayer) + 1 + 12 + new_message.length() + 1;
 		in->size = strlen(emu->sayer) + new_message.length() + 25;
@@ -3367,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;
-		ServerToRoFTextLink(new_message, old_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];
 
@@ -3850,6 +3740,9 @@ namespace RoF
 		OUT(zone_reason);
 		OUT(success);
 
+		if (eq->success < 0)
+			eq->success -= 1;
+
 		FINISH_ENCODE();
 	}
 
@@ -4352,7 +4245,7 @@ namespace RoF
 
 		std::string old_message = InBuffer;
 		std::string new_message;
-		RoFToServerTextLink(new_message, old_message);
+		RoFToServerSayLink(new_message, old_message);
 
 		//__packet->size = sizeof(ChannelMessage_Struct)+strlen(InBuffer) + 1;
 		__packet->size = sizeof(ChannelMessage_Struct) + new_message.length() + 1;
@@ -4463,7 +4356,7 @@ namespace RoF
 		IN(type);
 		IN(spellid);
 		IN(damage);
-		IN(meleepush_xy);
+		IN(hit_heading);
 
 		FINISH_DIRECT_DECODE();
 	}
@@ -4486,7 +4379,7 @@ namespace RoF
 
 		std::string old_message = (char *)&__eq_buffer[4]; // unknown01 offset
 		std::string new_message;
-		RoFToServerTextLink(new_message, old_message);
+		RoFToServerSayLink(new_message, old_message);
 
 		__packet->size = sizeof(Emote_Struct);
 		__packet->pBuffer = new unsigned char[__packet->size];
@@ -4807,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);
@@ -5201,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);
@@ -5295,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;
@@ -5389,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];
@@ -5599,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;
 
@@ -5636,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;
 		}
 
@@ -5655,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);
 			}
 
 			/*
@@ -5716,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;
 		}
 
@@ -5737,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
@@ -5757,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);
@@ -5778,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
@@ -5796,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;
@@ -5820,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;
@@ -5832,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;
 
@@ -5846,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;
@@ -5864,7 +5757,7 @@ namespace RoF
 		ServerSlot = TempSlot;
 		}*/
 
-		else if (rofSlot.Type == invtype::InvTypeGuildTribute) {
+		else if (rofSlot.Type == invtype::typeGuildTribute) {
 			ServerSlot = INVALID_INDEX;
 		}
 
@@ -5879,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
@@ -5891,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;
 		}
@@ -5913,19 +5806,19 @@ namespace RoF
 		return (rofCorpseSlot - 1);
 	}
 
-	static inline void ServerToRoFTextLink(std::string& rofTextLink, const std::string& serverTextLink)
+	static inline void ServerToRoFSayLink(std::string& rofSayLink, const std::string& serverSayLink)
 	{
-		if ((constants::SayLinkBodySize == EQEmu::legacy::TEXT_LINK_BODY_LENGTH) || (serverTextLink.find('\x12') == std::string::npos)) {
+		if ((constants::SAY_LINK_BODY_SIZE == EQEmu::constants::SAY_LINK_BODY_SIZE) || (serverSayLink.find('\x12') == std::string::npos)) {
-			rofTextLink = serverTextLink;
+			rofSayLink = serverSayLink;
 			return;
 		}
 
-		auto segments = SplitString(serverTextLink, '\x12');
+		auto segments = SplitString(serverSayLink, '\x12');
 
 		for (size_t segment_iter = 0; segment_iter < segments.size(); ++segment_iter) {
 			if (segment_iter & 1) {
-				if (segments[segment_iter].length() <= EQEmu::legacy::TEXT_LINK_BODY_LENGTH) {
+				if (segments[segment_iter].length() <= EQEmu::constants::SAY_LINK_BODY_SIZE) {
-					rofTextLink.append(segments[segment_iter]);
+					rofSayLink.append(segments[segment_iter]);
 					// TODO: log size mismatch error
 					continue;
 				}
@@ -5935,36 +5828,36 @@ namespace RoF
 				// RoF:  X XXXXX XXXXX XXXXX XXXXX XXXXX XXXXX XXXXX X  XXXX  X XXXXX XXXXXXXX (55)
 				// Diff:                                                     ^
 
-				rofTextLink.push_back('\x12');
+				rofSayLink.push_back('\x12');
-				rofTextLink.append(segments[segment_iter].substr(0, 41));
+				rofSayLink.append(segments[segment_iter].substr(0, 41));
 
 				if (segments[segment_iter][41] == '0')
-					rofTextLink.push_back(segments[segment_iter][42]);
+					rofSayLink.push_back(segments[segment_iter][42]);
 				else
-					rofTextLink.push_back('F');
+					rofSayLink.push_back('F');
 
-				rofTextLink.append(segments[segment_iter].substr(43));
+				rofSayLink.append(segments[segment_iter].substr(43));
-				rofTextLink.push_back('\x12');
+				rofSayLink.push_back('\x12');
 			}
 			else {
-				rofTextLink.append(segments[segment_iter]);
+				rofSayLink.append(segments[segment_iter]);
 			}
 		}
 	}
 
-	static inline void RoFToServerTextLink(std::string& serverTextLink, const std::string& rofTextLink)
+	static inline void RoFToServerSayLink(std::string& serverSayLink, const std::string& rofSayLink)
 	{
-		if ((EQEmu::legacy::TEXT_LINK_BODY_LENGTH == constants::SayLinkBodySize) || (rofTextLink.find('\x12') == std::string::npos)) {
+		if ((EQEmu::constants::SAY_LINK_BODY_SIZE == constants::SAY_LINK_BODY_SIZE) || (rofSayLink.find('\x12') == std::string::npos)) {
-			serverTextLink = rofTextLink;
+			serverSayLink = rofSayLink;
 			return;
 		}
 
-		auto segments = SplitString(rofTextLink, '\x12');
+		auto segments = SplitString(rofSayLink, '\x12');
 
 		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) {
-					serverTextLink.append(segments[segment_iter]);
+					serverSayLink.append(segments[segment_iter]);
 					// TODO: log size mismatch error
 					continue;
 				}
@@ -5974,14 +5867,14 @@ namespace RoF
 				// RoF2: X XXXXX XXXXX XXXXX XXXXX XXXXX XXXXX XXXXX X  XXXX XX  XXXXX XXXXXXXX (56)
 				// Diff:                                                     ^
 
-				serverTextLink.push_back('\x12');
+				serverSayLink.push_back('\x12');
-				serverTextLink.append(segments[segment_iter].substr(0, 41));
+				serverSayLink.append(segments[segment_iter].substr(0, 41));
-				serverTextLink.push_back('0');
+				serverSayLink.push_back('0');
-				serverTextLink.append(segments[segment_iter].substr(41));
+				serverSayLink.append(segments[segment_iter].substr(41));
-				serverTextLink.push_back('\x12');
+				serverSayLink.push_back('\x12');
 			}
 			else {
-				serverTextLink.append(segments[segment_iter]);
+				serverSayLink.append(segments[segment_iter]);
 			}
 		}
 	}

common/patches/rof2.cpp

@@ -57,11 +57,11 @@ namespace RoF2
 	static inline uint32 RoF2ToServerTypelessSlot(structs::TypelessInventorySlot_Struct rof2Slot);
 	static inline uint32 RoF2ToServerCorpseSlot(uint32 rof2CorpseSlot);
 
-	// server to client text link converter
+	// server to client say link converter
-	static inline void ServerToRoF2TextLink(std::string& rof2TextLink, const std::string& serverTextLink);
+	static inline void ServerToRoF2SayLink(std::string& rof2SayLink, const std::string& serverSayLink);
 
-	// client to server text link converter
+	// client to server say link converter
-	static inline void RoF2ToServerTextLink(std::string& serverTextLink, const std::string& rof2TextLink);
+	static inline void RoF2ToServerSayLink(std::string& serverSayLink, const std::string& rof2SayLink);
 
 	static inline CastingSlot ServerToRoF2CastingSlot(EQEmu::CastingSlot slot);
 	static inline EQEmu::CastingSlot RoF2ToServerCastingSlot(CastingSlot slot);
@@ -232,22 +232,23 @@ namespace RoF2
 		OUT(level);
 		eq->unknown06 = 0;
 		eq->instrument_mod = 1.0f + (emu->instrument_mod - 10) / 10.0f;
-		eq->bard_focus_id = emu->bard_focus_id;
+		OUT(force);
-		eq->knockback_angle = emu->sequence;
+		OUT(hit_heading);
-		eq->unknown22 = 0;
+		OUT(hit_pitch);
 		OUT(type);
 		eq->damage = 0;
 		eq->unknown31 = 0;
 		OUT(spell);
-		eq->level2 = eq->level;
+		OUT(spell_level);
-		eq->effect_flag = emu->buff_unknown;
+		OUT(effect_flag);
-		eq->unknown39 = 14;
+		eq->spell_gem = 0;
-		eq->unknown43 = 0;
+		eq->slot.Type = INVALID_INDEX;
-		eq->unknown44 = 17;
+		eq->slot.Unknown02 = 0;
-		eq->unknown45 = 0;
+		eq->slot.Slot = INVALID_INDEX;
-		eq->unknown46 = -1;
+		eq->slot.SubIndex = INVALID_INDEX;
-		eq->unknown50 = 0;
+		eq->slot.AugIndex = INVALID_INDEX;
-		eq->unknown54 = 0;
+		eq->slot.Unknown01 = 0;
+		eq->item_cast_type = 0;
 
 		FINISH_ENCODE();
 	}
@@ -528,7 +529,7 @@ namespace RoF2
 	{
 		SETUP_VAR_ENCODE(BuffIcon_Struct);
 
-		uint32 sz = 12 + (17 * emu->count);
+		uint32 sz = 12 + (17 * emu->count) + emu->name_lengths; // 17 includes nullterm
 		__packet->size = sz;
 		__packet->pBuffer = new unsigned char[sz];
 		memset(__packet->pBuffer, 0, sz);
@@ -544,7 +545,7 @@ namespace RoF2
 			__packet->WriteUInt32(emu->entries[i].spell_id);
 			__packet->WriteUInt32(emu->entries[i].tics_remaining);
 			__packet->WriteUInt32(emu->entries[i].num_hits); // Unknown
-			__packet->WriteString("");
+			__packet->WriteString(emu->entries[i].caster);
 		}
 		__packet->WriteUInt8(emu->type); // Unknown
 
@@ -588,7 +589,7 @@ namespace RoF2
 
 		std::string old_message = emu->message;
 		std::string new_message;
-		ServerToRoF2TextLink(new_message, old_message);
+		ServerToRoF2SayLink(new_message, old_message);
 
 		//in->size = strlen(emu->sender) + 1 + strlen(emu->targetname) + 1 + strlen(emu->message) + 1 + 36;
 		in->size = strlen(emu->sender) + strlen(emu->targetname) + new_message.length() + 39;
@@ -727,8 +728,8 @@ namespace RoF2
 		OUT(spellid);
 		OUT(damage);
 		OUT(force);
-		OUT(meleepush_xy);
+		OUT(hit_heading);
-		OUT(meleepush_z);
+		OUT(hit_pitch);
 		OUT(special);
 
 		FINISH_ENCODE();
@@ -915,7 +916,7 @@ namespace RoF2
 
 		std::string old_message = emu->message;
 		std::string new_message;
-		ServerToRoF2TextLink(new_message, old_message);
+		ServerToRoF2SayLink(new_message, old_message);
 
 		//if (new_message.length() > 512) // length restricted in packet building function due vari-length name size (no nullterm)
 		//	new_message = new_message.substr(0, 512);
@@ -967,7 +968,7 @@ namespace RoF2
 
 		for (int i = 0; i < 9; ++i) {
 			if (old_message_array[i].length() == 0) { break; }
-			ServerToRoF2TextLink(new_message_array[i], old_message_array[i]);
+			ServerToRoF2SayLink(new_message_array[i], old_message_array[i]);
 			new_message_size += new_message_array[i].length() + 1;
 		}
 
@@ -1939,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.
@@ -2261,11 +2148,11 @@ namespace RoF2
 			outapp->WriteUInt32(emu->skills[r]);
 		}
 
-		outapp->WriteUInt32(25);			// Unknown count
+		outapp->WriteUInt32(structs::MAX_PP_INNATE_SKILL);			// Innate Skills count
 
-		for (uint32 r = 0; r < 25; r++)
+		for (uint32 r = 0; r < structs::MAX_PP_INNATE_SKILL; r++)
 		{
-			outapp->WriteUInt32(0);			// Unknown
+			outapp->WriteUInt32(emu->InnateSkills[r]);			// Innate Skills (regen, slam, etc)
 		}
 
 		outapp->WriteUInt32(structs::MAX_PP_DISCIPLINES);	// Discipline count
@@ -2414,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) {
@@ -2432,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) {
@@ -2456,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);
@@ -2573,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);
@@ -3080,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);
@@ -3364,7 +3251,7 @@ namespace RoF2
 		std::string old_message = &emu->message[strlen(emu->sayer)];
 		std::string new_message;
 
-		ServerToRoF2TextLink(new_message, old_message);
+		ServerToRoF2SayLink(new_message, old_message);
 
 		//in->size = 3 + 4 + 4 + strlen(emu->sayer) + 1 + 12 + new_message.length() + 1;
 		in->size = strlen(emu->sayer) + new_message.length() + 25;
@@ -3436,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;
-		ServerToRoF2TextLink(new_message, old_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];
 
@@ -3994,6 +3884,9 @@ namespace RoF2
 		OUT(zone_reason);
 		OUT(success);
 
+		if (eq->success < 0)
+			eq->success -= 1;
+
 		FINISH_ENCODE();
 	}
 
@@ -4592,7 +4485,7 @@ namespace RoF2
 
 		std::string old_message = InBuffer;
 		std::string new_message;
-		RoF2ToServerTextLink(new_message, old_message);
+		RoF2ToServerSayLink(new_message, old_message);
 
 		//__packet->size = sizeof(ChannelMessage_Struct)+strlen(InBuffer) + 1;
 		__packet->size = sizeof(ChannelMessage_Struct) + new_message.length() + 1;
@@ -4703,7 +4596,7 @@ namespace RoF2
 		IN(type);
 		IN(spellid);
 		IN(damage);
-		IN(meleepush_xy);
+		IN(hit_heading);
 
 		FINISH_DIRECT_DECODE();
 	}
@@ -4726,7 +4619,7 @@ namespace RoF2
 
 		std::string old_message = (char *)&__eq_buffer[4]; // unknown01 offset
 		std::string new_message;
-		RoF2ToServerTextLink(new_message, old_message);
+		RoF2ToServerSayLink(new_message, old_message);
 
 		__packet->size = sizeof(Emote_Struct);
 		__packet->pBuffer = new unsigned char[__packet->size];
@@ -5047,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);
@@ -5496,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);
@@ -5590,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;
@@ -5684,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];
@@ -5904,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;
 
@@ -5941,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;
 		}
 
@@ -5968,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);
 			}
 
 			/*
@@ -6029,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;
 		}
 
@@ -6050,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
@@ -6070,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);
@@ -6083,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)
@@ -6091,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
@@ -6109,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;
@@ -6133,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;
@@ -6145,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;
 
@@ -6159,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;
@@ -6177,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);
@@ -6196,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
@@ -6208,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;
 		}
@@ -6227,22 +6120,22 @@ 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 ServerToRoF2TextLink(std::string& rof2TextLink, const std::string& serverTextLink)
+	static inline void ServerToRoF2SayLink(std::string& rof2SayLink, const std::string& serverSayLink)
 	{
-		if ((constants::SayLinkBodySize == EQEmu::legacy::TEXT_LINK_BODY_LENGTH) || (serverTextLink.find('\x12') == std::string::npos)) {
+		if ((constants::SAY_LINK_BODY_SIZE == EQEmu::constants::SAY_LINK_BODY_SIZE) || (serverSayLink.find('\x12') == std::string::npos)) {
-			rof2TextLink = serverTextLink;
+			rof2SayLink = serverSayLink;
 			return;
 		}
 
-		auto segments = SplitString(serverTextLink, '\x12');
+		auto segments = SplitString(serverSayLink, '\x12');
 
 		for (size_t segment_iter = 0; segment_iter < segments.size(); ++segment_iter) {
 			if (segment_iter & 1) {
-				if (segments[segment_iter].length() <= EQEmu::legacy::TEXT_LINK_BODY_LENGTH) {
+				if (segments[segment_iter].length() <= EQEmu::constants::SAY_LINK_BODY_SIZE) {
-					rof2TextLink.append(segments[segment_iter]);
+					rof2SayLink.append(segments[segment_iter]);
 					// TODO: log size mismatch error
 					continue;
 				}
@@ -6252,29 +6145,29 @@ namespace RoF2
 				// RoF2: X XXXXX XXXXX XXXXX XXXXX XXXXX XXXXX XXXXX X  XXXX XX XXXXX XXXXXXXX (56)
 				// Diff:
 
-				rof2TextLink.push_back('\x12');
+				rof2SayLink.push_back('\x12');
-				rof2TextLink.append(segments[segment_iter]);
+				rof2SayLink.append(segments[segment_iter]);
-				rof2TextLink.push_back('\x12');
+				rof2SayLink.push_back('\x12');
 			}
 			else {
-				rof2TextLink.append(segments[segment_iter]);
+				rof2SayLink.append(segments[segment_iter]);
 			}
 		}
 	}
 
-	static inline void RoF2ToServerTextLink(std::string& serverTextLink, const std::string& rof2TextLink)
+	static inline void RoF2ToServerSayLink(std::string& serverSayLink, const std::string& rof2SayLink)
 	{
-		if ((EQEmu::legacy::TEXT_LINK_BODY_LENGTH == constants::SayLinkBodySize) || (rof2TextLink.find('\x12') == std::string::npos)) {
+		if ((EQEmu::constants::SAY_LINK_BODY_SIZE == constants::SAY_LINK_BODY_SIZE) || (rof2SayLink.find('\x12') == std::string::npos)) {
-			serverTextLink = rof2TextLink;
+			serverSayLink = rof2SayLink;
 			return;
 		}
 
-		auto segments = SplitString(rof2TextLink, '\x12');
+		auto segments = SplitString(rof2SayLink, '\x12');
 
 		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) {
-					serverTextLink.append(segments[segment_iter]);
+					serverSayLink.append(segments[segment_iter]);
 					// TODO: log size mismatch error
 					continue;
 				}
@@ -6284,12 +6177,12 @@ namespace RoF2
 				// RoF2: X XXXXX XXXXX XXXXX XXXXX XXXXX XXXXX XXXXX X  XXXX XX XXXXX XXXXXXXX (56)
 				// Diff:
 
-				serverTextLink.push_back('\x12');
+				serverSayLink.push_back('\x12');
-				serverTextLink.append(segments[segment_iter]);
+				serverSayLink.append(segments[segment_iter]);
-				serverTextLink.push_back('\x12');
+				serverSayLink.push_back('\x12');
 			}
 			else {
-				serverTextLink.append(segments[segment_iter]);
+				serverSayLink.append(segments[segment_iter]);
 			}
 		}
 	}

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 {
-		enum InventoryType : int {
+				typePossessions = INULL,
-			InvTypePossessions = InvTypeBegin,
+				typeBank,
-			InvTypeBank,
+				typeSharedBank,
-			InvTypeSharedBank,
+				typeTrade,
-			InvTypeTrade,
+				typeWorld,
-			InvTypeWorld,
+				typeLimbo,
-			InvTypeLimbo,
+				typeTribute,
-			InvTypeTribute,
+				typeTrophyTribute,
-			InvTypeTrophyTribute,
+				typeGuildTribute,
-			InvTypeGuildTribute,
+				typeMerchant,
-			InvTypeMerchant,
+				typeDeleted,
-			InvTypeDeleted,
+				typeCorpse,
-			InvTypeCorpse,
+				typeBazaar,
-			InvTypeBazaar,
+				typeInspect,
-			InvTypeInspect,
+				typeRealEstate,
-			InvTypeRealEstate,
+				typeViewMODPC,
-			InvTypeViewMODPC,
+				typeViewMODBank,
-			InvTypeViewMODBank,
+				typeViewMODSharedBank,
-			InvTypeViewMODSharedBank,
+				typeViewMODLimbo,
-			InvTypeViewMODLimbo,
+				typeAltStorage,
-			InvTypeAltStorage,
+				typeArchived,
-			InvTypeArchived,
+				typeMail,
-			InvTypeMail,
+				typeGuildTrophyTribute,
-			InvTypeGuildTrophyTribute,
+				typeKrono,
-			InvTypeKrono,
+				typeOther
-			InvTypeOther,
-			InvTypeCount
 			};
 
+		} // namespace enum_
+		using namespace enum_;
+
+		const int16 POSSESSIONS_SIZE = 34;
+		const int16 BANK_SIZE = 24;
+		const int16 SHARED_BANK_SIZE = 2;
+		const int16 TRADE_SIZE = 8;
+		const int16 WORLD_SIZE = 10;
+		const int16 LIMBO_SIZE = 36;
+		const int16 TRIBUTE_SIZE = 5;
+		const int16 TROPHY_TRIBUTE_SIZE = 0;//unknown
+		const int16 GUILD_TRIBUTE_SIZE = 2;//unverified
+		const int16 MERCHANT_SIZE = 200;
+		const int16 DELETED_SIZE = 0;//unknown - "Recovery Tab"
+		const int16 CORPSE_SIZE = POSSESSIONS_SIZE;
+		const int16 BAZAAR_SIZE = 200;
+		const int16 INSPECT_SIZE = 23;
+		const int16 REAL_ESTATE_SIZE = 0;//unknown
+		const int16 VIEW_MOD_PC_SIZE = POSSESSIONS_SIZE;
+		const int16 VIEW_MOD_BANK_SIZE = BANK_SIZE;
+		const int16 VIEW_MOD_SHARED_BANK_SIZE = SHARED_BANK_SIZE;
+		const int16 VIEW_MOD_LIMBO_SIZE = LIMBO_SIZE;
+		const int16 ALT_STORAGE_SIZE = 0;//unknown - "Shroud Bank"
+		const int16 ARCHIVED_SIZE = 0;//unknown
+		const int16 MAIL_SIZE = 0;//unknown
+		const int16 GUILD_TROPHY_TRIBUTE_SIZE = 0;//unknown
+		const int16 KRONO_SIZE = 0;//unknown
+		const int16 OTHER_SIZE = 0;//unknown
+
+		const int16 TRADE_NPC_SIZE = 4; // defined by implication
+
+		const int16 TYPE_INVALID = IINVALID;
+		const int16 TYPE_BEGIN = typePossessions;
+		const int16 TYPE_END = typeOther;
+		const int16 TYPE_COUNT = (TYPE_END - TYPE_BEGIN) + 1;
+
+		int16 GetInvTypeSize(int16 inv_type);
+		const char* GetInvTypeName(int16 inv_type);
+
+		bool IsInvTypePersistent(int16 inv_type);
+
 	} /*invtype*/
 
 	namespace invslot {
 		inline EQEmu::versions::ClientVersion GetInvSlotRef() { return EQEmu::versions::ClientVersion::RoF2; }
 
-		enum : int { InvSlotInvalid = -1, InvSlotBegin };
+		namespace enum_ {
-
+			enum InventorySlots : int16 {
-		enum PossessionsSlot : int {
+				slotCharm = INULL,
-			PossessionsCharm = InvSlotBegin,
+				slotEar1,
-			PossessionsEar1,
+				slotHead,
-			PossessionsHead,
+				slotFace,
-			PossessionsFace,
+				slotEar2,
-			PossessionsEar2,
+				slotNeck,
-			PossessionsNeck,
+				slotShoulders,
-			PossessionsShoulders,
+				slotArms,
-			PossessionsArms,
+				slotBack,
-			PossessionsBack,
+				slotWrist1,
-			PossessionsWrist1,
+				slotWrist2,
-			PossessionsWrist2,
+				slotRange,
-			PossessionsRange,
+				slotHands,
-			PossessionsHands,
+				slotPrimary,
-			PossessionsPrimary,
+				slotSecondary,
-			PossessionsSecondary,
+				slotFinger1,
-			PossessionsFinger1,
+				slotFinger2,
-			PossessionsFinger2,
+				slotChest,
-			PossessionsChest,
+				slotLegs,
-			PossessionsLegs,
+				slotFeet,
-			PossessionsFeet,
+				slotWaist,
-			PossessionsWaist,
+				slotPowerSource,
-			PossessionsPowerSource,
+				slotAmmo,
-			PossessionsAmmo,
+				slotGeneral1,
-			PossessionsGeneral1,
+				slotGeneral2,
-			PossessionsGeneral2,
+				slotGeneral3,
-			PossessionsGeneral3,
+				slotGeneral4,
-			PossessionsGeneral4,
+				slotGeneral5,
-			PossessionsGeneral5,
+				slotGeneral6,
-			PossessionsGeneral6,
+				slotGeneral7,
-			PossessionsGeneral7,
+				slotGeneral8,
-			PossessionsGeneral8,
+				slotGeneral9,
-			PossessionsGeneral9,
+				slotGeneral10,
-			PossessionsGeneral10,
+				slotCursor
-			PossessionsCursor,
-			PossessionsCount
 			};
 
-		const int EquipmentBegin = PossessionsCharm;
+		} // namespace enum_
-		const int EquipmentEnd = PossessionsAmmo;
+		using namespace enum_;
-		const int EquipmentCount = (EquipmentEnd - EquipmentBegin + 1);
 
-		const int GeneralBegin = PossessionsGeneral1;
+		const int16 SLOT_INVALID = IINVALID;
-		const int GeneralEnd = PossessionsGeneral10;
+		const int16 SLOT_BEGIN = INULL;
-		const int GeneralCount = (GeneralEnd - GeneralBegin + 1);
+
+		const int16 POSSESSIONS_BEGIN = slotCharm;
+		const int16 POSSESSIONS_END = slotCursor;
+		const int16 POSSESSIONS_COUNT = (POSSESSIONS_END - POSSESSIONS_BEGIN) + 1;
+
+		const int16 EQUIPMENT_BEGIN = slotCharm;
+		const int16 EQUIPMENT_END = slotAmmo;
+		const int16 EQUIPMENT_COUNT = (EQUIPMENT_END - EQUIPMENT_BEGIN) + 1;
+
+		const int16 GENERAL_BEGIN = slotGeneral1;
+		const int16 GENERAL_END = slotGeneral10;
+		const int16 GENERAL_COUNT = (GENERAL_END - GENERAL_BEGIN) + 1;
+
+		const int16 BONUS_BEGIN = invslot::slotCharm;
+		const int16 BONUS_STAT_END = invslot::slotPowerSource;
+		const int16 BONUS_SKILL_END = invslot::slotAmmo;
+
+		const int16 CORPSE_BEGIN = invslot::slotGeneral1;
+		const int16 CORPSE_END = invslot::slotGeneral1 + invslot::slotCursor;
+
+		const uint64 POSSESSIONS_BITMASK = 0x00000003FFFFFFFF; // based on 34-slot count (RoF+)
+		const uint64 CORPSE_BITMASK = 0x01FFFFFFFF800000; // based on 34-slot count (RoF+)
+
+		const char* GetInvPossessionsSlotName(int16 inv_slot);
+		const char* GetInvSlotName(int16 inv_type, int16 inv_slot);
 
 	} /*invslot*/
 
 	namespace invbag {
 		inline EQEmu::versions::ClientVersion GetInvBagRef() { return EQEmu::versions::ClientVersion::RoF2; }
 
-		enum : int { InvBagInvalid = -1, InvBagBegin };
+		const int16 SLOT_INVALID = IINVALID;
+		const int16 SLOT_BEGIN = INULL;
+		const int16 SLOT_END = 9; //254;
+		const int16 SLOT_COUNT = 10; //255; // server Size will be 255..unsure what actual client is (test)
+
+		const char* GetInvBagIndexName(int16 bag_index);
 
 	} /*invbag*/
 
 	namespace invaug {
 		inline EQEmu::versions::ClientVersion GetInvAugRef() { return EQEmu::versions::ClientVersion::RoF2; }
 
-		enum : int { InvAugInvalid = -1, InvAugBegin };
+		const int16 SOCKET_INVALID = IINVALID;
+		const int16 SOCKET_BEGIN = INULL;
+		const int16 SOCKET_END = 5;
+		const int16 SOCKET_COUNT = 6;
+
+		const char* GetInvAugIndexName(int16 aug_index);
 
 	} /*invaug*/
 
@@ -164,7 +239,7 @@ namespace RoF2
 			ItemPacket11 = 111,
 			ItemPacket12 = 112,
 			ItemPacketRecovery = 113,
-			ItemPacket14 = 115
+			ItemPacket14 = 115 // Parcel? adds to merchant window too
 		};
 
 	} /*item*/
@@ -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

@@ -131,6 +131,7 @@ static const uint32 MAX_PP_LANGUAGE		= 32;	// was 25
 static const uint32 MAX_PP_SPELLBOOK	= 720;	// was 480
 static const uint32 MAX_PP_MEMSPELL		= 16;	// was 12
 static const uint32 MAX_PP_SKILL		= PACKET_SKILL_ARRAY_SIZE;	// 100 - actual skills buffer size
+static const uint32 MAX_PP_INNATE_SKILL	= 25;
 static const uint32 MAX_PP_AA_ARRAY		= 300;
 static const uint32 MAX_PP_DISCIPLINES	= 300;	// was 200
 static const uint32 MAX_GROUP_MEMBERS	= 6;
@@ -399,7 +400,7 @@ struct Spawn_Struct_Position
 
 struct Spawn_Struct_Position
 {
-	signed	padding0000:12;
+	signed	angle:12;       // pitch of camera?
 	signed	y:19;
 	signed	padding0001:1;
 
@@ -415,7 +416,7 @@ struct Spawn_Struct_Position
 	signed	z:19;
 	signed	padding0020:3;
 
-	signed  animation:10;   // animation
+	signed  animation:10;   // SpeedRun
 	signed	deltaY:13;
 	signed	padding0023:9;
 };
@@ -429,7 +430,7 @@ struct Spawn_Struct
 /*0000*/ //uint8     nullterm1; // hack to null terminate name
 /*0064*/ uint32 spawnId;
 /*0068*/ uint8  level;
-/*0069*/ float    unknown1;
+/*0069*/ float  bounding_radius; // used in melee, overrides calc
 /*0073*/ uint8  NPC;           // 0=player,1=npc,2=pc corpse,3=npc corpse
 	 Spawn_Struct_Bitfields	Bitfields;
 /*0000*/ uint8  otherData; // & 4 - has title, & 8 - has suffix, & 1 - it's a chest or untargetable
@@ -956,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
@@ -982,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 {
@@ -1155,8 +1156,8 @@ union
 /*01012*/ AA_Array  aa_array[MAX_PP_AA_ARRAY];	// [300] 3600 bytes - AAs 12 bytes each
 /*04612*/ uint32 skill_count;					// Seen 100
 /*04616*/ uint32 skills[MAX_PP_SKILL];			// [100] 400 bytes - List of skills
-/*05016*/ uint32 unknown15_count;				// Seen 25
+/*05016*/ uint32 InnateSkills_count;			// Seen 25
-/*05020*/ uint32 unknown_rof15[25];				// Most are 255 or 0
+/*05020*/ uint32 InnateSkills[MAX_PP_INNATE_SKILL];	// Most are 255 or 0
 /*05120*/ uint32 discipline_count;				// Seen 200
 /*05124*/ Disciplines_Struct  disciplines;		// [200] 800 bytes Known disciplines
 /*05924*/ uint32 timestamp_count;				// Seen 20
@@ -1197,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
@@ -1461,17 +1462,17 @@ struct Action_Struct
 {
 /*00*/	uint16 target;			// id of target
 /*02*/	uint16 source;			// id of caster
-/*04*/	uint16 level;			// level of caster - Seen 0
+/*04*/	uint16 level;			// level of caster for spells, OSX dump says attack rating, guess spells use it for level
-/*06*/  uint32 unknown06;
+/*06*/  uint32 unknown06;		// OSX dump says base_damage, was used for bard mod too, this is 0'd :(
 /*10*/	float instrument_mod;
-/*14*/  uint32 bard_focus_id;      // seen 0
+/*14*/  float force;
-/*18*/  float knockback_angle;  //seems to go from 0-512 then it rolls over again
+/*18*/  float hit_heading;
-/*22*/  uint32 unknown22;
+/*22*/  float hit_pitch;
-/*26*/  uint8 type;
+/*26*/  uint8 type;				// 231 (0xE7) for spells, skill
-/*27*/  uint32 damage;
+/*27*/  uint32 damage;			// OSX says min_damage
-/*31*/  uint16 unknown31;
+/*31*/  uint16 unknown31;		// OSX says tohit
 /*33*/	uint32 spell;			// spell id being cast
-/*37*/	uint8 level2;			// level of caster again? Or maybe the castee
+/*37*/	uint8 spell_level;			// level of caster again? Or maybe the castee
 /*38*/	uint8 effect_flag;		// if this is 4, the effect is valid: or if two are sent at the same time?
 /*39*/
 };
@@ -1483,25 +1484,21 @@ struct ActionAlt_Struct
 {
 /*00*/	uint16 target;			// id of target
 /*02*/	uint16 source;			// id of caster
-/*04*/	uint16 level;			// level of caster - Seen 0
+/*04*/	uint16 level;			// level of caster for spells, OSX dump says attack rating, guess spells use it for level
-/*06*/  uint32 unknown06;
+/*06*/  uint32 unknown06;		// OSX dump says base_damage, was used for bard mod too, this is 0'd :(
 /*10*/	float instrument_mod;
-/*14*/  uint32 bard_focus_id;      // seen 0
+/*14*/  float force;
-/*18*/  float knockback_angle;  //seems to go from 0-512 then it rolls over again
+/*18*/  float hit_heading;
-/*22*/  uint32 unknown22;
+/*22*/  float hit_pitch;
-/*26*/  uint8 type;
+/*26*/  uint8 type;				// 231 (0xE7) for spells, skill
-/*27*/  uint32 damage;
+/*27*/  uint32 damage;			// OSX says min_damage
-/*31*/  uint16 unknown31;
+/*31*/  uint16 unknown31;		// OSX says tohit
 /*33*/	uint32 spell;			// spell id being cast
-/*37*/	uint8 level2;			// level of caster again? Or maybe the castee
+/*37*/	uint8 spell_level;		// level of caster again? Or maybe the castee
 /*38*/	uint8 effect_flag;		// if this is 4, the effect is valid: or if two are sent at the same time?
-/*39*/	uint32 unknown39;		// New field to Underfoot - Seen 14
+/*39*/	uint8 spell_gem;
-/*43*/	uint8 unknown43;			// New field to Underfoot - Seen 0
+/*40*/	InventorySlot_Struct slot;
-/*44*/	uint8 unknown44;			// New field to Underfoot - Seen 17
+/*52*/	uint32 item_cast_type;	// ItemSpellTypes enum from MQ2
-/*45*/	uint8 unknown45;			// New field to Underfoot - Seen 0
-/*46*/	int32 unknown46;		// New field to Underfoot - Seen -1
-/*50*/	uint32 unknown50;		// New field to Underfoot - Seen 0
-/*54*/	uint16 unknown54;		// New field to Underfoot - Seen 0
 /*56*/
 };
 
@@ -1516,9 +1513,9 @@ struct CombatDamage_Struct
 /* 05 */	uint32	spellid;
 /* 09 */	int32	damage;
 /* 13 */	float	force;		// cd cc cc 3d
-/* 17 */	float	meleepush_xy;		// see above notes in Action_Struct
+/* 17 */	float	hit_heading;		// see above notes in Action_Struct
-/* 21 */	float	meleepush_z;
+/* 21 */	float	hit_pitch;
-/* 25 */	uint8	unknown25;	// was [9]
+/* 25 */	uint8	secondary;	// 0 for primary hand, 1 for secondary
 /* 26 */	uint32	special; // 2 = Rampage, 1 = Wild Rampage
 /* 30 */
 };
@@ -1826,6 +1823,20 @@ struct MoveItem_Struct
 /*0028*/
 };
 
+struct MultiMoveItemSub_Struct
+{
+/*0000*/ InventorySlot_Struct	from_slot;
+/*0012*/ InventorySlot_Struct	to_slot;
+/*0024*/ uint32			number_in_stack;
+/*0028*/ uint8			unknown[8];
+};
+
+struct MultiMoveItem_Struct
+{
+/*0000*/ uint32	count;
+/*0004*/ MultiMoveItemSub_Struct moves[0];
+};
+
 //
 // from_slot/to_slot
 // -1 - destroy
@@ -2335,7 +2346,6 @@ struct AltCurrencySelectItem_Struct
 /*064*/ uint32 unknown064;
 /*068*/ uint32 unknown068;
 /*072*/ uint32 unknown072;
-/*076*/ uint32 unknown076;
 };
 
 //Server -> Client
@@ -3590,21 +3600,6 @@ struct GuildSetRank_Struct
 /*80*/
 };
 
-struct BugStruct{
-/*0000*/	char	chartype[64];
-/*0064*/	char	name[96];
-/*0160*/	char	ui[128];
-/*0288*/	float	x;
-/*0292*/	float	y;
-/*0296*/	float	z;
-/*0300*/	float	heading;
-/*0304*/	uint32	unknown304;
-/*0308*/	uint32	type;
-/*0312*/	char	unknown312[2144];
-/*2456*/	char	bug[1024];
-/*3480*/	char	placeholder[2];
-/*3482*/	char	system_info[4098];
-};
 struct Make_Pet_Struct { //Simple struct for getting pet info
 	uint8 level;
 	uint8 class_;
@@ -3631,20 +3626,21 @@ struct Ground_Spawn{
 struct Ground_Spawns {
 	struct Ground_Spawn spawn[50]; //Assigned max number to allow
 };
-struct PetitionBug_Struct{
+
-	uint32	petition_number;
+//struct PetitionBug_Struct{
-	uint32	unknown4;
+//	uint32	petition_number;
-	char	accountname[64];
+//	uint32	unknown4;
-	uint32	zoneid;
+//	char	accountname[64];
-	char	name[64];
+//	uint32	zoneid;
-	uint32	level;
+//	char	name[64];
-	uint32	class_;
+//	uint32	level;
-	uint32	race;
+//	uint32	class_;
-	uint32	unknown152[3];
+//	uint32	race;
-	uint32	time;
+//	uint32	unknown152[3];
-	uint32	unknown168;
+//	uint32	time;
-	char	text[1028];
+//	uint32	unknown168;
-};
+//	char	text[1028];
+//};
 
 struct ApproveZone_Struct {
 	char	name[64];
@@ -5088,6 +5084,23 @@ struct CrystalCountUpdate_Struct
 	/*012*/	uint32	CareerEbonCrystals;
 };
 
+struct SayLinkBodyFrame_Struct {
+/*000*/	char ActionID[1];
+/*001*/	char ItemID[5];
+/*006*/	char Augment1[5];
+/*011*/	char Augment2[5];
+/*016*/	char Augment3[5];
+/*021*/	char Augment4[5];
+/*026*/	char Augment5[5];
+/*031*/	char Augment6[5];
+/*036*/	char IsEvolving[1];
+/*037*/	char EvolveGroup[4];
+/*041*/	char EvolveLevel[2];
+/*043*/	char OrnamentIcon[5];
+/*048*/	char Hash[8];
+/*056*/
+};
+
 	}; /*structs*/
 
 }; /*RoF2*/

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 {
-		enum InventoryType : int {
+				typePossessions = INULL,
-			InvTypePossessions = InvTypeBegin,
+				typeBank,
-			InvTypeBank,
+				typeSharedBank,
-			InvTypeSharedBank,
+				typeTrade,
-			InvTypeTrade,
+				typeWorld,
-			InvTypeWorld,
+				typeLimbo,
-			InvTypeLimbo,
+				typeTribute,
-			InvTypeTribute,
+				typeTrophyTribute,
-			InvTypeTrophyTribute,
+				typeGuildTribute,
-			InvTypeGuildTribute,
+				typeMerchant,
-			InvTypeMerchant,
+				typeDeleted,
-			InvTypeDeleted,
+				typeCorpse,
-			InvTypeCorpse,
+				typeBazaar,
-			InvTypeBazaar,
+				typeInspect,
-			InvTypeInspect,
+				typeRealEstate,
-			InvTypeRealEstate,
+				typeViewMODPC,
-			InvTypeViewMODPC,
+				typeViewMODBank,
-			InvTypeViewMODBank,
+				typeViewMODSharedBank,
-			InvTypeViewMODSharedBank,
+				typeViewMODLimbo,
-			InvTypeViewMODLimbo,
+				typeAltStorage,
-			InvTypeAltStorage,
+				typeArchived,
-			InvTypeArchived,
+				typeMail,
-			InvTypeMail,
+				typeGuildTrophyTribute,
-			InvTypeGuildTrophyTribute,
+				typeOther
-			InvTypeOther,
-			InvTypeCount
 			};
 
+		} // namespace enum_
+		using namespace enum_;
+
+		const int16 POSSESSIONS_SIZE = 34;
+		const int16 BANK_SIZE = 24;
+		const int16 SHARED_BANK_SIZE = 2;
+		const int16 TRADE_SIZE = 8;
+		const int16 WORLD_SIZE = 10;
+		const int16 LIMBO_SIZE = 36;
+		const int16 TRIBUTE_SIZE = 5;
+		const int16 TROPHY_TRIBUTE_SIZE = 0;//unknown
+		const int16 GUILD_TRIBUTE_SIZE = 2;//unverified
+		const int16 MERCHANT_SIZE = 200;
+		const int16 DELETED_SIZE = 0;//unknown - "Recovery Tab"
+		const int16 CORPSE_SIZE = POSSESSIONS_SIZE;
+		const int16 BAZAAR_SIZE = 200;
+		const int16 INSPECT_SIZE = 23;
+		const int16 REAL_ESTATE_SIZE = 0;//unknown
+		const int16 VIEW_MOD_PC_SIZE = POSSESSIONS_SIZE;
+		const int16 VIEW_MOD_BANK_SIZE = BANK_SIZE;
+		const int16 VIEW_MOD_SHARED_BANK_SIZE = SHARED_BANK_SIZE;
+		const int16 VIEW_MOD_LIMBO_SIZE = LIMBO_SIZE;
+		const int16 ALT_STORAGE_SIZE = 0;//unknown - "Shroud Bank"
+		const int16 ARCHIVED_SIZE = 0;//unknown
+		const int16 MAIL_SIZE = 0;//unknown
+		const int16 GUILD_TROPHY_TRIBUTE_SIZE = 0;//unknown
+		const int16 OTHER_SIZE = 0;//unknown
+
+		const int16 TRADE_NPC_SIZE = 4; // defined by implication
+
+		const int16 TYPE_INVALID = IINVALID;
+		const int16 TYPE_BEGIN = typePossessions;
+		const int16 TYPE_END = typeOther;
+		const int16 TYPE_COUNT = (TYPE_END - TYPE_BEGIN) + 1;
+
+		int16 GetInvTypeSize(int16 inv_type);
+		const char* GetInvTypeName(int16 inv_type);
+
+		bool IsInvTypePersistent(int16 inv_type);
+
 	} /*invtype*/
 
 	namespace invslot {
 		inline EQEmu::versions::ClientVersion GetInvSlotRef() { return EQEmu::versions::ClientVersion::RoF; }
 
-		enum : int { InvSlotInvalid = -1, InvSlotBegin };
+		namespace enum_ {
-
+			enum InventorySlots : int16 {
-		enum PossessionsSlot : int {
+				slotCharm = INULL,
-			PossessionsCharm = InvSlotBegin,
+				slotEar1,
-			PossessionsEar1,
+				slotHead,
-			PossessionsHead,
+				slotFace,
-			PossessionsFace,
+				slotEar2,
-			PossessionsEar2,
+				slotNeck,
-			PossessionsNeck,
+				slotShoulders,
-			PossessionsShoulders,
+				slotArms,
-			PossessionsArms,
+				slotBack,
-			PossessionsBack,
+				slotWrist1,
-			PossessionsWrist1,
+				slotWrist2,
-			PossessionsWrist2,
+				slotRange,
-			PossessionsRange,
+				slotHands,
-			PossessionsHands,
+				slotPrimary,
-			PossessionsPrimary,
+				slotSecondary,
-			PossessionsSecondary,
+				slotFinger1,
-			PossessionsFinger1,
+				slotFinger2,
-			PossessionsFinger2,
+				slotChest,
-			PossessionsChest,
+				slotLegs,
-			PossessionsLegs,
+				slotFeet,
-			PossessionsFeet,
+				slotWaist,
-			PossessionsWaist,
+				slotPowerSource,
-			PossessionsPowerSource,
+				slotAmmo,
-			PossessionsAmmo,
+				slotGeneral1,
-			PossessionsGeneral1,
+				slotGeneral2,
-			PossessionsGeneral2,
+				slotGeneral3,
-			PossessionsGeneral3,
+				slotGeneral4,
-			PossessionsGeneral4,
+				slotGeneral5,
-			PossessionsGeneral5,
+				slotGeneral6,
-			PossessionsGeneral6,
+				slotGeneral7,
-			PossessionsGeneral7,
+				slotGeneral8,
-			PossessionsGeneral8,
+				slotGeneral9,
-			PossessionsGeneral9,
+				slotGeneral10,
-			PossessionsGeneral10,
+				slotCursor
-			PossessionsCursor,
-			PossessionsCount
 			};
 
-		const int EquipmentBegin = PossessionsCharm;
+		} // namespace enum_
-		const int EquipmentEnd = PossessionsAmmo;
+		using namespace enum_;
-		const int EquipmentCount = (EquipmentEnd - EquipmentBegin + 1);
 
-		const int GeneralBegin = PossessionsGeneral1;
+		const int16 SLOT_INVALID = IINVALID;
-		const int GeneralEnd = PossessionsGeneral10;
+		const int16 SLOT_BEGIN = INULL;
-		const int GeneralCount = (GeneralEnd - GeneralBegin + 1);
+
+		const int16 POSSESSIONS_BEGIN = slotCharm;
+		const int16 POSSESSIONS_END = slotCursor;
+		const int16 POSSESSIONS_COUNT = (POSSESSIONS_END - POSSESSIONS_BEGIN) + 1;
+
+		const int16 EQUIPMENT_BEGIN = slotCharm;
+		const int16 EQUIPMENT_END = slotAmmo;
+		const int16 EQUIPMENT_COUNT = (EQUIPMENT_END - EQUIPMENT_BEGIN + 1);
+
+		const int16 GENERAL_BEGIN = slotGeneral1;
+		const int16 GENERAL_END = slotGeneral10;
+		const int16 GENERAL_COUNT = (GENERAL_END - GENERAL_BEGIN + 1);
+
+		const int16 BONUS_BEGIN = invslot::slotCharm;
+		const int16 BONUS_STAT_END = invslot::slotPowerSource;
+		const int16 BONUS_SKILL_END = invslot::slotAmmo;
+
+		const int16 CORPSE_BEGIN = invslot::slotGeneral1;
+		const int16 CORPSE_END = invslot::slotGeneral1 + invslot::slotCursor;
+
+		const uint64 POSSESSIONS_BITMASK = 0x00000003FFFFFFFF; // based on 34-slot count (RoF+)
+		const uint64 CORPSE_BITMASK = 0x01FFFFFFFF800000; // based on 34-slot count (RoF+)
+
+		const char* GetInvPossessionsSlotName(int16 inv_slot);
+		const char* GetInvSlotName(int16 inv_type, int16 inv_slot);
 
 	} /*invslot*/
 
 	namespace invbag {
 		inline EQEmu::versions::ClientVersion GetInvBagRef() { return EQEmu::versions::ClientVersion::RoF; }
 
-		enum : int { InvBagInvalid = -1, InvBagBegin };
+		const int16 SLOT_INVALID = IINVALID;
+		const int16 SLOT_BEGIN = INULL;
+		const int16 SLOT_END = 9; //254;
+		const int16 SLOT_COUNT = 10; //255; // server Size will be 255..unsure what actual client is (test)
+
+		const char* GetInvBagIndexName(int16 bag_index);
 
 	} /*invbag*/
 
 	namespace invaug {
 		inline EQEmu::versions::ClientVersion GetInvAugRef() { return EQEmu::versions::ClientVersion::RoF; }
 
-		enum : int { InvAugInvalid = -1, InvAugBegin };
+		const int16 SOCKET_INVALID = IINVALID;
+		const int16 SOCKET_BEGIN = INULL;
+		const int16 SOCKET_END = 5;
+		const int16 SOCKET_COUNT = 6;
+
+		const char* GetInvAugIndexName(int16 aug_index);
 
 	} /*invaug*/
 
@@ -164,109 +238,21 @@ namespace RoF
 	namespace profile {
 		inline EQEmu::versions::ClientVersion GetProfileRef() { return EQEmu::versions::ClientVersion::RoF; }
 
+		const int16 BANDOLIERS_SIZE = 20;		// number of bandolier instances
+		const int16 BANDOLIER_ITEM_COUNT = 4;	// number of equipment slots in bandolier instance
+
+		const int16 POTION_BELT_SIZE = 5;
+
+		const int16 SKILL_ARRAY_SIZE = 100;
+
 	} /*profile*/
 
 	namespace constants {
 		inline EQEmu::versions::ClientVersion GetConstantsRef() { return EQEmu::versions::ClientVersion::RoF; }
 
-	} /*constants*/
+		const size_t CHARACTER_CREATION_LIMIT = 12;
 
-	namespace behavior {
+		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

@@ -131,6 +131,7 @@ static const uint32 MAX_PP_LANGUAGE		= 32;	// was 25
 static const uint32 MAX_PP_SPELLBOOK	= 720;	// was 480
 static const uint32 MAX_PP_MEMSPELL		= 16;	// was 12
 static const uint32 MAX_PP_SKILL		= PACKET_SKILL_ARRAY_SIZE;	// 100 - actual skills buffer size
+static const uint32 MAX_PP_INNATE_SKILL	= 25;
 static const uint32 MAX_PP_AA_ARRAY		= 300;
 static const uint32 MAX_PP_DISCIPLINES	= 200;	// was 100
 static const uint32 MAX_GROUP_MEMBERS	= 6;
@@ -407,7 +408,7 @@ struct Spawn_Struct
 /*0000*/ //uint8     nullterm1; // hack to null terminate name
 /*0064*/ uint32 spawnId;
 /*0068*/ uint8  level;
-/*0069*/ float    unknown1;
+/*0069*/ float  bounding_radius; // used in melee, overrides calc
 /*0073*/ uint8  NPC;           // 0=player,1=npc,2=pc corpse,3=npc corpse
 	 Spawn_Struct_Bitfields	Bitfields;
 /*0000*/ uint8  otherData; // & 4 - has title, & 8 - has suffix, & 1 - it's a chest or untargetable
@@ -897,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
@@ -923,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 {
@@ -1096,8 +1097,8 @@ union
 /*01012*/ AA_Array  aa_array[MAX_PP_AA_ARRAY];	// [300] 3600 bytes - AAs 12 bytes each
 /*04612*/ uint32 skill_count;					// Seen 100
 /*04616*/ uint32 skills[MAX_PP_SKILL];			// [100] 400 bytes - List of skills
-/*05016*/ uint32 unknown15_count;				// Seen 25
+/*05016*/ uint32 InnateSkills_count;				// Seen 25
-/*05020*/ uint32 unknown_rof15[25];				// Most are 255 or 0
+/*05020*/ uint32 InnateSkills[MAX_PP_INNATE_SKILL];	// Most are 255 or 0
 /*05120*/ uint32 discipline_count;				// Seen 200
 /*05124*/ Disciplines_Struct  disciplines;		// [200] 800 bytes Known disciplines
 /*05924*/ uint32 timestamp_count;				// Seen 20
@@ -1138,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
@@ -1449,17 +1450,17 @@ struct Action_Struct
 {
 /*00*/	uint16 target;			// id of target
 /*02*/	uint16 source;			// id of caster
-/*04*/	uint16 level;			// level of caster - Seen 0
+/*04*/	uint16 level;			// level of caster for spells, OSX dump says attack rating, guess spells use it for level
-/*06*/  uint32 unknown06;
+/*06*/  uint32 unknown06;		// OSX dump says base_damage, was used for bard mod too, this is 0'd :(
 /*10*/	float instrument_mod;
-/*14*/  uint32 bard_focus_id;      // seen 0
+/*14*/  float force;
-/*18*/  float knockback_angle;  //seems to go from 0-512 then it rolls over again
+/*18*/  float hit_heading;
-/*22*/  uint32 unknown22;
+/*22*/  float hit_pitch;
-/*26*/  uint8 type;
+/*26*/  uint8 type;				// 231 (0xE7) for spells, skill
-/*27*/  uint32 damage;
+/*27*/  uint32 damage;			// OSX says min_damage
-/*31*/  uint16 unknown31;
+/*31*/  uint16 unknown31;		// OSX says tohit
 /*33*/	uint32 spell;			// spell id being cast
-/*37*/	uint8 level2;			// level of caster again? Or maybe the castee
+/*37*/	uint8 spell_level;			// level of caster again? Or maybe the castee
 /*38*/	uint8 effect_flag;		// if this is 4, the effect is valid: or if two are sent at the same time?
 /*39*/
 };
@@ -1471,25 +1472,21 @@ struct ActionAlt_Struct
 {
 /*00*/	uint16 target;			// id of target
 /*02*/	uint16 source;			// id of caster
-/*04*/	uint16 level;			// level of caster - Seen 0
+/*04*/	uint16 level;			// level of caster for spells, OSX dump says attack rating, guess spells use it for level
-/*06*/  uint32 unknown06;
+/*06*/  uint32 unknown06;		// OSX dump says base_damage, was used for bard mod too, this is 0'd :(
 /*10*/	float instrument_mod;
-/*14*/  uint32 bard_focus_id;      // seen 0
+/*14*/  float force;
-/*18*/  float knockback_angle;  //seems to go from 0-512 then it rolls over again
+/*18*/  float hit_heading;
-/*22*/  uint32 unknown22;
+/*22*/  float hit_pitch;
-/*26*/  uint8 type;
+/*26*/  uint8 type;				// 231 (0xE7) for spells, skill
-/*27*/  uint32 damage;
+/*27*/  uint32 damage;			// OSX says min_damage
-/*31*/  uint16 unknown31;
+/*31*/  uint16 unknown31;		// OSX says tohit
 /*33*/	uint32 spell;			// spell id being cast
-/*37*/	uint8 level2;			// level of caster again? Or maybe the castee
+/*37*/	uint8 spell_level;		// level of caster again? Or maybe the castee
 /*38*/	uint8 effect_flag;		// if this is 4, the effect is valid: or if two are sent at the same time?
-/*39*/	uint32 unknown39;		// New field to Underfoot - Seen 14
+/*39*/	uint8 spell_gem;
-/*43*/	uint8 unknown43;			// New field to Underfoot - Seen 0
+/*40*/	InventorySlot_Struct slot;
-/*44*/	uint8 unknown44;			// New field to Underfoot - Seen 17
+/*52*/	uint32 item_cast_type;	// ItemSpellTypes enum from MQ2
-/*45*/	uint8 unknown45;			// New field to Underfoot - Seen 0
-/*46*/	int32 unknown46;		// New field to Underfoot - Seen -1
-/*50*/	uint32 unknown50;		// New field to Underfoot - Seen 0
-/*54*/	uint16 unknown54;		// New field to Underfoot - Seen 0
 /*56*/
 };
 
@@ -1504,9 +1501,9 @@ struct CombatDamage_Struct
 /* 05 */	uint32	spellid;
 /* 09 */	int32	damage;
 /* 13 */	float	force;		// cd cc cc 3d
-/* 17 */	float	meleepush_xy;		// see above notes in Action_Struct
+/* 17 */	float	hit_heading;		// see above notes in Action_Struct
-/* 21 */	float	meleepush_z;
+/* 21 */	float	hit_pitch;
-/* 25 */	uint8	unknown25;	// was [9]
+/* 25 */	uint8	secondary;	// 0 for primary hand, 1 for secondary
 /* 26 */	uint32	special; // 2 = Rampage, 1 = Wild Rampage
 /* 30 */
 };
@@ -3544,21 +3541,6 @@ struct GuildSetRank_Struct
 /*80*/
 };
 
-struct BugStruct{
-/*0000*/	char	chartype[64];
-/*0064*/	char	name[96];
-/*0160*/	char	ui[128];
-/*0288*/	float	x;
-/*0292*/	float	y;
-/*0296*/	float	z;
-/*0300*/	float	heading;
-/*0304*/	uint32	unknown304;
-/*0308*/	uint32	type;
-/*0312*/	char	unknown312[2144];
-/*2456*/	char	bug[1024];
-/*3480*/	char	placeholder[2];
-/*3482*/	char	system_info[4098];
-};
 struct Make_Pet_Struct { //Simple struct for getting pet info
 	uint8 level;
 	uint8 class_;
@@ -3585,20 +3567,21 @@ struct Ground_Spawn{
 struct Ground_Spawns {
 	struct Ground_Spawn spawn[50]; //Assigned max number to allow
 };
-struct PetitionBug_Struct{
+
-	uint32	petition_number;
+//struct PetitionBug_Struct{
-	uint32	unknown4;
+//	uint32	petition_number;
-	char	accountname[64];
+//	uint32	unknown4;
-	uint32	zoneid;
+//	char	accountname[64];
-	char	name[64];
+//	uint32	zoneid;
-	uint32	level;
+//	char	name[64];
-	uint32	class_;
+//	uint32	level;
-	uint32	race;
+//	uint32	class_;
-	uint32	unknown152[3];
+//	uint32	race;
-	uint32	time;
+//	uint32	unknown152[3];
-	uint32	unknown168;
+//	uint32	time;
-	char	text[1028];
+//	uint32	unknown168;
-};
+//	char	text[1028];
+//};
 
 struct ApproveZone_Struct {
 	char	name[64];
@@ -5019,6 +5002,23 @@ struct MercenaryMerchantRequest_Struct {
 struct MercenaryMerchantResponse_Struct {
 /*0000*/ uint32 ResponseType;
 /*0004*/
+};
+
+struct SayLinkBodyFrame_Struct {
+/*000*/	char ActionID[1];
+/*001*/	char ItemID[5];
+/*006*/	char Augment1[5];
+/*011*/	char Augment2[5];
+/*016*/	char Augment3[5];
+/*021*/	char Augment4[5];
+/*026*/	char Augment5[5];
+/*031*/	char Augment6[5];
+/*036*/	char IsEvolving[1];
+/*037*/	char EvolveGroup[4];
+/*041*/	char EvolveLevel[1];
+/*042*/	char OrnamentIcon[5];
+/*047*/	char Hash[8];
+/*055*/
 };
 
 	}; /*structs*/

common/patches/sod.cpp

@@ -53,11 +53,11 @@ namespace SoD
 	static inline uint32 SoDToServerSlot(uint32 sodSlot);
 	static inline uint32 SoDToServerCorpseSlot(uint32 sodCorpseSlot);
 
-	// server to client text link converter
+	// server to client say link converter
-	static inline void ServerToSoDTextLink(std::string& sodTextLink, const std::string& serverTextLink);
+	static inline void ServerToSoDSayLink(std::string& sodSayLink, const std::string& serverSayLink);
 
-	// client to server text link converter
+	// client to server say link converter
-	static inline void SoDToServerTextLink(std::string& serverTextLink, const std::string& sodTextLink);
+	static inline void SoDToServerSayLink(std::string& serverSayLink, const std::string& sodSayLink);
 
 	static inline CastingSlot ServerToSoDCastingSlot(EQEmu::CastingSlot slot);
 	static inline EQEmu::CastingSlot SoDToServerCastingSlot(CastingSlot slot);
@@ -161,15 +161,14 @@ namespace SoD
 		OUT(source);
 		OUT(level);
 		OUT(instrument_mod);
-		eq->sequence = emu->sequence;
+		OUT(force);
+		OUT(hit_heading);
+		OUT(hit_pitch);
 		OUT(type);
 		//OUT(damage);
 		OUT(spell);
-		eq->level2 = emu->level;
+		OUT(spell_level);
-		OUT(buff_unknown); // if this is 4, a buff icon is made
+		OUT(effect_flag); // if this is 4, a buff icon is made
-		//eq->unknown0036 = -1;
-		//eq->unknown0040 = -1;
-		//eq->unknown0044 = -1;
 
 		FINISH_ENCODE();
 	}
@@ -346,7 +345,7 @@ namespace SoD
 
 		std::string old_message = emu->message;
 		std::string new_message;
-		ServerToSoDTextLink(new_message, old_message);
+		ServerToSoDSayLink(new_message, old_message);
 
 		in->size = sizeof(ChannelMessage_Struct) + new_message.length() + 1;
 
@@ -458,8 +457,8 @@ namespace SoD
 		OUT(spellid);
 		OUT(damage);
 		OUT(force);
-		OUT(meleepush_xy);
+		OUT(hit_heading);
-		OUT(meleepush_z);
+		OUT(hit_pitch);
 		OUT(special);
 
 		FINISH_ENCODE();
@@ -625,7 +624,7 @@ namespace SoD
 
 		std::string old_message = emu->message;
 		std::string new_message;
-		ServerToSoDTextLink(new_message, old_message);
+		ServerToSoDSayLink(new_message, old_message);
 
 		//if (new_message.length() > 512) // length restricted in packet building function due vari-length name size (no nullterm)
 		//	new_message = new_message.substr(0, 512);
@@ -677,7 +676,7 @@ namespace SoD
 
 		for (int i = 0; i < 9; ++i) {
 			if (old_message_array[i].length() == 0) { break; }
-			ServerToSoDTextLink(new_message_array[i], old_message_array[i]);
+			ServerToSoDSayLink(new_message_array[i], old_message_array[i]);
 			new_message_size += new_message_array[i].length() + 1;
 		}
 
@@ -1384,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;
@@ -1605,6 +1496,7 @@ namespace SoD
 		OUT(copper_cursor);
 
 		OUT_array(skills, structs::MAX_PP_SKILL);	// 1:1 direct copy (100 dword)
+		OUT_array(InnateSkills, structs::MAX_PP_INNATE_SKILL);  // 1:1 direct copy (25 dword)
 
 		//	OUT(unknown04760[236]);
 		OUT(toxicity);
@@ -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);
@@ -2155,7 +2047,7 @@ namespace SoD
 		std::string old_message = &emu->message[strlen(emu->sayer)];
 		std::string new_message;
 
-		ServerToSoDTextLink(new_message, old_message);
+		ServerToSoDSayLink(new_message, old_message);
 
 		//in->size = 3 + 4 + 4 + strlen(emu->sayer) + 1 + 12 + new_message.length() + 1;
 		in->size = strlen(emu->sayer) + new_message.length() + 25;
@@ -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;
-		ServerToSoDTextLink(new_message, old_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];
 
@@ -2932,25 +2827,6 @@ namespace SoD
 		FINISH_DIRECT_DECODE();
 	}
 
-	DECODE(OP_Bug)
-	{
-		DECODE_LENGTH_EXACT(structs::BugStruct);
-		SETUP_DIRECT_DECODE(BugStruct, structs::BugStruct);
-
-		strn0cpy(emu->chartype, eq->chartype, sizeof(emu->chartype));
-		strn0cpy(emu->name, eq->name, sizeof(emu->name));
-		strn0cpy(emu->ui, eq->ui, sizeof(emu->ui));
-		IN(x);
-		IN(y);
-		IN(z);
-		IN(heading);
-		strn0cpy(emu->target_name, eq->target_name, sizeof(emu->target_name));
-		strn0cpy(emu->bug, eq->bug, sizeof(emu->bug));
-		strn0cpy(emu->system_info, eq->system_info, sizeof(emu->system_info));
-
-		FINISH_DIRECT_DECODE();
-	}
-
 	DECODE(OP_CastSpell)
 	{
 		DECODE_LENGTH_EXACT(structs::CastSpell_Struct);
@@ -2971,7 +2847,7 @@ namespace SoD
 
 		std::string old_message = (char *)&__eq_buffer[sizeof(ChannelMessage_Struct)];
 		std::string new_message;
-		SoDToServerTextLink(new_message, old_message);
+		SoDToServerSayLink(new_message, old_message);
 
 		__packet->size = sizeof(ChannelMessage_Struct) + new_message.length() + 1;
 		__packet->pBuffer = new unsigned char[__packet->size];
@@ -3085,7 +2961,7 @@ namespace SoD
 
 		std::string old_message = (char *)&__eq_buffer[4]; // unknown01 offset
 		std::string new_message;
-		SoDToServerTextLink(new_message, old_message);
+		SoDToServerSayLink(new_message, old_message);
 
 		__packet->size = sizeof(Emote_Struct);
 		__packet->pBuffer = new unsigned char[__packet->size];
@@ -3597,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;
@@ -3687,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];
@@ -3860,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;
 
@@ -3889,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;
@@ -3914,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;
@@ -3935,19 +3811,19 @@ namespace SoD
 		return (sodCorpseSlot - 1);
 	}
 
-	static inline void ServerToSoDTextLink(std::string& sodTextLink, const std::string& serverTextLink)
+	static inline void ServerToSoDSayLink(std::string& sodSayLink, const std::string& serverSayLink)
 	{
-		if ((constants::SayLinkBodySize == EQEmu::legacy::TEXT_LINK_BODY_LENGTH) || (serverTextLink.find('\x12') == std::string::npos)) {
+		if ((constants::SAY_LINK_BODY_SIZE == EQEmu::constants::SAY_LINK_BODY_SIZE) || (serverSayLink.find('\x12') == std::string::npos)) {
-			sodTextLink = serverTextLink;
+			sodSayLink = serverSayLink;
 			return;
 		}
 
-		auto segments = SplitString(serverTextLink, '\x12');
+		auto segments = SplitString(serverSayLink, '\x12');
 
 		for (size_t segment_iter = 0; segment_iter < segments.size(); ++segment_iter) {
 			if (segment_iter & 1) {
-				if (segments[segment_iter].length() <= EQEmu::legacy::TEXT_LINK_BODY_LENGTH) {
+				if (segments[segment_iter].length() <= EQEmu::constants::SAY_LINK_BODY_SIZE) {
-					sodTextLink.append(segments[segment_iter]);
+					sodSayLink.append(segments[segment_iter]);
 					// TODO: log size mismatch error
 					continue;
 				}
@@ -3957,37 +3833,37 @@ namespace SoD
 				// SoF:  X XXXXX XXXXX XXXXX XXXXX XXXXX XXXXX       X  XXXX  X XXXXX XXXXXXXX (50)
 				// Diff:                                       ^^^^^         ^
 
-				sodTextLink.push_back('\x12');
+				sodSayLink.push_back('\x12');
-				sodTextLink.append(segments[segment_iter].substr(0, 31));
+				sodSayLink.append(segments[segment_iter].substr(0, 31));
-				sodTextLink.append(segments[segment_iter].substr(36, 5));
+				sodSayLink.append(segments[segment_iter].substr(36, 5));
 
 				if (segments[segment_iter][41] == '0')
-					sodTextLink.push_back(segments[segment_iter][42]);
+					sodSayLink.push_back(segments[segment_iter][42]);
 				else
-					sodTextLink.push_back('F');
+					sodSayLink.push_back('F');
 
-				sodTextLink.append(segments[segment_iter].substr(43));
+				sodSayLink.append(segments[segment_iter].substr(43));
-				sodTextLink.push_back('\x12');
+				sodSayLink.push_back('\x12');
 			}
 			else {
-				sodTextLink.append(segments[segment_iter]);
+				sodSayLink.append(segments[segment_iter]);
 			}
 		}
 	}
 
-	static inline void SoDToServerTextLink(std::string& serverTextLink, const std::string& sodTextLink)
+	static inline void SoDToServerSayLink(std::string& serverSayLink, const std::string& sodSayLink)
 	{
-		if ((EQEmu::legacy::TEXT_LINK_BODY_LENGTH == constants::SayLinkBodySize) || (sodTextLink.find('\x12') == std::string::npos)) {
+		if ((EQEmu::constants::SAY_LINK_BODY_SIZE == constants::SAY_LINK_BODY_SIZE) || (sodSayLink.find('\x12') == std::string::npos)) {
-			serverTextLink = sodTextLink;
+			serverSayLink = sodSayLink;
 			return;
 		}
 
-		auto segments = SplitString(sodTextLink, '\x12');
+		auto segments = SplitString(sodSayLink, '\x12');
 
 		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) {
-					serverTextLink.append(segments[segment_iter]);
+					serverSayLink.append(segments[segment_iter]);
 					// TODO: log size mismatch error
 					continue;
 				}
@@ -3997,16 +3873,16 @@ namespace SoD
 				// RoF2: X XXXXX XXXXX XXXXX XXXXX XXXXX XXXXX XXXXX X  XXXX XX  XXXXX XXXXXXXX (56)
 				// Diff:                                       ^^^^^         ^
 
-				serverTextLink.push_back('\x12');
+				serverSayLink.push_back('\x12');
-				serverTextLink.append(segments[segment_iter].substr(0, 31));
+				serverSayLink.append(segments[segment_iter].substr(0, 31));
-				serverTextLink.append("00000");
+				serverSayLink.append("00000");
-				serverTextLink.append(segments[segment_iter].substr(31, 5));
+				serverSayLink.append(segments[segment_iter].substr(31, 5));
-				serverTextLink.push_back('0');
+				serverSayLink.push_back('0');
-				serverTextLink.append(segments[segment_iter].substr(36));
+				serverSayLink.append(segments[segment_iter].substr(36));
-				serverTextLink.push_back('\x12');
+				serverSayLink.push_back('\x12');
 			}
 			else {
-				serverTextLink.append(segments[segment_iter]);
+				serverSayLink.append(segments[segment_iter]);
 			}
 		}
 	}

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 {
-		enum InventoryType : int {
+				typePossessions = INULL,
-			InvTypePossessions = InvTypeBegin,
+				typeBank,
-			InvTypeBank,
+				typeSharedBank,
-			InvTypeSharedBank,
+				typeTrade,
-			InvTypeTrade,
+				typeWorld,
-			InvTypeWorld,
+				typeLimbo,
-			InvTypeLimbo,
+				typeTribute,
-			InvTypeTribute,
+				typeGuildTribute,
-			InvTypeGuildTribute,
+				typeMerchant,
-			InvTypeMerchant,
+				typeCorpse,
-			InvTypeCorpse,
+				typeBazaar,
-			InvTypeBazaar,
+				typeInspect,
-			InvTypeInspect,
+				typeViewMODPC,
-			InvTypeViewMODPC,
+				typeViewMODBank,
-			InvTypeViewMODBank,
+				typeViewMODSharedBank,
-			InvTypeViewMODSharedBank,
+				typeViewMODLimbo,
-			InvTypeViewMODLimbo,
+				typeAltStorage,
-			InvTypeAltStorage,
+				typeArchived,
-			InvTypeArchived,
+				typeOther
-			InvTypeOther,
-			InvTypeCount
 			};
 
+		} // namespace enum_
+		using namespace enum_;
+
+		const int16 POSSESSIONS_SIZE = 32;
+		const int16 BANK_SIZE = 24;
+		const int16 SHARED_BANK_SIZE = 2;
+		const int16 TRADE_SIZE = 8;
+		const int16 WORLD_SIZE = 10;
+		const int16 LIMBO_SIZE = 36;
+		const int16 TRIBUTE_SIZE = 5;
+		const int16 GUILD_TRIBUTE_SIZE = 2;
+		const int16 MERCHANT_SIZE = 80;
+		const int16 CORPSE_SIZE = POSSESSIONS_SIZE;
+		const int16 BAZAAR_SIZE = 80;
+		const int16 INSPECT_SIZE = 23;
+		const int16 VIEW_MOD_PC_SIZE = POSSESSIONS_SIZE;
+		const int16 VIEW_MOD_BANK_SIZE = BANK_SIZE;
+		const int16 VIEW_MOD_SHARED_BANK_SIZE = SHARED_BANK_SIZE;
+		const int16 VIEW_MOD_LIMBO_SIZE = LIMBO_SIZE;
+		const int16 ALT_STORAGE_SIZE = 0;//unknown - "Shroud Bank"
+		const int16 ARCHIVED_SIZE = 0;//unknown
+		const int16 OTHER_SIZE = 0;//unknown
+
+		const int16 TRADE_NPC_SIZE = 4; // defined by implication
+
+		const int16 TYPE_INVALID = IINVALID;
+		const int16 TYPE_BEGIN = typePossessions;
+		const int16 TYPE_END = typeOther;
+		const int16 TYPE_COUNT = (TYPE_END - TYPE_BEGIN) + 1;
+
+		int16 GetInvTypeSize(int16 inv_type);
+		const char* GetInvTypeName(int16 inv_type);
+
+		bool IsInvTypePersistent(int16 inv_type);
+
 	} /*invtype*/
 
 	namespace invslot {
 		inline EQEmu::versions::ClientVersion GetInvSlotRef() { return EQEmu::versions::ClientVersion::SoD; }
 
-		enum : int { InvSlotInvalid = -1, InvSlotBegin };
+		namespace enum_ {
-
+			enum InventorySlots : int16 {
-		enum PossessionsSlot : int {
+				slotCharm = INULL,
-			PossessionsCharm = InvSlotBegin,
+				slotEar1,
-			PossessionsEar1,
+				slotHead,
-			PossessionsHead,
+				slotFace,
-			PossessionsFace,
+				slotEar2,
-			PossessionsEar2,
+				slotNeck,
-			PossessionsNeck,
+				slotShoulders,
-			PossessionsShoulders,
+				slotArms,
-			PossessionsArms,
+				slotBack,
-			PossessionsBack,
+				slotWrist1,
-			PossessionsWrist1,
+				slotWrist2,
-			PossessionsWrist2,
+				slotRange,
-			PossessionsRange,
+				slotHands,
-			PossessionsHands,
+				slotPrimary,
-			PossessionsPrimary,
+				slotSecondary,
-			PossessionsSecondary,
+				slotFinger1,
-			PossessionsFinger1,
+				slotFinger2,
-			PossessionsFinger2,
+				slotChest,
-			PossessionsChest,
+				slotLegs,
-			PossessionsLegs,
+				slotFeet,
-			PossessionsFeet,
+				slotWaist,
-			PossessionsWaist,
+				slotPowerSource,
-			PossessionsPowerSource,
+				slotAmmo,
-			PossessionsAmmo,
+				slotGeneral1,
-			PossessionsGeneral1,
+				slotGeneral2,
-			PossessionsGeneral2,
+				slotGeneral3,
-			PossessionsGeneral3,
+				slotGeneral4,
-			PossessionsGeneral4,
+				slotGeneral5,
-			PossessionsGeneral5,
+				slotGeneral6,
-			PossessionsGeneral6,
+				slotGeneral7,
-			PossessionsGeneral7,
+				slotGeneral8,
-			PossessionsGeneral8,
+				slotCursor
-			PossessionsCursor,
-			PossessionsCount
 			};
 
-		const int EquipmentBegin = PossessionsCharm;
+		} // namespace enum_
-		const int EquipmentEnd = PossessionsAmmo;
+		using namespace enum_;
-		const int EquipmentCount = (EquipmentEnd - EquipmentBegin + 1);
 
-		const int GeneralBegin = PossessionsGeneral1;
+		const int16 SLOT_INVALID = IINVALID;
-		const int GeneralEnd = PossessionsGeneral8;
+		const int16 SLOT_BEGIN = INULL;
-		const int GeneralCount = (GeneralEnd - GeneralBegin + 1);
+
+		const int16 POSSESSIONS_BEGIN = slotCharm;
+		const int16 POSSESSIONS_END = slotCursor;
+		const int16 POSSESSIONS_COUNT = (POSSESSIONS_END - POSSESSIONS_BEGIN) + 1;
+
+		const int16 EQUIPMENT_BEGIN = slotCharm;
+		const int16 EQUIPMENT_END = slotAmmo;
+		const int16 EQUIPMENT_COUNT = (EQUIPMENT_END - EQUIPMENT_BEGIN + 1);
+
+		const int16 GENERAL_BEGIN = slotGeneral1;
+		const int16 GENERAL_END = slotGeneral8;
+		const int16 GENERAL_COUNT = (GENERAL_END - GENERAL_BEGIN + 1);
+
+		const int16 BONUS_BEGIN = invslot::slotCharm;
+		const int16 BONUS_STAT_END = invslot::slotPowerSource;
+		const int16 BONUS_SKILL_END = invslot::slotAmmo;
+
+		const int16 BANK_BEGIN = 2000;
+		const int16 BANK_END = (BANK_BEGIN + invtype::BANK_SIZE) - 1;
+
+		const int16 SHARED_BANK_BEGIN = 2500;
+		const int16 SHARED_BANK_END = (SHARED_BANK_BEGIN + invtype::SHARED_BANK_SIZE) - 1;
+
+		const int16 TRADE_BEGIN = 3000;
+		const int16 TRADE_END = (TRADE_BEGIN + invtype::TRADE_SIZE) - 1;
+
+		const int16 TRADE_NPC_END = (TRADE_BEGIN + invtype::TRADE_NPC_SIZE) - 1; // defined by implication
+
+		const int16 WORLD_BEGIN = 4000;
+		const int16 WORLD_END = (WORLD_BEGIN + invtype::WORLD_SIZE) - 1;
+
+		const int16 TRIBUTE_BEGIN = 400;
+		const int16 TRIBUTE_END = (TRIBUTE_BEGIN + invtype::TRIBUTE_SIZE) - 1;
+
+		const int16 GUILD_TRIBUTE_BEGIN = 450;
+		const int16 GUILD_TRIBUTE_END = (GUILD_TRIBUTE_BEGIN + invtype::GUILD_TRIBUTE_SIZE) - 1;
+
+		const int16 CORPSE_BEGIN = invslot::slotGeneral1;
+		const int16 CORPSE_END = invslot::slotGeneral1 + invslot::slotCursor;
+
+		const uint64 POSSESSIONS_BITMASK = 0x000000027FFFFFFF; // based on 34-slot count (RoF+)
+		const uint64 CORPSE_BITMASK = 0x01FFFFFE7F800000; // based on 34-slot count (RoF+)
+
+		const char* GetInvPossessionsSlotName(int16 inv_slot);
+		const char* GetInvCorpseSlotName(int16 inv_slot);
+		const char* GetInvSlotName(int16 inv_type, int16 inv_slot);
 
 	} /*invslot*/
 
 	namespace invbag {
 		inline EQEmu::versions::ClientVersion GetInvBagRef() { return EQEmu::versions::ClientVersion::SoD; }
 
-		enum : int { InvBagInvalid = -1, InvBagBegin };
+		const int16 SLOT_INVALID = IINVALID;
+		const int16 SLOT_BEGIN = INULL;
+		const int16 SLOT_END = 9;
+		const int16 SLOT_COUNT = 10;
+
+		const int16 GENERAL_BAGS_BEGIN = 262;
+		const int16 GENERAL_BAGS_COUNT = invslot::GENERAL_COUNT * SLOT_COUNT;
+		const int16 GENERAL_BAGS_END = (GENERAL_BAGS_BEGIN + GENERAL_BAGS_COUNT) - 1;
+
+		const int16 CURSOR_BAG_BEGIN = 342;
+		const int16 CURSOR_BAG_COUNT = SLOT_COUNT;
+		const int16 CURSOR_BAG_END = (CURSOR_BAG_BEGIN + CURSOR_BAG_COUNT) - 1;
+
+		const int16 BANK_BAGS_BEGIN = 2032;
+		const int16 BANK_BAGS_COUNT = (invtype::BANK_SIZE * SLOT_COUNT);
+		const int16 BANK_BAGS_END = (BANK_BAGS_BEGIN + BANK_BAGS_COUNT) - 1;
+
+		const int16 SHARED_BANK_BAGS_BEGIN = 2532;
+		const int16 SHARED_BANK_BAGS_COUNT = invtype::SHARED_BANK_SIZE * SLOT_COUNT;
+		const int16 SHARED_BANK_BAGS_END = (SHARED_BANK_BAGS_BEGIN + SHARED_BANK_BAGS_COUNT) - 1;
+
+		const int16 TRADE_BAGS_BEGIN = 3031;
+		const int16 TRADE_BAGS_COUNT = invtype::TRADE_SIZE * SLOT_COUNT;
+		const int16 TRADE_BAGS_END = (TRADE_BAGS_BEGIN + TRADE_BAGS_COUNT) - 1;
+
+		const char* GetInvBagIndexName(int16 bag_index);
 
 	} /*invbag*/
 
 	namespace invaug {
 		inline EQEmu::versions::ClientVersion GetInvAugRef() { return EQEmu::versions::ClientVersion::SoD; }
 
-		enum : int { InvAugInvalid = -1, InvAugBegin };
+		const int16 SOCKET_INVALID = IINVALID;
+		const int16 SOCKET_BEGIN = INULL;
+		const int16 SOCKET_END = 4;
+		const int16 SOCKET_COUNT = 5;
+
+		const char* GetInvAugIndexName(int16 aug_index);
 
 	} /*invaug*/
 
@@ -153,147 +263,21 @@ namespace SoD
 	namespace profile {
 		inline EQEmu::versions::ClientVersion GetProfileRef() { return EQEmu::versions::ClientVersion::SoD; }
 
+		const int16 BANDOLIERS_SIZE = 20;		// number of bandolier instances
+		const int16 BANDOLIER_ITEM_COUNT = 4;	// number of equipment slots in bandolier instance
+
+		const int16 POTION_BELT_SIZE = 5;
+
+		const int16 SKILL_ARRAY_SIZE = 100;
+
 	} /*profile*/
 
 	namespace constants {
 		inline EQEmu::versions::ClientVersion GetConstantsRef() { return EQEmu::versions::ClientVersion::SoD; }
 
-	} /*constants*/
+		const size_t CHARACTER_CREATION_LIMIT = 12;
 
-	namespace behavior {
+		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)
@@ -104,7 +103,6 @@ D(OP_AugmentInfo)
 D(OP_AugmentItem)
 D(OP_BazaarSearch)
 D(OP_Buff)
-D(OP_Bug)
 D(OP_CastSpell)
 D(OP_ChannelMessage)
 D(OP_CharacterCreate)

common/patches/sod_structs.h

@@ -292,7 +292,7 @@ struct Spawn_Struct
 /*0000*/ //uint8     nullterm1; // hack to null terminate name
 /*0064*/ uint32 spawnId;
 /*0068*/ uint8  level;
-/*0069*/ float    unknown1;
+/*0069*/ float  bounding_radius; // used in melee, overrides calc
 /*0073*/ uint8  NPC;           // 0=player,1=npc,2=pc corpse,3=npc corpse
 	 Spawn_Struct_Bitfields	Bitfields;
 /*0000*/ uint8  otherData; // & 4 - has title, & 8 - has suffix, & 1 - it's a chest or untargetable
@@ -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;
@@ -818,6 +818,7 @@ static const uint32 MAX_PP_LANGUAGE		= 25; //
 static const uint32 MAX_PP_SPELLBOOK	= 480; // Confirmed 60 pages on Live now
 static const uint32 MAX_PP_MEMSPELL		= 10; //was 9 now 10 on Live
 static const uint32 MAX_PP_SKILL		= PACKET_SKILL_ARRAY_SIZE;	// 100 - actual skills buffer size
+static const uint32 MAX_PP_INNATE_SKILL	= 25;
 static const uint32 MAX_PP_AA_ARRAY		= 300; //was 299
 static const uint32 MAX_GROUP_MEMBERS	= 6;
 static const uint32 MAX_RECAST_TYPES	= 20;
@@ -923,7 +924,8 @@ struct PlayerProfile_Struct
 /*06488*/ uint32  silver_cursor;		// Silver Pieces on cursor
 /*06492*/ uint32  copper_cursor;		// Copper Pieces on cursor
 /*06496*/ uint32  skills[MAX_PP_SKILL];	// [400] List of skills	// 100 dword buffer
-/*06896*/ uint8 unknown04760[136];
+/*06896*/ uint32  InnateSkills[MAX_PP_INNATE_SKILL];
+/*06996*/ uint8   unknown04760[36];
 /*07032*/ uint32  toxicity;				// Potion Toxicity (15=too toxic, each potion adds 3)
 /*07036*/ uint32  thirst_level;			// Drink (ticks till next drink)
 /*07040*/ uint32  hunger_level;			// Food (ticks till next eat)
@@ -935,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;
@@ -1213,20 +1215,18 @@ struct Action_Struct
 {
  /* 00 */	uint16 target;	// id of target
  /* 02 */	uint16 source;	// id of caster
- /* 04 */	uint16 level; // level of caster
+ /* 04 */	uint16 level; // level of caster for spells, OSX dump says attack rating, guess spells use it for level
- /* 06 */	uint16 instrument_mod;	// seems to be fixed to 0x0A
+ /* 06 */	uint32 instrument_mod;	// OSX dump says base damage, spells use it for bard song (different from newer clients)
- /* 08 */	uint32 unknown08;
+ /* 10 */	float force;
- /* 12 */	uint16 unknown16;
+ /* 14 */	float hit_heading;
-// some kind of sequence that's the same in both actions
+ /* 18 */	float hit_pitch;
-// as well as the combat damage, to tie em together?
+ /* 22 */	uint8 type;		// 231 (0xE7) for spells, skill
- /* 14 */	float sequence;		// was uint32
+ /* 23 */	uint16 unknown23; // OSX says min_damage
- /* 18 */	uint32 unknown18;
+ /* 25 */	uint16 unknown25; // OSX says tohit
- /* 22 */	uint8 type;		// 231 (0xE7) for spells
- /* 23 */	uint32 unknown23;
  /* 27 */	uint16 spell;	// spell id being cast
- /* 29 */	uint8 level2;	// level of caster again? Or maybe the castee
+ /* 29 */	uint8 spell_level;	// level of caster again? Or maybe the castee
 // this field seems to be some sort of success flag, if it's 4
- /* 30 */	uint8 buff_unknown;	// if this is 4, a buff icon is made
+ /* 30 */	uint8 effect_flag;	// if this is 4, a buff icon is made
  /* 31 */
 };
 
@@ -1235,26 +1235,23 @@ struct Action_Struct
 // has to do with buff blocking??
 struct ActionAlt_Struct // ActionAlt_Struct - Size: 56 bytes
 {
-/*0000*/ uint16 target;                 // Target ID
+/*0000*/ uint16 target;	// id of target
-/*0002*/ uint16 source;                 // SourceID
+/*0002*/ uint16 source;	// id of caster
-/*0004*/ uint16 level;					// level of caster
+/*0004*/ uint16 level; // level of caster for spells, OSX dump says attack rating, guess spells use it for level
-/*0006*/ uint16 instrument_mod;				// seems to be fixed to 0x0A
+/*0006*/ uint32 instrument_mod;	// OSX dump says base damage, spells use it for bard song (different from newer clients)
-/*0008*/ uint32 unknown08;
+/*0010*/ float force;
-/*0012*/ uint16 unknown16;
+/*0014*/ float hit_heading;
-/*0014*/ uint32 sequence;
+/*0018*/ float hit_pitch;
-/*0018*/ uint32 unknown18;
+/*0022*/ uint8 type;		// 231 (0xE7) for spells, skill
-/*0022*/ uint8  type;                   // Casts, Falls, Bashes, etc...
+/*0023*/ uint16 unknown23; // OSX says min_damage
-/*0023*/ uint32  damage;                 // Amount of Damage
+/*0025*/ uint16 unknown25; // OSX says tohit
-/*0027*/ uint16  spell;                  // SpellID
+/*0027*/ uint16 spell;	// spell id being cast
-/*0029*/ uint8 unknown29;
+/*0029*/ uint8 spell_level;	// level of caster again? Or maybe the castee
-/*0030*/ uint8 buff_unknown;				// if this is 4, a buff icon is made
+// this field seems to be some sort of success flag, if it's 4
-/*0031*/ uint32 unknown0031;			// seen 00 00 00 00
+/*0030*/ uint8 effect_flag;	// if this is 4, a buff icon is made
-/*0035*/ uint8 unknown0035;				// seen 00
+/*0031*/ uint8 spell_slot;
-/*0036*/ uint32 unknown0036;			// seen ff ff ff ff
+/*0032*/ uint32 slot[5];
-/*0040*/ uint32 unknown0040;			// seen ff ff ff ff
+/*0052*/ uint32 item_cast_type;	// ItemSpellTypes enum from MQ2
-/*0044*/ uint32 unknown0044;			// seen ff ff ff ff
-/*0048*/ uint32 unknown0048;			// seen 00 00 00 00
-/*0052*/ uint32 unknown0052;			// seen 00 00 00 00
 /*0056*/
 };
 
@@ -1269,9 +1266,9 @@ struct CombatDamage_Struct
 /* 05 */	uint16	spellid;
 /* 07 */	int32	damage;
 /* 11 */	float	force;		// cd cc cc 3d
-/* 15 */	float	meleepush_xy;		// see above notes in Action_Struct
+/* 15 */	float	hit_heading;		// see above notes in Action_Struct
-/* 19 */	float	meleepush_z;
+/* 19 */	float	hit_pitch;
-/* 23 */	uint8	unknown23;	// was [9]
+/* 23 */	uint8	secondary;	// 0 for primary hand, 1 for secondary
 /* 24 */	uint32	special; // 2 = Rampage, 1 = Wild Rampage
 /* 28 */
 };
@@ -3006,24 +3003,6 @@ struct GuildMakeLeader{
 	char	target[64];
 };
 
-struct BugStruct{
-/*0000*/    uint32  type1; //seems to be just a different way of seeing type; seems to be ordered completely differently
-/*0004*/	char	chartype[64];
-/*0068*/	char	name[96];
-/*0164*/	char	ui[128];
-/*0292*/	float	x;
-/*0296*/	float	y;
-/*0300*/	float	z;
-/*0304*/	float	heading;
-/*0308*/	uint32	unknown304;
-/*0312*/	char	unknown308[160];
-/*0472*/	char	target_name[64];
-/*0536*/	uint32	type;
-/*0540*/	char	unknown536[2052];
-/*2588*/	char	bug[2048];
-/*4636*/	char	unknown4632[6];
-/*4642*/	char	system_info[4094];
-};
 struct Make_Pet_Struct { //Simple struct for getting pet info
 	uint8 level;
 	uint8 class_;
@@ -3050,20 +3029,21 @@ struct Ground_Spawn{
 struct Ground_Spawns {
 	struct Ground_Spawn spawn[50]; //Assigned max number to allow
 };
-struct PetitionBug_Struct{
+
-	uint32	petition_number;
+//struct PetitionBug_Struct{
-	uint32	unknown4;
+//	uint32	petition_number;
-	char	accountname[64];
+//	uint32	unknown4;
-	uint32	zoneid;
+//	char	accountname[64];
-	char	name[64];
+//	uint32	zoneid;
-	uint32	level;
+//	char	name[64];
-	uint32	class_;
+//	uint32	level;
-	uint32	race;
+//	uint32	class_;
-	uint32	unknown152[3];
+//	uint32	race;
-	uint32	time;
+//	uint32	unknown152[3];
-	uint32	unknown168;
+//	uint32	time;
-	char	text[1028];
+//	uint32	unknown168;
-};
+//	char	text[1028];
+//};
 
 struct ApproveZone_Struct {
 	char	name[64];
@@ -4400,6 +4380,22 @@ struct MercenaryAssign_Struct {
 /*0004*/	uint32	MercUnk01;		//
 /*0008*/	uint32	MercUnk02;		//
 /*0012*/
+};
+
+struct SayLinkBodyFrame_Struct {
+/*000*/	char ActionID[1];
+/*001*/	char ItemID[5];
+/*006*/	char Augment1[5];
+/*011*/	char Augment2[5];
+/*016*/	char Augment3[5];
+/*021*/	char Augment4[5];
+/*026*/	char Augment5[5];
+/*031*/	char IsEvolving[1];
+/*032*/	char EvolveGroup[4];
+/*036*/	char EvolveLevel[1];
+/*037*/	char OrnamentIcon[5];
+/*042*/	char Hash[8];
+/*050*/
 };
 
 	}; /*structs*/

common/patches/sof.cpp

@@ -53,11 +53,11 @@ namespace SoF
 	static inline uint32 SoFToServerSlot(uint32 sofSlot);
 	static inline uint32 SoFToServerCorpseSlot(uint32 sofCorpseSlot);
 
-	// server to client text link converter
+	// server to client say link converter
-	static inline void ServerToSoFTextLink(std::string& sofTextLink, const std::string& serverTextLink);
+	static inline void ServerToSoFSayLink(std::string& sofSayLink, const std::string& serverSayLink);
 
-	// client to server text link converter
+	// client to server say link converter
-	static inline void SoFToServerTextLink(std::string& serverTextLink, const std::string& sofTextLink);
+	static inline void SoFToServerSayLink(std::string& serverSayLink, const std::string& sofSayLink);
 
 	static inline CastingSlot ServerToSoFCastingSlot(EQEmu::CastingSlot slot);
 	static inline EQEmu::CastingSlot SoFToServerCastingSlot(CastingSlot slot, uint32 itemlocation);
@@ -161,15 +161,14 @@ namespace SoF
 		OUT(source);
 		OUT(level);
 		OUT(instrument_mod);
-		eq->sequence = emu->sequence;
+		OUT(force);
+		OUT(hit_heading);
+		OUT(hit_pitch);
 		OUT(type);
 		//OUT(damage);
 		OUT(spell);
-		eq->level2 = emu->level;
+		OUT(spell_level);
-		OUT(buff_unknown); // if this is 4, a buff icon is made
+		OUT(effect_flag); // if this is 4, a buff icon is made
-		//eq->unknown0036 = -1;
-		//eq->unknown0040 = -1;
-		//eq->unknown0044 = -1;
 
 		FINISH_ENCODE();
 	}
@@ -328,7 +327,7 @@ namespace SoF
 
 		std::string old_message = emu->message;
 		std::string new_message;
-		ServerToSoFTextLink(new_message, old_message);
+		ServerToSoFSayLink(new_message, old_message);
 
 		in->size = sizeof(ChannelMessage_Struct) + new_message.length() + 1;
 
@@ -440,8 +439,8 @@ namespace SoF
 		OUT(spellid);
 		OUT(damage);
 		OUT(force);
-		OUT(meleepush_xy);
+		OUT(hit_heading);
-		OUT(meleepush_z);
+		OUT(hit_pitch);
 
 		FINISH_ENCODE();
 	}
@@ -613,7 +612,7 @@ namespace SoF
 
 		std::string old_message = emu->message;
 		std::string new_message;
-		ServerToSoFTextLink(new_message, old_message);
+		ServerToSoFSayLink(new_message, old_message);
 
 		//if (new_message.length() > 512) // length restricted in packet building function due vari-length name size (no nullterm)
 		//	new_message = new_message.substr(0, 512);
@@ -665,7 +664,7 @@ namespace SoF
 
 		for (int i = 0; i < 9; ++i) {
 			if (old_message_array[i].length() == 0) { break; }
-			ServerToSoFTextLink(new_message_array[i], old_message_array[i]);
+			ServerToSoFSayLink(new_message_array[i], old_message_array[i]);
 			new_message_size += new_message_array[i].length() + 1;
 		}
 
@@ -1061,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);
@@ -1276,6 +1163,7 @@ namespace SoF
 		OUT(copper_cursor);
 
 		OUT_array(skills, structs::MAX_PP_SKILL);	// 1:1 direct copy (100 dword)
+		OUT_array(InnateSkills, structs::MAX_PP_INNATE_SKILL);  // 1:1 direct copy (25 dword)
 
 		//	OUT(unknown04760[236]);
 		OUT(toxicity);
@@ -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);
@@ -1813,7 +1701,7 @@ namespace SoF
 		std::string old_message = &emu->message[strlen(emu->sayer)];
 		std::string new_message;
 
-		ServerToSoFTextLink(new_message, old_message);
+		ServerToSoFSayLink(new_message, old_message);
 
 		//in->size = 3 + 4 + 4 + strlen(emu->sayer) + 1 + 12 + new_message.length() + 1;
 		in->size = strlen(emu->sayer) + new_message.length() + 25;
@@ -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;
-		ServerToSoFTextLink(new_message, old_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];
 
@@ -2384,6 +2275,17 @@ namespace SoF
 		FINISH_DIRECT_DECODE();
 	}
 
+	DECODE(OP_Bug)
+	{
+		DECODE_LENGTH_EXACT(structs::BugReport_Struct);
+		SETUP_DIRECT_DECODE(BugReport_Struct, structs::BugReport_Struct);
+
+		emu->category_id = EQEmu::bug::CategoryNameToCategoryID(eq->category_name);
+		memcpy(emu->category_name, eq, sizeof(structs::BugReport_Struct));
+
+		FINISH_DIRECT_DECODE();
+	}
+
 	DECODE(OP_CastSpell)
 	{
 		DECODE_LENGTH_EXACT(structs::CastSpell_Struct);
@@ -2403,7 +2305,7 @@ namespace SoF
 
 		std::string old_message = (char *)&__eq_buffer[sizeof(ChannelMessage_Struct)];
 		std::string new_message;
-		SoFToServerTextLink(new_message, old_message);
+		SoFToServerSayLink(new_message, old_message);
 
 		__packet->size = sizeof(ChannelMessage_Struct) + new_message.length() + 1;
 		__packet->pBuffer = new unsigned char[__packet->size];
@@ -2517,7 +2419,7 @@ namespace SoF
 
 		std::string old_message = (char *)&__eq_buffer[4]; // unknown01 offset
 		std::string new_message;
-		SoFToServerTextLink(new_message, old_message);
+		SoFToServerSayLink(new_message, old_message);
 
 		__packet->size = sizeof(Emote_Struct);
 		__packet->pBuffer = new unsigned char[__packet->size];
@@ -2965,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;
@@ -3055,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];
@@ -3227,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;
 
@@ -3256,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;
 
@@ -3282,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;
 
@@ -3304,19 +3206,19 @@ namespace SoF
 		return (sofCorpseSlot - 1);
 	}
 
-	static inline void ServerToSoFTextLink(std::string& sofTextLink, const std::string& serverTextLink)
+	static inline void ServerToSoFSayLink(std::string& sofSayLink, const std::string& serverSayLink)
 	{
-		if ((constants::SayLinkBodySize == EQEmu::legacy::TEXT_LINK_BODY_LENGTH) || (serverTextLink.find('\x12') == std::string::npos)) {
+		if ((constants::SAY_LINK_BODY_SIZE == EQEmu::constants::SAY_LINK_BODY_SIZE) || (serverSayLink.find('\x12') == std::string::npos)) {
-			sofTextLink = serverTextLink;
+			sofSayLink = serverSayLink;
 			return;
 		}
 
-		auto segments = SplitString(serverTextLink, '\x12');
+		auto segments = SplitString(serverSayLink, '\x12');
 
 		for (size_t segment_iter = 0; segment_iter < segments.size(); ++segment_iter) {
 			if (segment_iter & 1) {
-				if (segments[segment_iter].length() <= EQEmu::legacy::TEXT_LINK_BODY_LENGTH) {
+				if (segments[segment_iter].length() <= EQEmu::constants::SAY_LINK_BODY_SIZE) {
-					sofTextLink.append(segments[segment_iter]);
+					sofSayLink.append(segments[segment_iter]);
 					// TODO: log size mismatch error
 					continue;
 				}
@@ -3326,37 +3228,37 @@ namespace SoF
 				// SoF:  X XXXXX XXXXX XXXXX XXXXX XXXXX XXXXX       X  XXXX  X XXXXX XXXXXXXX (50)
 				// Diff:                                       ^^^^^         ^
 
-				sofTextLink.push_back('\x12');
+				sofSayLink.push_back('\x12');
-				sofTextLink.append(segments[segment_iter].substr(0, 31));
+				sofSayLink.append(segments[segment_iter].substr(0, 31));
-				sofTextLink.append(segments[segment_iter].substr(36, 5));
+				sofSayLink.append(segments[segment_iter].substr(36, 5));
 
 				if (segments[segment_iter][41] == '0')
-					sofTextLink.push_back(segments[segment_iter][42]);
+					sofSayLink.push_back(segments[segment_iter][42]);
 				else
-					sofTextLink.push_back('F');
+					sofSayLink.push_back('F');
 
-				sofTextLink.append(segments[segment_iter].substr(43));
+				sofSayLink.append(segments[segment_iter].substr(43));
-				sofTextLink.push_back('\x12');
+				sofSayLink.push_back('\x12');
 			}
 			else {
-				sofTextLink.append(segments[segment_iter]);
+				sofSayLink.append(segments[segment_iter]);
 			}
 		}
 	}
 
-	static inline void SoFToServerTextLink(std::string& serverTextLink, const std::string& sofTextLink)
+	static inline void SoFToServerSayLink(std::string& serverSayLink, const std::string& sofSayLink)
 	{
-		if ((EQEmu::legacy::TEXT_LINK_BODY_LENGTH == constants::SayLinkBodySize) || (sofTextLink.find('\x12') == std::string::npos)) {
+		if ((EQEmu::constants::SAY_LINK_BODY_SIZE == constants::SAY_LINK_BODY_SIZE) || (sofSayLink.find('\x12') == std::string::npos)) {
-			serverTextLink = sofTextLink;
+			serverSayLink = sofSayLink;
 			return;
 		}
 
-		auto segments = SplitString(sofTextLink, '\x12');
+		auto segments = SplitString(sofSayLink, '\x12');
 
 		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) {
-					serverTextLink.append(segments[segment_iter]);
+					serverSayLink.append(segments[segment_iter]);
 					// TODO: log size mismatch error
 					continue;
 				}
@@ -3366,16 +3268,16 @@ namespace SoF
 				// RoF2: X XXXXX XXXXX XXXXX XXXXX XXXXX XXXXX XXXXX X  XXXX XX  XXXXX XXXXXXXX (56)
 				// Diff:                                       ^^^^^         ^
 
-				serverTextLink.push_back('\x12');
+				serverSayLink.push_back('\x12');
-				serverTextLink.append(segments[segment_iter].substr(0, 31));
+				serverSayLink.append(segments[segment_iter].substr(0, 31));
-				serverTextLink.append("00000");
+				serverSayLink.append("00000");
-				serverTextLink.append(segments[segment_iter].substr(31, 5));
+				serverSayLink.append(segments[segment_iter].substr(31, 5));
-				serverTextLink.push_back('0');
+				serverSayLink.push_back('0');
-				serverTextLink.append(segments[segment_iter].substr(36));
+				serverSayLink.append(segments[segment_iter].substr(36));
-				serverTextLink.push_back('\x12');
+				serverSayLink.push_back('\x12');
 			}
 			else {
-				serverTextLink.append(segments[segment_iter]);
+				serverSayLink.append(segments[segment_iter]);
 			}
 		}
 	}

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 {
-		enum InventoryType : int {
+				typePossessions = INULL,
-			InvTypePossessions = InvTypeBegin,
+				typeBank,
-			InvTypeBank,
+				typeSharedBank,
-			InvTypeSharedBank,
+				typeTrade,
-			InvTypeTrade,
+				typeWorld,
-			InvTypeWorld,
+				typeLimbo,
-			InvTypeLimbo,
+				typeTribute,
-			InvTypeTribute,
+				typeGuildTribute,
-			InvTypeGuildTribute,
+				typeMerchant,
-			InvTypeMerchant,
+				typeCorpse,
-			InvTypeCorpse,
+				typeBazaar,
-			InvTypeBazaar,
+				typeInspect,
-			InvTypeInspect,
+				typeViewMODPC,
-			InvTypeViewMODPC,
+				typeViewMODBank,
-			InvTypeViewMODBank,
+				typeViewMODSharedBank,
-			InvTypeViewMODSharedBank,
+				typeViewMODLimbo,
-			InvTypeViewMODLimbo,
+				typeAltStorage,
-			InvTypeAltStorage,
+				typeArchived,
-			InvTypeArchived,
+				typeOther
-			InvTypeOther,
-			InvTypeCount
 			};
 
+		} // namespace enum_
+		using namespace enum_;
+
+		const int16 POSSESSIONS_SIZE = 32;
+		const int16 BANK_SIZE = 24;
+		const int16 SHARED_BANK_SIZE = 2;
+		const int16 TRADE_SIZE = 8;
+		const int16 WORLD_SIZE = 10;
+		const int16 LIMBO_SIZE = 36;
+		const int16 TRIBUTE_SIZE = 5;
+		const int16 GUILD_TRIBUTE_SIZE = 2;
+		const int16 MERCHANT_SIZE = 80;
+		const int16 CORPSE_SIZE = POSSESSIONS_SIZE;
+		const int16 BAZAAR_SIZE = 80;
+		const int16 INSPECT_SIZE = 23;
+		const int16 VIEW_MOD_PC_SIZE = POSSESSIONS_SIZE;
+		const int16 VIEW_MOD_BANK_SIZE = BANK_SIZE;
+		const int16 VIEW_MOD_SHARED_BANK_SIZE = SHARED_BANK_SIZE;
+		const int16 VIEW_MOD_LIMBO_SIZE = LIMBO_SIZE;
+		const int16 ALT_STORAGE_SIZE = 0;//unknown - "Shroud Bank"
+		const int16 ARCHIVED_SIZE = 0;//unknown
+		const int16 OTHER_SIZE = 0;//unknown
+
+		const int16 TRADE_NPC_SIZE = 4; // defined by implication
+
+		const int16 TYPE_INVALID = IINVALID;
+		const int16 TYPE_BEGIN = typePossessions;
+		const int16 TYPE_END = typeOther;
+		const int16 TYPE_COUNT = (TYPE_END - TYPE_BEGIN) + 1;
+
+		int16 GetInvTypeSize(int16 inv_type);
+		const char* GetInvTypeName(int16 inv_type);
+
+		bool IsInvTypePersistent(int16 inv_type);
+
 	} /*invtype*/
 
 	namespace invslot {
 		inline EQEmu::versions::ClientVersion GetInvSlotRef() { return EQEmu::versions::ClientVersion::SoF; }
 
-		enum : int { InvSlotInvalid = -1, InvSlotBegin };
+		namespace enum_ {
-
+			enum InventorySlots : int16 {
-		enum PossessionsSlot : int {
+				slotCharm = INULL,
-			PossessionsCharm = InvSlotBegin,
+				slotEar1,
-			PossessionsEar1,
+				slotHead,
-			PossessionsHead,
+				slotFace,
-			PossessionsFace,
+				slotEar2,
-			PossessionsEar2,
+				slotNeck,
-			PossessionsNeck,
+				slotShoulders,
-			PossessionsShoulders,
+				slotArms,
-			PossessionsArms,
+				slotBack,
-			PossessionsBack,
+				slotWrist1,
-			PossessionsWrist1,
+				slotWrist2,
-			PossessionsWrist2,
+				slotRange,
-			PossessionsRange,
+				slotHands,
-			PossessionsHands,
+				slotPrimary,
-			PossessionsPrimary,
+				slotSecondary,
-			PossessionsSecondary,
+				slotFinger1,
-			PossessionsFinger1,
+				slotFinger2,
-			PossessionsFinger2,
+				slotChest,
-			PossessionsChest,
+				slotLegs,
-			PossessionsLegs,
+				slotFeet,
-			PossessionsFeet,
+				slotWaist,
-			PossessionsWaist,
+				slotPowerSource,
-			PossessionsPowerSource,
+				slotAmmo,
-			PossessionsAmmo,
+				slotGeneral1,
-			PossessionsGeneral1,
+				slotGeneral2,
-			PossessionsGeneral2,
+				slotGeneral3,
-			PossessionsGeneral3,
+				slotGeneral4,
-			PossessionsGeneral4,
+				slotGeneral5,
-			PossessionsGeneral5,
+				slotGeneral6,
-			PossessionsGeneral6,
+				slotGeneral7,
-			PossessionsGeneral7,
+				slotGeneral8,
-			PossessionsGeneral8,
+				slotCursor
-			PossessionsCursor,
-			PossessionsCount
 			};
 
-		const int EquipmentBegin = PossessionsCharm;
+		} // namespace enum_
-		const int EquipmentEnd = PossessionsAmmo;
+		using namespace enum_;
-		const int EquipmentCount = (EquipmentEnd - EquipmentBegin + 1);
 
-		const int GeneralBegin = PossessionsGeneral1;
+		const int16 SLOT_INVALID = IINVALID;
-		const int GeneralEnd = PossessionsGeneral8;
+		const int16 SLOT_BEGIN = INULL;
-		const int GeneralCount = (GeneralEnd - GeneralBegin + 1);
+
+		const int16 POSSESSIONS_BEGIN = slotCharm;
+		const int16 POSSESSIONS_END = slotCursor;
+		const int16 POSSESSIONS_COUNT = (POSSESSIONS_END - POSSESSIONS_BEGIN) + 1;
+
+		const int16 EQUIPMENT_BEGIN = slotCharm;
+		const int16 EQUIPMENT_END = slotAmmo;
+		const int16 EQUIPMENT_COUNT = (EQUIPMENT_END - EQUIPMENT_BEGIN + 1);
+
+		const int16 GENERAL_BEGIN = slotGeneral1;
+		const int16 GENERAL_END = slotGeneral8;
+		const int16 GENERAL_COUNT = (GENERAL_END - GENERAL_BEGIN + 1);
+
+		const int16 BONUS_BEGIN = invslot::slotCharm;
+		const int16 BONUS_STAT_END = invslot::slotPowerSource;
+		const int16 BONUS_SKILL_END = invslot::slotAmmo;
+
+		const int16 BANK_BEGIN = 2000;
+		const int16 BANK_END = (BANK_BEGIN + invtype::BANK_SIZE) - 1;
+
+		const int16 SHARED_BANK_BEGIN = 2500;
+		const int16 SHARED_BANK_END = (SHARED_BANK_BEGIN + invtype::SHARED_BANK_SIZE) - 1;
+
+		const int16 TRADE_BEGIN = 3000;
+		const int16 TRADE_END = (TRADE_BEGIN + invtype::TRADE_SIZE) - 1;
+
+		const int16 TRADE_NPC_END = (TRADE_BEGIN + invtype::TRADE_NPC_SIZE) - 1; // defined by implication
+
+		const int16 WORLD_BEGIN = 4000;
+		const int16 WORLD_END = (WORLD_BEGIN + invtype::WORLD_SIZE) - 1;
+
+		const int16 TRIBUTE_BEGIN = 400;
+		const int16 TRIBUTE_END = (TRIBUTE_BEGIN + invtype::TRIBUTE_SIZE) - 1;
+
+		const int16 GUILD_TRIBUTE_BEGIN = 450;
+		const int16 GUILD_TRIBUTE_END = (GUILD_TRIBUTE_BEGIN + invtype::GUILD_TRIBUTE_SIZE) - 1;
+
+		const int16 CORPSE_BEGIN = invslot::slotGeneral1;
+		const int16 CORPSE_END = invslot::slotGeneral1 + invslot::slotCursor;
+
+		const uint64 POSSESSIONS_BITMASK = 0x000000027FFFFFFF; // based on 34-slot count (RoF+)
+		const uint64 CORPSE_BITMASK = 0x01FFFFFE7F800000; // based on 34-slot count (RoF+)
+
+		const char* GetInvPossessionsSlotName(int16 inv_slot);
+		const char* GetInvCorpseSlotName(int16 inv_slot);
+		const char* GetInvSlotName(int16 inv_type, int16 inv_slot);
 
 	} /*invslot*/
 
 	namespace invbag {
 		inline EQEmu::versions::ClientVersion GetInvBagRef() { return EQEmu::versions::ClientVersion::SoF; }
 
-		enum : int { InvBagInvalid = -1, InvBagBegin };
+		const int16 SLOT_INVALID = IINVALID;
+		const int16 SLOT_BEGIN = INULL;
+		const int16 SLOT_END = 9;
+		const int16 SLOT_COUNT = 10;
+
+		const int16 GENERAL_BAGS_BEGIN = 262;
+		const int16 GENERAL_BAGS_COUNT = invslot::GENERAL_COUNT * SLOT_COUNT;
+		const int16 GENERAL_BAGS_END = (GENERAL_BAGS_BEGIN + GENERAL_BAGS_COUNT) - 1;
+
+		const int16 CURSOR_BAG_BEGIN = 342;
+		const int16 CURSOR_BAG_COUNT = SLOT_COUNT;
+		const int16 CURSOR_BAG_END = (CURSOR_BAG_BEGIN + CURSOR_BAG_COUNT) - 1;
+
+		const int16 BANK_BAGS_BEGIN = 2032;
+		const int16 BANK_BAGS_COUNT = (invtype::BANK_SIZE * SLOT_COUNT);
+		const int16 BANK_BAGS_END = (BANK_BAGS_BEGIN + BANK_BAGS_COUNT) - 1;
+
+		const int16 SHARED_BANK_BAGS_BEGIN = 2532;
+		const int16 SHARED_BANK_BAGS_COUNT = invtype::SHARED_BANK_SIZE * SLOT_COUNT;
+		const int16 SHARED_BANK_BAGS_END = (SHARED_BANK_BAGS_BEGIN + SHARED_BANK_BAGS_COUNT) - 1;
+
+		const int16 TRADE_BAGS_BEGIN = 3031;
+		const int16 TRADE_BAGS_COUNT = invtype::TRADE_SIZE * SLOT_COUNT;
+		const int16 TRADE_BAGS_END = (TRADE_BAGS_BEGIN + TRADE_BAGS_COUNT) - 1;
+
+		const char* GetInvBagIndexName(int16 bag_index);
 
 	} /*invbag*/
 
 	namespace invaug {
 		inline EQEmu::versions::ClientVersion GetInvAugRef() { return EQEmu::versions::ClientVersion::SoF; }
 
-		enum : int { InvAugInvalid = -1, InvAugBegin };
+		const int16 SOCKET_INVALID = IINVALID;
+		const int16 SOCKET_BEGIN = INULL;
+		const int16 SOCKET_END = 4;
+		const int16 SOCKET_COUNT = 5;
+
+		const char* GetInvAugIndexName(int16 aug_index);
 
 	} /*invaug*/
 
@@ -153,147 +263,21 @@ namespace SoF
 	namespace profile {
 		inline EQEmu::versions::ClientVersion GetProfileRef() { return EQEmu::versions::ClientVersion::SoF; }
 
+		const int16 BANDOLIERS_SIZE = 20;		// number of bandolier instances
+		const int16 BANDOLIER_ITEM_COUNT = 4;	// number of equipment slots in bandolier instance
+
+		const int16 POTION_BELT_SIZE = 5;
+
+		const int16 SKILL_ARRAY_SIZE = 100;
+
 	} /*profile*/
 
 	namespace constants {
 		inline EQEmu::versions::ClientVersion GetConstantsRef() { return EQEmu::versions::ClientVersion::SoF; }
 
-	} /*constants*/
+		const size_t CHARACTER_CREATION_LIMIT = 12;
 
-	namespace behavior {
+		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)
@@ -95,6 +94,7 @@ D(OP_ApplyPoison)
 D(OP_AugmentInfo)
 D(OP_AugmentItem)
 D(OP_Buff)
+D(OP_Bug)
 D(OP_CastSpell)
 D(OP_ChannelMessage)
 D(OP_CharacterCreate)

common/patches/sof_structs.h

@@ -52,6 +52,25 @@ struct EnterWorld_Struct {
 struct WorldObjectsSent_Struct {
 };
 
+// yep, even SoF had a version of the new inventory system, used by OP_MoveMultipleItems
+struct InventorySlot_Struct
+{
+/*000*/	int32	Type;		// Worn and Normal inventory = 0, Bank = 1, Shared Bank = 2, Trade = 3, World = 4, Limbo = 5
+/*004*/	int32	Slot;
+/*008*/	int32	SubIndex;
+/*012*/	int32	AugIndex;
+/*016*/	int32	Unknown01;
+};
+
+// unsure if they have a version of this, completeness though
+struct TypelessInventorySlot_Struct
+{
+/*000*/	int32	Slot;
+/*004*/	int32	SubIndex;
+/*008*/	int32	AugIndex;
+/*012*/	int32	Unknown01;
+};
+
 /* Name Approval Struct */
 /* Len: */
 /* Opcode: 0x8B20*/
@@ -307,7 +326,8 @@ union
 /*0725*/ uint8  targetable;			// 1 = Targetable 0 = Not Targetable (is_npc?)
 /*0726*/ uint8  unknown0726[4];
 /*0730*/ uint8  NPC;				// 0=player,1=npc,2=pc corpse,3=npc corpse
-/*0731*/ uint8  unknown0731[11];
+/*0731*/ float  bounding_radius;	// used in melee, overrides calc
+/*0735*/ uint8  unknown0731[7];
 /*0742*/ uint8	targetable_with_hotkey;
 /*0743*/ signed   padding00:12;		// ***Placeholder
 		 signed   x:19;				// x coord
@@ -697,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
@@ -711,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;
@@ -799,6 +819,7 @@ static const uint32 MAX_PP_LANGUAGE		= 25; //
 static const uint32 MAX_PP_SPELLBOOK	= 480; // Confirmed 60 pages on Live now
 static const uint32 MAX_PP_MEMSPELL		= 10; //was 9 now 10 on Live
 static const uint32 MAX_PP_SKILL		= PACKET_SKILL_ARRAY_SIZE;	// 100 - actual skills buffer size
+static const uint32 MAX_PP_INNATE_SKILL	= 25;
 static const uint32 MAX_PP_AA_ARRAY		= 300; //was 299
 static const uint32 MAX_GROUP_MEMBERS	= 6;
 static const uint32 MAX_RECAST_TYPES	= 20;
@@ -903,7 +924,8 @@ struct PlayerProfile_Struct //23576 Octets
 /*06488*/ uint32  silver_cursor;		// Silver Pieces on cursor
 /*06492*/ uint32  copper_cursor;		// Copper Pieces on cursor
 /*06496*/ uint32  skills[MAX_PP_SKILL];	// [400] List of skills // 100 dword buffer
-/*06896*/ uint8 unknown04760[136];
+/*06896*/ uint32  InnateSkills[MAX_PP_INNATE_SKILL];
+/*06996*/ uint8  unknown04760[36];
 /*07032*/ uint32  toxicity;				// Potion Toxicity (15=too toxic, each potion adds 3)
 /*07036*/ uint32  thirst_level;			// Drink (ticks till next drink)
 /*07040*/ uint32  hunger_level;			// Food (ticks till next eat)
@@ -915,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;
@@ -1193,20 +1215,18 @@ struct Action_Struct
 {
  /* 00 */	uint16 target;	// id of target
  /* 02 */	uint16 source;	// id of caster
- /* 04 */	uint16 level; // level of caster
+ /* 04 */	uint16 level; // level of caster for spells, OSX dump says attack rating, guess spells use it for level
- /* 06 */	uint16 instrument_mod;	// seems to be fixed to 0x0A
+ /* 06 */	uint32 instrument_mod;	// OSX dump says base damage, spells use it for bard song (different from newer clients)
- /* 08 */	uint32 unknown08;
+ /* 10 */	float force;
- /* 12 */	uint16 unknown16;
+ /* 14 */	float hit_heading;
-// some kind of sequence that's the same in both actions
+ /* 18 */	float hit_pitch;
-// as well as the combat damage, to tie em together?
+ /* 22 */	uint8 type;		// 231 (0xE7) for spells, skill
- /* 14 */	float sequence;		// was uint32
+ /* 23 */	uint16 unknown23; // OSX says min_damage
- /* 18 */	uint32 unknown18;
+ /* 25 */	uint16 unknown25; // OSX says tohit
- /* 22 */	uint8 type;		// 231 (0xE7) for spells
- /* 23 */	uint32 unknown23;
  /* 27 */	uint16 spell;	// spell id being cast
- /* 29 */	uint8 level2;	// level of caster again? Or maybe the castee
+ /* 29 */	uint8 spell_level;	// level of caster again? Or maybe the castee
 // this field seems to be some sort of success flag, if it's 4
- /* 30 */	uint8 buff_unknown;	// if this is 4, a buff icon is made
+ /* 30 */	uint8 effect_flag;	// if this is 4, a buff icon is made
  /* 31 */
 };
 
@@ -1215,26 +1235,23 @@ struct Action_Struct
 // has to do with buff blocking??
 struct ActionAlt_Struct // ActionAlt_Struct - Size: 56 bytes
 {
-/*0000*/ uint16 target;                 // Target ID
+/*0000*/ uint16 target;	// id of target
-/*0002*/ uint16 source;                 // SourceID
+/*0002*/ uint16 source;	// id of caster
-/*0004*/ uint16 level;					// level of caster
+/*0004*/ uint16 level; // level of caster for spells, OSX dump says attack rating, guess spells use it for level
-/*0006*/ uint16 instrument_mod;				// seems to be fixed to 0x0A
+/*0006*/ uint32 instrument_mod;	// OSX dump says base damage, spells use it for bard song (different from newer clients)
-/*0008*/ uint32 unknown08;
+/*0010*/ float force;
-/*0012*/ uint16 unknown16;
+/*0014*/ float hit_heading;
-/*0014*/ uint32 sequence;
+/*0018*/ float hit_pitch;
-/*0018*/ uint32 unknown18;
+/*0022*/ uint8 type;		// 231 (0xE7) for spells, skill
-/*0022*/ uint8  type;                   // Casts, Falls, Bashes, etc...
+/*0023*/ uint16 unknown23; // OSX says min_damage
-/*0023*/ uint32  damage;                 // Amount of Damage
+/*0025*/ uint16 unknown25; // OSX says tohit
-/*0027*/ uint16  spell;                  // SpellID
+/*0027*/ uint16 spell;	// spell id being cast
-/*0029*/ uint8 unknown29;
+/*0029*/ uint8 spell_level;	// level of caster again? Or maybe the castee
-/*0030*/ uint8 buff_unknown;				// if this is 4, a buff icon is made
+// this field seems to be some sort of success flag, if it's 4
-/*0031*/ uint32 unknown0031;			// seen 00 00 00 00
+/*0030*/ uint8 effect_flag;	// if this is 4, a buff icon is made
-/*0035*/ uint8 unknown0035;				// seen 00
+/*0031*/ uint8 spell_slot;
-/*0036*/ uint32 unknown0036;			// seen ff ff ff ff
+/*0032*/ uint32 slot[5];
-/*0040*/ uint32 unknown0040;			// seen ff ff ff ff
+/*0052*/ uint32 item_cast_type;	// ItemSpellTypes enum from MQ2
-/*0044*/ uint32 unknown0044;			// seen ff ff ff ff
-/*0048*/ uint32 unknown0048;			// seen 00 00 00 00
-/*0052*/ uint32 unknown0052;			// seen 00 00 00 00
 /*0056*/
 };
 
@@ -1249,9 +1266,10 @@ struct CombatDamage_Struct
 /* 05 */	uint16	spellid;
 /* 07 */	int32	damage;
 /* 11 */	float	force;		// cd cc cc 3d
-/* 15 */	float	meleepush_xy;		// see above notes in Action_Struct
+/* 15 */	float	hit_heading;		// see above notes in Action_Struct
-/* 19 */	float	meleepush_z;
+/* 19 */	float	hit_pitch;
-/* 23 */	uint8	unknown23[5];	// was [9] this appears unrelated to the stuff the other clients do here?
+/* 23 */	uint8	secondary;	// 0 for primary hand, 1 for secondary
+/* 24 */	uint32	special; // 2 = Rampage, 1 = Wild Rampage, Report function doesn't seem to check this :P
 /* 28 */
 };
 
@@ -1555,6 +1573,19 @@ struct MoveItem_Struct
 /*0012*/
 };
 
+struct MultiMoveItemSub_Struct
+{
+/*0000*/ InventorySlot_Struct	from_slot;
+/*0020*/ uint32 number_in_stack; // so the amount we are moving from the source
+/*0024*/ InventorySlot_Struct	to_slot;
+};
+
+struct MultiMoveItem_Struct
+{
+/*0000*/ uint32	count;
+/*0004*/ MultiMoveItemSub_Struct moves[0];
+};
+
 //
 // from_slot/to_slot
 // -1 - destroy
@@ -2872,23 +2903,31 @@ struct GuildMakeLeader{
 	char	target[64];
 };
 
+struct BugReport_Struct {
+/*0000*/	char	category_name[64];
+/*0064*/	char	character_name[64];
+/*0128*/	char	unused_0128[32];
+/*0160*/	char	ui_path[128];
+/*0288*/	float	pos_x;
+/*0292*/	float	pos_y;
+/*0296*/	float	pos_z;
+/*0300*/	uint32	heading;
+/*0304*/	uint32	unused_0304;
+/*0308*/	uint32	time_played;
+/*0312*/	char	padding_0312[8];
+/*0320*/	uint32	target_id;
+/*0324*/	char	padding_0324[140];
+/*0464*/	uint32	unknown_0464;	// seems to always be '0'
+/*0468*/	char	target_name[64];
+/*0532*/	uint32	optional_info_mask;
 
-
+// this looks like a butchered 8k buffer with 2 trailing dword fields
-struct BugStruct{
+/*0536*/	char	unused_0536[2052];
-/*0000*/	char	chartype[64];
+/*2588*/	char	bug_report[2050];
-/*0064*/	char	name[96];
+/*4638*/	char	system_info[4098];
-/*0160*/	char	ui[128];
+/*8736*/
-/*0288*/	float	x;
-/*0292*/	float	y;
-/*0296*/	float	z;
-/*0300*/	float	heading;
-/*0304*/	uint32	unknown304;
-/*0308*/	uint32	type;
-/*0312*/	char	unknown312[2144];
-/*2456*/	char	bug[1024];
-/*3480*/	char	placeholder[2];
-/*3482*/	char	system_info[4098];
 };
+
 struct Make_Pet_Struct { //Simple struct for getting pet info
 	uint8 level;
 	uint8 class_;
@@ -2915,20 +2954,21 @@ struct Ground_Spawn{
 struct Ground_Spawns {
 	struct Ground_Spawn spawn[50]; //Assigned max number to allow
 };
-struct PetitionBug_Struct{
+
-	uint32	petition_number;
+//struct PetitionBug_Struct{
-	uint32	unknown4;
+//	uint32	petition_number;
-	char	accountname[64];
+//	uint32	unknown4;
-	uint32	zoneid;
+//	char	accountname[64];
-	char	name[64];
+//	uint32	zoneid;
-	uint32	level;
+//	char	name[64];
-	uint32	class_;
+//	uint32	level;
-	uint32	race;
+//	uint32	class_;
-	uint32	unknown152[3];
+//	uint32	race;
-	uint32	time;
+//	uint32	unknown152[3];
-	uint32	unknown168;
+//	uint32	time;
-	char	text[1028];
+//	uint32	unknown168;
-};
+//	char	text[1028];
+//};
 
 struct ApproveZone_Struct {
 	char	name[64];
@@ -4112,6 +4152,22 @@ struct AltCurrencySellItem_Struct {
 /*004*/ uint32 slot_id;
 /*006*/ uint32 charges;
 /*010*/ uint32 cost;
+};
+
+struct SayLinkBodyFrame_Struct {
+/*000*/	char ActionID[1];
+/*001*/	char ItemID[5];
+/*006*/	char Augment1[5];
+/*011*/	char Augment2[5];
+/*016*/	char Augment3[5];
+/*021*/	char Augment4[5];
+/*026*/	char Augment5[5];
+/*031*/	char IsEvolving[1];
+/*032*/	char EvolveGroup[4];
+/*036*/	char EvolveLevel[1];
+/*037*/	char OrnamentIcon[5];
+/*042*/	char Hash[8];
+/*050*/
 };
 
 	}; /*structs*/

common/patches/titanium.cpp

@@ -52,11 +52,11 @@ namespace Titanium
 	static inline uint32 TitaniumToServerSlot(int16 titaniumSlot);
 	static inline uint32 TitaniumToServerCorpseSlot(int16 titaniumCorpseSlot);
 
-	// server to client text link converter
+	// server to client say link converter
-	static inline void ServerToTitaniumTextLink(std::string& titaniumTextLink, const std::string& serverTextLink);
+	static inline void ServerToTitaniumSayLink(std::string& titaniumSayLink, const std::string& serverSayLink);
 
-	// client to server text link converter
+	// client to server say link converter
-	static inline void TitaniumToServerTextLink(std::string& serverTextLink, const std::string& titaniumTextLink);
+	static inline void TitaniumToServerSayLink(std::string& serverSayLink, const std::string& titaniumSayLink);
 
 	static inline CastingSlot ServerToTitaniumCastingSlot(EQEmu::CastingSlot slot);
 	static inline EQEmu::CastingSlot TitaniumToServerCastingSlot(CastingSlot slot, uint32 itemlocation);
@@ -164,11 +164,14 @@ namespace Titanium
 		OUT(source);
 		OUT(level);
 		OUT(instrument_mod);
-		OUT(sequence);
+		OUT(force);
+		OUT(hit_heading);
+		OUT(hit_pitch);
 		OUT(type);
 		//OUT(damage);
 		OUT(spell);
-		OUT(buff_unknown); // if this is 4, a buff icon is made
+		OUT(spell_level);
+		OUT(effect_flag); // if this is 4, a buff icon is made
 
 		FINISH_ENCODE();
 	}
@@ -290,7 +293,7 @@ namespace Titanium
 
 		std::string old_message = emu->message;
 		std::string new_message;
-		ServerToTitaniumTextLink(new_message, old_message);
+		ServerToTitaniumSayLink(new_message, old_message);
 
 		in->size = sizeof(ChannelMessage_Struct) + new_message.length() + 1;
 
@@ -358,8 +361,8 @@ namespace Titanium
 		OUT(spellid);
 		OUT(damage);
 		OUT(force);
-		OUT(meleepush_xy);
+		OUT(hit_heading);
-		OUT(meleepush_z);
+		OUT(hit_pitch);
 
 		FINISH_ENCODE();
 	}
@@ -532,7 +535,7 @@ namespace Titanium
 
 		std::string old_message = emu->message;
 		std::string new_message;
-		ServerToTitaniumTextLink(new_message, old_message);
+		ServerToTitaniumSayLink(new_message, old_message);
 
 		//if (new_message.length() > 512) // length restricted in packet building function due vari-length name size (no nullterm)
 		//	new_message = new_message.substr(0, 512);
@@ -574,7 +577,7 @@ namespace Titanium
 
 		for (int i = 0; i < 9; ++i) {
 			if (old_message_array[i].length() == 0) { break; }
-			ServerToTitaniumTextLink(new_message_array[i], old_message_array[i]);
+			ServerToTitaniumSayLink(new_message_array[i], old_message_array[i]);
 			new_message_size += new_message_array[i].length() + 1;
 		}
 
@@ -1020,6 +1023,7 @@ namespace Titanium
 		OUT(copper_cursor);
 
 		OUT_array(skills, structs::MAX_PP_SKILL);	// 1:1 direct copy (100 dword)
+		OUT_array(InnateSkills, structs::MAX_PP_INNATE_SKILL);	// 1:1 direct copy (25 dword)
 
 		//	OUT(unknown04760[236]);
 		OUT(toxicity);
@@ -1047,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';
@@ -1068,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';
@@ -1401,7 +1405,7 @@ namespace Titanium
 		std::string old_message = &emu->message[strlen(emu->sayer)];
 		std::string new_message;
 
-		ServerToTitaniumTextLink(new_message, old_message);
+		ServerToTitaniumSayLink(new_message, old_message);
 
 		//in->size = 3 + 4 + 4 + strlen(emu->sayer) + 1 + 12 + new_message.length() + 1;
 		in->size = strlen(emu->sayer) + new_message.length() + 25;
@@ -1455,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;
-		ServerToTitaniumTextLink(new_message, old_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];
 
@@ -1475,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);
@@ -1788,6 +1796,17 @@ namespace Titanium
 		FINISH_DIRECT_DECODE();
 	}
 
+	DECODE(OP_Bug)
+	{
+		DECODE_LENGTH_EXACT(structs::BugReport_Struct);
+		SETUP_DIRECT_DECODE(BugReport_Struct, structs::BugReport_Struct);
+
+		emu->category_id = EQEmu::bug::CategoryNameToCategoryID(eq->category_name);
+		memcpy(emu->category_name, eq, sizeof(structs::BugReport_Struct));
+
+		FINISH_DIRECT_DECODE();
+	}
+
 	DECODE(OP_CastSpell)
 	{
 		DECODE_LENGTH_EXACT(structs::CastSpell_Struct);
@@ -1807,7 +1826,7 @@ namespace Titanium
 
 		std::string old_message = (char *)&__eq_buffer[sizeof(ChannelMessage_Struct)];
 		std::string new_message;
-		TitaniumToServerTextLink(new_message, old_message);
+		TitaniumToServerSayLink(new_message, old_message);
 
 		__packet->size = sizeof(ChannelMessage_Struct) + new_message.length() + 1;
 		__packet->pBuffer = new unsigned char[__packet->size];
@@ -1879,7 +1898,7 @@ namespace Titanium
 
 		std::string old_message = (char *)&__eq_buffer[4]; // unknown01 offset
 		std::string new_message;
-		TitaniumToServerTextLink(new_message, old_message);
+		TitaniumToServerSayLink(new_message, old_message);
 
 		__packet->size = sizeof(Emote_Struct);
 		__packet->pBuffer = new unsigned char[__packet->size];
@@ -2427,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);
@@ -2473,19 +2492,19 @@ namespace Titanium
 		return titaniumCorpseSlot;
 	}
 
-	static inline void ServerToTitaniumTextLink(std::string& titaniumTextLink, const std::string& serverTextLink)
+	static inline void ServerToTitaniumSayLink(std::string& titaniumSayLink, const std::string& serverSayLink)
 	{
-		if ((constants::SayLinkBodySize == EQEmu::legacy::TEXT_LINK_BODY_LENGTH) || (serverTextLink.find('\x12') == std::string::npos)) {
+		if ((constants::SAY_LINK_BODY_SIZE == EQEmu::constants::SAY_LINK_BODY_SIZE) || (serverSayLink.find('\x12') == std::string::npos)) {
-			titaniumTextLink = serverTextLink;
+			titaniumSayLink = serverSayLink;
 			return;
 		}
 
-		auto segments = SplitString(serverTextLink, '\x12');
+		auto segments = SplitString(serverSayLink, '\x12');
 
 		for (size_t segment_iter = 0; segment_iter < segments.size(); ++segment_iter) {
 			if (segment_iter & 1) {
-				if (segments[segment_iter].length() <= EQEmu::legacy::TEXT_LINK_BODY_LENGTH) {
+				if (segments[segment_iter].length() <= EQEmu::constants::SAY_LINK_BODY_SIZE) {
-					titaniumTextLink.append(segments[segment_iter]);
+					titaniumSayLink.append(segments[segment_iter]);
 					// TODO: log size mismatch error
 					continue;
 				}
@@ -2495,37 +2514,37 @@ namespace Titanium
 				// 6.2:  X XXXXX XXXXX XXXXX XXXXX XXXXX XXXXX       X  XXXX  X       XXXXXXXX (45)
 				// Diff:                                       ^^^^^         ^  ^^^^^
 
-				titaniumTextLink.push_back('\x12');
+				titaniumSayLink.push_back('\x12');
-				titaniumTextLink.append(segments[segment_iter].substr(0, 31));
+				titaniumSayLink.append(segments[segment_iter].substr(0, 31));
-				titaniumTextLink.append(segments[segment_iter].substr(36, 5));
+				titaniumSayLink.append(segments[segment_iter].substr(36, 5));
 
 				if (segments[segment_iter][41] == '0')
-					titaniumTextLink.push_back(segments[segment_iter][42]);
+					titaniumSayLink.push_back(segments[segment_iter][42]);
 				else
-					titaniumTextLink.push_back('F');
+					titaniumSayLink.push_back('F');
 
-				titaniumTextLink.append(segments[segment_iter].substr(48));
+				titaniumSayLink.append(segments[segment_iter].substr(48));
-				titaniumTextLink.push_back('\x12');
+				titaniumSayLink.push_back('\x12');
 			}
 			else {
-				titaniumTextLink.append(segments[segment_iter]);
+				titaniumSayLink.append(segments[segment_iter]);
 			}
 		}
 	}
 
-	static inline void TitaniumToServerTextLink(std::string& serverTextLink, const std::string& titaniumTextLink)
+	static inline void TitaniumToServerSayLink(std::string& serverSayLink, const std::string& titaniumSayLink)
 	{
-		if ((EQEmu::legacy::TEXT_LINK_BODY_LENGTH == constants::SayLinkBodySize) || (titaniumTextLink.find('\x12') == std::string::npos)) {
+		if ((EQEmu::constants::SAY_LINK_BODY_SIZE == constants::SAY_LINK_BODY_SIZE) || (titaniumSayLink.find('\x12') == std::string::npos)) {
-			serverTextLink = titaniumTextLink;
+			serverSayLink = titaniumSayLink;
 			return;
 		}
 
-		auto segments = SplitString(titaniumTextLink, '\x12');
+		auto segments = SplitString(titaniumSayLink, '\x12');
 
 		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) {
-					serverTextLink.append(segments[segment_iter]);
+					serverSayLink.append(segments[segment_iter]);
 					// TODO: log size mismatch error
 					continue;
 				}
@@ -2535,18 +2554,18 @@ namespace Titanium
 				// RoF2: X XXXXX XXXXX XXXXX XXXXX XXXXX XXXXX XXXXX X  XXXX XX  XXXXX XXXXXXXX (56)
 				// Diff:                                       ^^^^^         ^   ^^^^^
 
-				serverTextLink.push_back('\x12');
+				serverSayLink.push_back('\x12');
-				serverTextLink.append(segments[segment_iter].substr(0, 31));
+				serverSayLink.append(segments[segment_iter].substr(0, 31));
-				serverTextLink.append("00000");
+				serverSayLink.append("00000");
-				serverTextLink.append(segments[segment_iter].substr(31, 5));
+				serverSayLink.append(segments[segment_iter].substr(31, 5));
-				serverTextLink.push_back('0');
+				serverSayLink.push_back('0');
-				serverTextLink.push_back(segments[segment_iter][36]);
+				serverSayLink.push_back(segments[segment_iter][36]);
-				serverTextLink.append("00000");
+				serverSayLink.append("00000");
-				serverTextLink.append(segments[segment_iter].substr(37));
+				serverSayLink.append(segments[segment_iter].substr(37));
-				serverTextLink.push_back('\x12');
+				serverSayLink.push_back('\x12');
 			}
 			else {
-				serverTextLink.append(segments[segment_iter]);
+				serverSayLink.append(segments[segment_iter]);
 			}
 		}
 	}

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 {
-		enum InventoryType : int {
+				typePossessions = INULL,
-			InvTypePossessions = InvTypeBegin,
+				typeBank,
-			InvTypeBank,
+				typeSharedBank,
-			InvTypeSharedBank,
+				typeTrade,
-			InvTypeTrade,
+				typeWorld,
-			InvTypeWorld,
+				typeLimbo,
-			InvTypeLimbo,
+				typeTribute,
-			InvTypeTribute,
+				typeGuildTribute,
-			InvTypeGuildTribute,
+				typeMerchant,
-			InvTypeMerchant,
+				typeCorpse,
-			InvTypeCorpse,
+				typeBazaar,
-			InvTypeBazaar,
+				typeInspect,
-			InvTypeInspect,
+				typeViewMODPC,
-			InvTypeViewMODPC,
+				typeViewMODBank,
-			InvTypeViewMODBank,
+				typeViewMODSharedBank,
-			InvTypeViewMODSharedBank,
+				typeViewMODLimbo,
-			InvTypeViewMODLimbo,
+				typeAltStorage,
-			InvTypeAltStorage,
+				typeArchived,
-			InvTypeArchived,
+				typeOther
-			InvTypeOther,
-			InvTypeCount
 			};
 
+		} // namespace enum_
+		using namespace enum_;
+
+		const int16 POSSESSIONS_SIZE = 31;
+		const int16 BANK_SIZE = 16;
+		const int16 SHARED_BANK_SIZE = 2;
+		const int16 TRADE_SIZE = 8;
+		const int16 WORLD_SIZE = 10;
+		const int16 LIMBO_SIZE = 36;
+		const int16 TRIBUTE_SIZE = 5;
+		const int16 GUILD_TRIBUTE_SIZE = 2;
+		const int16 MERCHANT_SIZE = 80;
+		const int16 CORPSE_SIZE = POSSESSIONS_SIZE;
+		const int16 BAZAAR_SIZE = 80;
+		const int16 INSPECT_SIZE = 22;
+		const int16 VIEW_MOD_PC_SIZE = POSSESSIONS_SIZE;
+		const int16 VIEW_MOD_BANK_SIZE = BANK_SIZE;
+		const int16 VIEW_MOD_SHARED_BANK_SIZE = SHARED_BANK_SIZE;
+		const int16 VIEW_MOD_LIMBO_SIZE = LIMBO_SIZE;
+		const int16 ALT_STORAGE_SIZE = 0;//unknown - "Shroud Bank"
+		const int16 ARCHIVED_SIZE = 0;//unknown
+		const int16 OTHER_SIZE = 0;//unknown
+
+		const int16 TRADE_NPC_SIZE = 4; // defined by implication
+
+		const int16 TYPE_INVALID = IINVALID;
+		const int16 TYPE_BEGIN = typePossessions;
+		const int16 TYPE_END = typeOther;
+		const int16 TYPE_COUNT = (TYPE_END - TYPE_BEGIN) + 1;
+
+		int16 GetInvTypeSize(int16 inv_type);
+		const char* GetInvTypeName(int16 inv_type);
+
+		bool IsInvTypePersistent(int16 inv_type);
+
 	} /*invtype*/
 
 	namespace invslot {
 		inline EQEmu::versions::ClientVersion GetInvSlotRef() { return EQEmu::versions::ClientVersion::Titanium; }
 
-		enum : int { InvSlotInvalid = -1, InvSlotBegin };
+		namespace enum_ {
-
+			enum InventorySlots : int16 {
-		enum PossessionsSlot : int {
+				slotCharm = INULL,
-			PossessionsCharm = InvSlotBegin,
+				slotEar1,
-			PossessionsEar1,
+				slotHead,
-			PossessionsHead,
+				slotFace,
-			PossessionsFace,
+				slotEar2,
-			PossessionsEar2,
+				slotNeck,
-			PossessionsNeck,
+				slotShoulders,
-			PossessionsShoulders,
+				slotArms,
-			PossessionsArms,
+				slotBack,
-			PossessionsBack,
+				slotWrist1,
-			PossessionsWrist1,
+				slotWrist2,
-			PossessionsWrist2,
+				slotRange,
-			PossessionsRange,
+				slotHands,
-			PossessionsHands,
+				slotPrimary,
-			PossessionsPrimary,
+				slotSecondary,
-			PossessionsSecondary,
+				slotFinger1,
-			PossessionsFinger1,
+				slotFinger2,
-			PossessionsFinger2,
+				slotChest,
-			PossessionsChest,
+				slotLegs,
-			PossessionsLegs,
+				slotFeet,
-			PossessionsFeet,
+				slotWaist,
-			PossessionsWaist,
+				slotAmmo,
-			PossessionsAmmo,
+				slotGeneral1,
-			PossessionsGeneral1,
+				slotGeneral2,
-			PossessionsGeneral2,
+				slotGeneral3,
-			PossessionsGeneral3,
+				slotGeneral4,
-			PossessionsGeneral4,
+				slotGeneral5,
-			PossessionsGeneral5,
+				slotGeneral6,
-			PossessionsGeneral6,
+				slotGeneral7,
-			PossessionsGeneral7,
+				slotGeneral8,
-			PossessionsGeneral8,
+				slotCursor
-			PossessionsCursor,
-			PossessionsCount
 			};
 
-		const int EquipmentBegin = PossessionsCharm;
+		} // namespace enum_
-		const int EquipmentEnd = PossessionsAmmo;
+		using namespace enum_;
-		const int EquipmentCount = (EquipmentEnd - EquipmentBegin + 1);
 
-		const int GeneralBegin = PossessionsGeneral1;
+		const int16 SLOT_INVALID = IINVALID;
-		const int GeneralEnd = PossessionsGeneral8;
+		const int16 SLOT_BEGIN = INULL;
-		const int GeneralCount = (GeneralEnd - GeneralBegin + 1);
+
+		const int16 POSSESSIONS_BEGIN = slotCharm;
+		const int16 POSSESSIONS_END = slotCursor;
+		const int16 POSSESSIONS_COUNT = (POSSESSIONS_END - POSSESSIONS_BEGIN) + 1;
+
+		const int16 EQUIPMENT_BEGIN = slotCharm;
+		const int16 EQUIPMENT_END = slotAmmo;
+		const int16 EQUIPMENT_COUNT = (EQUIPMENT_END - EQUIPMENT_BEGIN + 1);
+
+		const int16 GENERAL_BEGIN = slotGeneral1;
+		const int16 GENERAL_END = slotGeneral8;
+		const int16 GENERAL_COUNT = (GENERAL_END - GENERAL_BEGIN + 1);
+
+		const int16 BONUS_BEGIN = invslot::slotCharm;
+		const int16 BONUS_STAT_END = invslot::slotWaist;
+		const int16 BONUS_SKILL_END = invslot::slotAmmo;
+
+		const int16 BANK_BEGIN = 2000;
+		const int16 BANK_END = (BANK_BEGIN + invtype::BANK_SIZE) - 1;
+
+		const int16 SHARED_BANK_BEGIN = 2500;
+		const int16 SHARED_BANK_END = (SHARED_BANK_BEGIN + invtype::SHARED_BANK_SIZE) - 1;
+
+		const int16 TRADE_BEGIN = 3000;
+		const int16 TRADE_END = (TRADE_BEGIN + invtype::TRADE_SIZE) - 1;
+
+		const int16 TRADE_NPC_END = (TRADE_BEGIN + invtype::TRADE_NPC_SIZE) - 1; // defined by implication
+
+		const int16 WORLD_BEGIN = 4000;
+		const int16 WORLD_END = (WORLD_BEGIN + invtype::WORLD_SIZE) - 1;
+
+		const int16 TRIBUTE_BEGIN = 400;
+		const int16 TRIBUTE_END = (TRIBUTE_BEGIN + invtype::TRIBUTE_SIZE) - 1;
+
+		const int16 GUILD_TRIBUTE_BEGIN = 450;
+		const int16 GUILD_TRIBUTE_END = (GUILD_TRIBUTE_BEGIN + invtype::GUILD_TRIBUTE_SIZE) - 1;
+
+		const int16 CORPSE_BEGIN = invslot::slotGeneral1;
+		const int16 CORPSE_END = invslot::slotGeneral1 + invslot::slotCursor;
+
+		const uint64 POSSESSIONS_BITMASK = 0x000000027FDFFFFF; // based on 34-slot count (RoF+)
+		const uint64 CORPSE_BITMASK = 0x017FFFFE7F800000; // based on 34-slot count (RoF+)
+
+		const char* GetInvPossessionsSlotName(int16 inv_slot);
+		const char* GetInvCorpseSlotName(int16 inv_slot);
+		const char* GetInvSlotName(int16 inv_type, int16 inv_slot);
 
 	} /*invslot*/
 
 	namespace invbag {
 		inline EQEmu::versions::ClientVersion GetInvBagRef() { return EQEmu::versions::ClientVersion::Titanium; }
 
-		enum : int { InvBagInvalid = -1, InvBagBegin };
+		const int16 SLOT_INVALID = IINVALID;
+		const int16 SLOT_BEGIN = INULL;
+		const int16 SLOT_END = 9;
+		const int16 SLOT_COUNT = 10;
+
+		const int16 GENERAL_BAGS_BEGIN = 251;
+		const int16 GENERAL_BAGS_COUNT = invslot::GENERAL_COUNT * SLOT_COUNT;
+		const int16 GENERAL_BAGS_END = (GENERAL_BAGS_BEGIN + GENERAL_BAGS_COUNT) - 1;
+
+		const int16 CURSOR_BAG_BEGIN = 331;
+		const int16 CURSOR_BAG_COUNT = SLOT_COUNT;
+		const int16 CURSOR_BAG_END = (CURSOR_BAG_BEGIN + CURSOR_BAG_COUNT) - 1;
+
+		const int16 BANK_BAGS_BEGIN = 2031;
+		const int16 BANK_BAGS_COUNT = (invtype::BANK_SIZE * SLOT_COUNT);
+		const int16 BANK_BAGS_END = (BANK_BAGS_BEGIN + BANK_BAGS_COUNT) - 1;
+
+		const int16 SHARED_BANK_BAGS_BEGIN = 2531;
+		const int16 SHARED_BANK_BAGS_COUNT = invtype::SHARED_BANK_SIZE * SLOT_COUNT;
+		const int16 SHARED_BANK_BAGS_END = (SHARED_BANK_BAGS_BEGIN + SHARED_BANK_BAGS_COUNT) - 1;
+
+		const int16 TRADE_BAGS_BEGIN = 3031;
+		const int16 TRADE_BAGS_COUNT = invtype::TRADE_SIZE * SLOT_COUNT;
+		const int16 TRADE_BAGS_END = (TRADE_BAGS_BEGIN + TRADE_BAGS_COUNT) - 1;
+
+		const char* GetInvBagIndexName(int16 bag_index);
 
 	} /*invbag*/
 
 	namespace invaug {
 		inline EQEmu::versions::ClientVersion GetInvAugRef() { return EQEmu::versions::ClientVersion::Titanium; }
 
-		enum : int { InvAugInvalid = -1, InvAugBegin };
+		const int16 SOCKET_INVALID = IINVALID;
+		const int16 SOCKET_BEGIN = INULL;
+		const int16 SOCKET_END = 4;
+		const int16 SOCKET_COUNT = 5;
+
+		const char* GetInvAugIndexName(int16 aug_index);
 
 	} /*invaug*/
 
@@ -152,147 +262,21 @@ namespace Titanium
 	namespace profile {
 		inline EQEmu::versions::ClientVersion GetProfileRef() { return EQEmu::versions::ClientVersion::Titanium; }
 
+		const int16 BANDOLIERS_SIZE = 4;		// number of bandolier instances
+		const int16 BANDOLIER_ITEM_COUNT = 4;	// number of equipment slots in bandolier instance
+
+		const int16 POTION_BELT_SIZE = 4;
+
+		const int16 SKILL_ARRAY_SIZE = 100;
+
 	} /*profile*/
 
 	namespace constants {
 		inline EQEmu::versions::ClientVersion GetConstantsRef() { return EQEmu::versions::ClientVersion::Titanium; }
 
-	} /*constants*/
+		const size_t CHARACTER_CREATION_LIMIT = 8; // Hard-coded in client - DO NOT ALTER
 
-	namespace behavior {
+		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_ops.h

@@ -78,6 +78,7 @@ D(OP_AdventureMerchantSell)
 D(OP_ApplyPoison)
 D(OP_AugmentItem)
 D(OP_Buff)
+D(OP_Bug)
 D(OP_CastSpell)
 D(OP_ChannelMessage)
 D(OP_CharacterCreate)

common/patches/titanium_structs.h

@@ -48,6 +48,23 @@ struct EnterWorld_Struct {
 /*068*/	uint32	return_home;		// 01 on "Return Home", 00 if not
 };
 
+// yep, even tit had a version of the new inventory system, used by OP_MoveMultipleItems
+struct InventorySlot_Struct
+{
+/*000*/	int32	Type;		// Worn and Normal inventory = 0, Bank = 1, Shared Bank = 2, Trade = 3, World = 4, Limbo = 5
+/*004*/	int32	Slot;
+/*008*/	int32	SubIndex;	// no aug index in Tit
+/*012*/	int32	Unknown01;
+};
+
+// unsure if they have a version of this, completeness though
+struct TypelessInventorySlot_Struct
+{
+/*000*/	int32	Slot;
+/*004*/	int32	SubIndex;	// no aug index in Tit
+/*008*/	int32	Unknown01;
+};
+
 /* Name Approval Struct */
 /* Len: */
 /* Opcode: 0x8B20*/
@@ -310,7 +327,7 @@ union
                                   // horse: 0=brown, 1=white, 2=black, 3=tan
 };
 /*0340*/ uint32 spawnId;        // Spawn Id
-/*0344*/ uint8 unknown0344[4];
+/*0344*/ float bounding_radius; // used in melee, overrides calc
 /*0348*/ TintProfile equipment_tint;
 /*0384*/ uint8  lfg;            // 0=off, 1=lfg on
 /*0385*/
@@ -638,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
@@ -652,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;
@@ -740,6 +757,7 @@ static const uint32 MAX_PP_LANGUAGE		= 28;
 static const uint32 MAX_PP_SPELLBOOK	= 400;
 static const uint32 MAX_PP_MEMSPELL		= 9;
 static const uint32 MAX_PP_SKILL		= PACKET_SKILL_ARRAY_SIZE;	// 100 - actual skills buffer size
+static const uint32 MAX_PP_INNATE_SKILL	= 25;
 static const uint32 MAX_PP_AA_ARRAY		= 240;
 static const uint32 MAX_GROUP_MEMBERS	= 6;
 static const uint32 MAX_RECAST_TYPES	= 20;
@@ -844,7 +862,8 @@ struct PlayerProfile_Struct
 /*04452*/ uint32  silver_cursor;      // Silver Pieces on cursor
 /*04456*/ uint32  copper_cursor;      // Copper Pieces on cursor
 /*04460*/ uint32  skills[MAX_PP_SKILL]; // [400] List of skills	// 100 dword buffer
-/*04860*/ uint8 unknown04760[136];
+/*04860*/ uint32  InnateSkills[MAX_PP_INNATE_SKILL];
+/*04960*/ uint8   unknown04760[36];
 /*04996*/ uint32  toxicity;           // Potion Toxicity (15=too toxic, each potion adds 3)
 /*05000*/ uint32  thirst_level;             // Drink (ticks till next drink)
 /*05004*/ uint32  hunger_level;             // Food (ticks till next eat)
@@ -856,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];
@@ -1100,20 +1119,18 @@ struct Action_Struct
 {
  /* 00 */	uint16 target;	// id of target
  /* 02 */	uint16 source;	// id of caster
- /* 04 */	uint16 level; // level of caster
+ /* 04 */	uint16 level; // level of caster for spells, OSX dump says attack rating, guess spells use it for level
- /* 06 */	uint16 instrument_mod;
+ /* 06 */	uint32 instrument_mod; // OSX dump says base damage, spells use it for bard song (different from newer clients)
- /* 08 */	uint32 unknown08;
+ /* 10 */	float force;
- /* 12 */	uint16 unknown16;
+ /* 14 */	float hit_heading;
-// some kind of sequence that's the same in both actions
+ /* 18 */	float hit_pitch;
-// as well as the combat damage, to tie em together?
+ /* 22 */	uint8 type;		// 231 (0xE7) for spells, skill
- /* 14 */	uint32 sequence;
+ /* 23 */	uint16 unknown23; // OSX says min_damage
- /* 18 */	uint32 unknown18;
+ /* 25 */	uint16 unknown25; // OSX says tohit
- /* 22 */	uint8 type;		// 231 (0xE7) for spells
- /* 23 */	uint32 unknown23;
  /* 27 */	uint16 spell;	// spell id being cast
- /* 29 */	uint8 unknown29;
+ /* 29 */	uint8 spell_level;
 // this field seems to be some sort of success flag, if it's 4
- /* 30 */	uint8 buff_unknown;	// if this is 4, a buff icon is made
+ /* 30 */	uint8 effect_flag;	// if this is 4, a buff icon is made
  /* 31 */
 };
 
@@ -1124,12 +1141,12 @@ struct CombatDamage_Struct
 {
 /* 00 */	uint16	target;
 /* 02 */	uint16	source;
-/* 04 */	uint8	type; //slashing, etc.  231 (0xE7) for spells
+/* 04 */	uint8	type; //slashing, etc.  231 (0xE7) for spells, skill
 /* 05 */	uint16	spellid;
 /* 07 */	uint32	damage;
 /* 11 */	float force;
-/* 15 */	float meleepush_xy;	// see above notes in Action_Struct
+/* 15 */	float hit_heading;	// see above notes in Action_Struct
-/* 19 */	float meleepush_z;
+/* 19 */	float hit_pitch;
 /* 23 */
 };
 
@@ -1327,6 +1344,19 @@ struct MoveItem_Struct
 /*0012*/
 };
 
+struct MultiMoveItemSub_Struct
+{
+/*0000*/ InventorySlot_Struct	from_slot;
+/*0016*/ uint32 number_in_stack; // so the amount we are moving from the source
+/*0020*/ InventorySlot_Struct	to_slot;
+};
+
+struct MultiMoveItem_Struct
+{
+/*0000*/ uint32	count;
+/*0004*/ MultiMoveItemSub_Struct moves[0];
+};
+
 //
 // from_slot/to_slot
 // -1 - destroy
@@ -2539,21 +2569,32 @@ struct GuildMakeLeader{
 	char	name[64];
 	char	target[64];
 };
-struct BugStruct{
+
-/*0000*/	char	chartype[64];
+struct BugReport_Struct {
-/*0064*/	char	name[96];
+/*0000*/	char	category_name[64];
-/*0160*/	char	ui[128];
+/*0064*/	char	character_name[64];
-/*0288*/	float	x;
+/*0128*/	char	unused_0128[32];
-/*0292*/	float	y;
+/*0160*/	char	ui_path[128];
-/*0296*/	float	z;
+/*0288*/	float	pos_x;
-/*0300*/	float	heading;
+/*0292*/	float	pos_y;
-/*0304*/	uint32	unknown304;
+/*0296*/	float	pos_z;
-/*0308*/	uint32	type;
+/*0300*/	uint32	heading;
-/*0312*/	char	unknown312[2144];
+/*0304*/	uint32	unused_0304;
-/*2456*/	char	bug[1024];
+/*0308*/	uint32	time_played;
-/*3480*/	char	placeholder[2];
+/*0312*/	char	padding_0312[8];
-/*3482*/	char	system_info[4098];
+/*0320*/	uint32	target_id;
+/*0324*/	char	padding_0324[140];
+/*0464*/	uint32	unknown_0464;	// seems to always be '0'
+/*0468*/	char	target_name[64];
+/*0532*/	uint32	optional_info_mask;
+
+// this looks like a butchered 8k buffer with 2 trailing dword fields
+/*0536*/	char	unused_0536[2052];
+/*2588*/	char	bug_report[2050];
+/*4638*/	char	system_info[4098];
+/*8736*/
 };
+
 struct Make_Pet_Struct { //Simple struct for getting pet info
 	uint8 level;
 	uint8 class_;
@@ -2580,20 +2621,21 @@ struct Ground_Spawn{
 struct Ground_Spawns {
 	struct Ground_Spawn spawn[50]; //Assigned max number to allow
 };
-struct PetitionBug_Struct{
+
-	uint32	petition_number;
+//struct PetitionBug_Struct{
-	uint32	unknown4;
+//	uint32	petition_number;
-	char	accountname[64];
+//	uint32	unknown4;
-	uint32	zoneid;
+//	char	accountname[64];
-	char	name[64];
+//	uint32	zoneid;
-	uint32	level;
+//	char	name[64];
-	uint32	class_;
+//	uint32	level;
-	uint32	race;
+//	uint32	class_;
-	uint32	unknown152[3];
+//	uint32	race;
-	uint32	time;
+//	uint32	unknown152[3];
-	uint32	unknown168;
+//	uint32	time;
-	char	text[1028];
+//	uint32	unknown168;
-};
+//	char	text[1028];
+//};
 
 struct ApproveZone_Struct {
 	char	name[64];
@@ -3521,6 +3563,21 @@ struct LFGuild_GuildToggle_Struct
 //	char ScrollName; // '0'
 //};
 
+struct SayLinkBodyFrame_Struct {
+/*000*/	char ActionID[1];
+/*001*/	char ItemID[5];
+/*006*/	char Augment1[5];
+/*011*/	char Augment2[5];
+/*016*/	char Augment3[5];
+/*021*/	char Augment4[5];
+/*026*/	char Augment5[5];
+/*031*/	char IsEvolving[1];
+/*032*/	char EvolveGroup[4];
+/*036*/	char EvolveLevel[1];
+/*037*/	char Hash[8];
+/*045*/
+};
+
 	}; /*structs*/
 
 }; /*Titanium*/

common/patches/uf.cpp

@@ -53,11 +53,11 @@ namespace UF
 	static inline uint32 UFToServerSlot(uint32 ufSlot);
 	static inline uint32 UFToServerCorpseSlot(uint32 ufCorpseSlot);
 
-	// server to client text link converter
+	// server to client say link converter
-	static inline void ServerToUFTextLink(std::string& ufTextLink, const std::string& serverTextLink);
+	static inline void ServerToUFSayLink(std::string& ufSayLink, const std::string& serverSayLink);
 
-	// client to server text link converter
+	// client to server say link converter
-	static inline void UFToServerTextLink(std::string& serverTextLink, const std::string& ufTextLink);
+	static inline void UFToServerSayLink(std::string& serverSayLink, const std::string& ufSayLink);
 
 	static inline CastingSlot ServerToUFCastingSlot(EQEmu::CastingSlot slot);
 	static inline EQEmu::CastingSlot UFToServerCastingSlot(CastingSlot slot);
@@ -161,29 +161,20 @@ namespace UF
 		OUT(source);
 		OUT(level);
 		eq->instrument_mod = 1.0f + (emu->instrument_mod - 10) / 10.0f;
-		eq->knockback_angle = emu->sequence;
+		OUT(force);
+		OUT(hit_heading);
+		OUT(hit_pitch);
 		OUT(type);
 		OUT(spell);
-		eq->level2 = eq->level;
+		OUT(spell_level);
-		eq->effect_flag = emu->buff_unknown;
+		OUT(effect_flag);
-		eq->unknown37 = 0x01;
+		eq->spell_gem = 0;
-		eq->unknown44 = 0xFFFFFFFF;
+		eq->slot[0] = -1; // type
-		eq->unknown48 = 0xFFFFFFFF;
+		eq->slot[1] = -1; // slot
-		eq->unknown52 = 0xFFFFFFFF;
+		eq->slot[2] = -1; // sub index
-
+		eq->slot[3] = -1; // aug index
-		/*OUT(target);
+		eq->slot[4] = -1; // unknown
-		OUT(source);
+		eq->item_cast_type = 0;
-		OUT(level);
-		OUT(instrument_mod);
-		eq->sequence = emu->sequence;
-		OUT(type);
-		//OUT(damage);
-		OUT(spell);
-		eq->level2 = emu->level;
-		OUT(buff_unknown); // if this is 4, a buff icon is made
-		//eq->unknown0036 = -1;
-		//eq->unknown0040 = -1;
-		//eq->unknown0044 = -1;*/
 
 		FINISH_ENCODE();
 	}
@@ -391,7 +382,7 @@ namespace UF
 	{
 		SETUP_VAR_ENCODE(BuffIcon_Struct);
 
-		uint32 sz = 12 + (17 * emu->count);
+		uint32 sz = 12 + (17 * emu->count) + emu->name_lengths; // 17 includes nullterm
 		__packet->size = sz;
 		__packet->pBuffer = new unsigned char[sz];
 		memset(__packet->pBuffer, 0, sz);
@@ -407,7 +398,7 @@ namespace UF
 			__packet->WriteUInt32(emu->entries[i].spell_id);
 			__packet->WriteUInt32(emu->entries[i].tics_remaining);
 			__packet->WriteUInt32(emu->entries[i].num_hits);
-			__packet->WriteString("");
+			__packet->WriteString(emu->entries[i].caster);
 		}
 		__packet->WriteUInt8(emu->type);
 
@@ -463,7 +454,7 @@ namespace UF
 
 		std::string old_message = emu->message;
 		std::string new_message;
-		ServerToUFTextLink(new_message, old_message);
+		ServerToUFSayLink(new_message, old_message);
 
 		//in->size = strlen(emu->sender) + 1 + strlen(emu->targetname) + 1 + strlen(emu->message) + 1 + 36;
 		in->size = strlen(emu->sender) + strlen(emu->targetname) + new_message.length() + 39;
@@ -586,8 +577,8 @@ namespace UF
 		OUT(spellid);
 		OUT(damage);
 		OUT(force);
-		OUT(meleepush_xy);
+		OUT(hit_heading);
-		OUT(meleepush_z);
+		OUT(hit_pitch);
 		OUT(special);
 
 		FINISH_ENCODE();
@@ -762,7 +753,7 @@ namespace UF
 
 		std::string old_message = emu->message;
 		std::string new_message;
-		ServerToUFTextLink(new_message, old_message);
+		ServerToUFSayLink(new_message, old_message);
 
 		//if (new_message.length() > 512) // length restricted in packet building function due vari-length name size (no nullterm)
 		//	new_message = new_message.substr(0, 512);
@@ -814,7 +805,7 @@ namespace UF
 
 		for (int i = 0; i < 9; ++i) {
 			if (old_message_array[i].length() == 0) { break; }
-			ServerToUFTextLink(new_message_array[i], old_message_array[i]);
+			ServerToUFSayLink(new_message_array[i], old_message_array[i]);
 			new_message_size += new_message_array[i].length() + 1;
 		}
 
@@ -1618,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;
@@ -1850,6 +1730,7 @@ namespace UF
 		OUT(copper_cursor);
 
 		OUT_array(skills, structs::MAX_PP_SKILL);	// 1:1 direct copy (100 dword)
+		OUT_array(InnateSkills, structs::MAX_PP_INNATE_SKILL);  // 1:1 direct copy (25 dword)
 
 		//	OUT(unknown04760[236]);
 		OUT(toxicity);
@@ -1889,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';
@@ -1910,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';
@@ -2225,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
@@ -2242,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);
@@ -2258,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
@@ -2468,7 +2349,7 @@ namespace UF
 		std::string old_message = &emu->message[strlen(emu->sayer)];
 		std::string new_message;
 
-		ServerToUFTextLink(new_message, old_message);
+		ServerToUFSayLink(new_message, old_message);
 
 		//in->size = 3 + 4 + 4 + strlen(emu->sayer) + 1 + 12 + new_message.length() + 1;
 		in->size = strlen(emu->sayer) + new_message.length() + 25;
@@ -2536,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;
-		ServerToUFTextLink(new_message, old_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];
 
@@ -3286,7 +3170,7 @@ namespace UF
 
 		std::string old_message = InBuffer;
 		std::string new_message;
-		UFToServerTextLink(new_message, old_message);
+		UFToServerSayLink(new_message, old_message);
 
 		//__packet->size = sizeof(ChannelMessage_Struct)+strlen(InBuffer) + 1;
 		__packet->size = sizeof(ChannelMessage_Struct) + new_message.length() + 1;
@@ -3397,7 +3281,7 @@ namespace UF
 		IN(type);
 		IN(spellid);
 		IN(damage);
-		IN(meleepush_xy);
+		IN(hit_heading);
 
 		FINISH_DIRECT_DECODE();
 	}
@@ -3420,7 +3304,7 @@ namespace UF
 
 		std::string old_message = (char *)&__eq_buffer[4]; // unknown01 offset
 		std::string new_message;
-		UFToServerTextLink(new_message, old_message);
+		UFToServerSayLink(new_message, old_message);
 
 		__packet->size = sizeof(Emote_Struct);
 		__packet->pBuffer = new unsigned char[__packet->size];
@@ -3926,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;
@@ -4016,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];
@@ -4212,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;
 
@@ -4241,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;
 
@@ -4267,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;
 
@@ -4289,19 +4173,19 @@ namespace UF
 		return (ufCorpseSlot - 1);
 	}
 
-	static inline void ServerToUFTextLink(std::string& ufTextLink, const std::string& serverTextLink)
+	static inline void ServerToUFSayLink(std::string& ufSayLink, const std::string& serverSayLink)
 	{
-		if ((constants::SayLinkBodySize == EQEmu::legacy::TEXT_LINK_BODY_LENGTH) || (serverTextLink.find('\x12') == std::string::npos)) {
+		if ((constants::SAY_LINK_BODY_SIZE == EQEmu::constants::SAY_LINK_BODY_SIZE) || (serverSayLink.find('\x12') == std::string::npos)) {
-			ufTextLink = serverTextLink;
+			ufSayLink = serverSayLink;
 			return;
 		}
 
-		auto segments = SplitString(serverTextLink, '\x12');
+		auto segments = SplitString(serverSayLink, '\x12');
 
 		for (size_t segment_iter = 0; segment_iter < segments.size(); ++segment_iter) {
 			if (segment_iter & 1) {
-				if (segments[segment_iter].length() <= EQEmu::legacy::TEXT_LINK_BODY_LENGTH) {
+				if (segments[segment_iter].length() <= EQEmu::constants::SAY_LINK_BODY_SIZE) {
-					ufTextLink.append(segments[segment_iter]);
+					ufSayLink.append(segments[segment_iter]);
 					// TODO: log size mismatch error
 					continue;
 				}
@@ -4311,37 +4195,37 @@ namespace UF
 				// SoF:  X XXXXX XXXXX XXXXX XXXXX XXXXX XXXXX       X  XXXX  X XXXXX XXXXXXXX (50)
 				// Diff:                                       ^^^^^         ^
 
-				ufTextLink.push_back('\x12');
+				ufSayLink.push_back('\x12');
-				ufTextLink.append(segments[segment_iter].substr(0, 31));
+				ufSayLink.append(segments[segment_iter].substr(0, 31));
-				ufTextLink.append(segments[segment_iter].substr(36, 5));
+				ufSayLink.append(segments[segment_iter].substr(36, 5));
 
 				if (segments[segment_iter][41] == '0')
-					ufTextLink.push_back(segments[segment_iter][42]);
+					ufSayLink.push_back(segments[segment_iter][42]);
 				else
-					ufTextLink.push_back('F');
+					ufSayLink.push_back('F');
 
-				ufTextLink.append(segments[segment_iter].substr(43));
+				ufSayLink.append(segments[segment_iter].substr(43));
-				ufTextLink.push_back('\x12');
+				ufSayLink.push_back('\x12');
 			}
 			else {
-				ufTextLink.append(segments[segment_iter]);
+				ufSayLink.append(segments[segment_iter]);
 			}
 		}
 	}
 
-	static inline void UFToServerTextLink(std::string& serverTextLink, const std::string& ufTextLink)
+	static inline void UFToServerSayLink(std::string& serverSayLink, const std::string& ufSayLink)
 	{
-		if ((EQEmu::legacy::TEXT_LINK_BODY_LENGTH == constants::SayLinkBodySize) || (ufTextLink.find('\x12') == std::string::npos)) {
+		if ((EQEmu::constants::SAY_LINK_BODY_SIZE == constants::SAY_LINK_BODY_SIZE) || (ufSayLink.find('\x12') == std::string::npos)) {
-			serverTextLink = ufTextLink;
+			serverSayLink = ufSayLink;
 			return;
 		}
 
-		auto segments = SplitString(ufTextLink, '\x12');
+		auto segments = SplitString(ufSayLink, '\x12');
 
 		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) {
-					serverTextLink.append(segments[segment_iter]);
+					serverSayLink.append(segments[segment_iter]);
 					// TODO: log size mismatch error
 					continue;
 				}
@@ -4351,16 +4235,16 @@ namespace UF
 				// RoF2: X XXXXX XXXXX XXXXX XXXXX XXXXX XXXXX XXXXX X  XXXX XX  XXXXX XXXXXXXX (56)
 				// Diff:                                       ^^^^^         ^
 
-				serverTextLink.push_back('\x12');
+				serverSayLink.push_back('\x12');
-				serverTextLink.append(segments[segment_iter].substr(0, 31));
+				serverSayLink.append(segments[segment_iter].substr(0, 31));
-				serverTextLink.append("00000");
+				serverSayLink.append("00000");
-				serverTextLink.append(segments[segment_iter].substr(31, 5));
+				serverSayLink.append(segments[segment_iter].substr(31, 5));
-				serverTextLink.push_back('0');
+				serverSayLink.push_back('0');
-				serverTextLink.append(segments[segment_iter].substr(36));
+				serverSayLink.append(segments[segment_iter].substr(36));
-				serverTextLink.push_back('\x12');
+				serverSayLink.push_back('\x12');
 			}
 			else {
-				serverTextLink.append(segments[segment_iter]);
+				serverSayLink.append(segments[segment_iter]);
 			}
 		}
 	}

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,108 +27,218 @@
 
 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 {
-		enum InventoryType : int {
+				typePossessions = INULL,
-			InvTypePossessions = InvTypeBegin,
+				typeBank,
-			InvTypeBank,
+				typeSharedBank,
-			InvTypeSharedBank,
+				typeTrade,
-			InvTypeTrade,
+				typeWorld,
-			InvTypeWorld,
+				typeLimbo,
-			InvTypeLimbo,
+				typeTribute,
-			InvTypeTribute,
+				typeGuildTribute,
-			InvTypeGuildTribute,
+				typeMerchant,
-			InvTypeMerchant,
+				typeCorpse,
-			InvTypeCorpse,
+				typeBazaar,
-			InvTypeBazaar,
+				typeInspect,
-			InvTypeInspect,
+				typeViewMODPC,
-			InvTypeViewMODPC,
+				typeViewMODBank,
-			InvTypeViewMODBank,
+				typeViewMODSharedBank,
-			InvTypeViewMODSharedBank,
+				typeViewMODLimbo,
-			InvTypeViewMODLimbo,
+				typeAltStorage,
-			InvTypeAltStorage,
+				typeArchived,
-			InvTypeArchived,
+				typeOther
-			InvTypeOther,
-			InvTypeCount
 			};
 
+		} // namespace enum_
+		using namespace enum_;
+
+		const int16 POSSESSIONS_SIZE = 32;
+		const int16 BANK_SIZE = 24;
+		const int16 SHARED_BANK_SIZE = 2;
+		const int16 TRADE_SIZE = 8;
+		const int16 WORLD_SIZE = 10;
+		const int16 LIMBO_SIZE = 36;
+		const int16 TRIBUTE_SIZE = 5;
+		const int16 GUILD_TRIBUTE_SIZE = 2;
+		const int16 MERCHANT_SIZE = 80;
+		const int16 CORPSE_SIZE = POSSESSIONS_SIZE;
+		const int16 BAZAAR_SIZE = 80;
+		const int16 INSPECT_SIZE = 23;
+		const int16 VIEW_MOD_PC_SIZE = POSSESSIONS_SIZE;
+		const int16 VIEW_MOD_BANK_SIZE = BANK_SIZE;
+		const int16 VIEW_MOD_SHARED_BANK_SIZE = SHARED_BANK_SIZE;
+		const int16 VIEW_MOD_LIMBO_SIZE = LIMBO_SIZE;
+		const int16 ALT_STORAGE_SIZE = 0;//unknown - "Shroud Bank"
+		const int16 ARCHIVED_SIZE = 0;//unknown
+		const int16 OTHER_SIZE = 0;//unknown
+
+		const int16 TRADE_NPC_SIZE = 4; // defined by implication
+
+		const int16 TYPE_INVALID = IINVALID;
+		const int16 TYPE_BEGIN = typePossessions;
+		const int16 TYPE_END = typeOther;
+		const int16 TYPE_COUNT = (TYPE_END - TYPE_BEGIN) + 1;
+
+		int16 GetInvTypeSize(int16 inv_type);
+		const char* GetInvTypeName(int16 inv_type);
+
+		bool IsInvTypePersistent(int16 inv_type);
+
 	} /*invtype*/
 
 	namespace invslot {
 		inline EQEmu::versions::ClientVersion GetInvSlotRef() { return EQEmu::versions::ClientVersion::UF; }
 
-		enum : int { InvSlotInvalid = -1, InvSlotBegin };
+		namespace enum_ {
-
+			enum InventorySlots : int16 {
-		enum PossessionsSlot : int {
+				slotCharm = INULL,
-			PossessionsCharm = InvSlotBegin,
+				slotEar1,
-			PossessionsEar1,
+				slotHead,
-			PossessionsHead,
+				slotFace,
-			PossessionsFace,
+				slotEar2,
-			PossessionsEar2,
+				slotNeck,
-			PossessionsNeck,
+				slotShoulders,
-			PossessionsShoulders,
+				slotArms,
-			PossessionsArms,
+				slotBack,
-			PossessionsBack,
+				slotWrist1,
-			PossessionsWrist1,
+				slotWrist2,
-			PossessionsWrist2,
+				slotRange,
-			PossessionsRange,
+				slotHands,
-			PossessionsHands,
+				slotPrimary,
-			PossessionsPrimary,
+				slotSecondary,
-			PossessionsSecondary,
+				slotFinger1,
-			PossessionsFinger1,
+				slotFinger2,
-			PossessionsFinger2,
+				slotChest,
-			PossessionsChest,
+				slotLegs,
-			PossessionsLegs,
+				slotFeet,
-			PossessionsFeet,
+				slotWaist,
-			PossessionsWaist,
+				slotPowerSource,
-			PossessionsPowerSource,
+				slotAmmo,
-			PossessionsAmmo,
+				slotGeneral1,
-			PossessionsGeneral1,
+				slotGeneral2,
-			PossessionsGeneral2,
+				slotGeneral3,
-			PossessionsGeneral3,
+				slotGeneral4,
-			PossessionsGeneral4,
+				slotGeneral5,
-			PossessionsGeneral5,
+				slotGeneral6,
-			PossessionsGeneral6,
+				slotGeneral7,
-			PossessionsGeneral7,
+				slotGeneral8,
-			PossessionsGeneral8,
+				slotCursor
-			PossessionsCursor,
-			PossessionsCount
 			};
 
-		const int EquipmentBegin = PossessionsCharm;
+		} // namespace enum_
-		const int EquipmentEnd = PossessionsAmmo;
+		using namespace enum_;
-		const int EquipmentCount = (EquipmentEnd - EquipmentBegin + 1);
 
-		const int GeneralBegin = PossessionsGeneral1;
+		const int16 SLOT_INVALID = IINVALID;
-		const int GeneralEnd = PossessionsGeneral8;
+		const int16 SLOT_BEGIN = INULL;
-		const int GeneralCount = (GeneralEnd - GeneralBegin + 1);
+
+		const int16 POSSESSIONS_BEGIN = slotCharm;
+		const int16 POSSESSIONS_END = slotCursor;
+		const int16 POSSESSIONS_COUNT = (POSSESSIONS_END - POSSESSIONS_BEGIN) + 1;
+
+		const int16 EQUIPMENT_BEGIN = slotCharm;
+		const int16 EQUIPMENT_END = slotAmmo;
+		const int16 EQUIPMENT_COUNT = (EQUIPMENT_END - EQUIPMENT_BEGIN + 1);
+
+		const int16 GENERAL_BEGIN = slotGeneral1;
+		const int16 GENERAL_END = slotGeneral8;
+		const int16 GENERAL_COUNT = (GENERAL_END - GENERAL_BEGIN + 1);
+
+		const int16 BONUS_BEGIN = invslot::slotCharm;
+		const int16 BONUS_STAT_END = invslot::slotPowerSource;
+		const int16 BONUS_SKILL_END = invslot::slotAmmo;
+
+		const int16 BANK_BEGIN = 2000;
+		const int16 BANK_END = (BANK_BEGIN + invtype::BANK_SIZE) - 1;
+
+		const int16 SHARED_BANK_BEGIN = 2500;
+		const int16 SHARED_BANK_END = (SHARED_BANK_BEGIN + invtype::SHARED_BANK_SIZE) - 1;
+
+		const int16 TRADE_BEGIN = 3000;
+		const int16 TRADE_END = (TRADE_BEGIN + invtype::TRADE_SIZE) - 1;
+
+		const int16 TRADE_NPC_END = (TRADE_BEGIN + invtype::TRADE_NPC_SIZE) - 1; // defined by implication
+
+		const int16 WORLD_BEGIN = 4000;
+		const int16 WORLD_END = (WORLD_BEGIN + invtype::WORLD_SIZE) - 1;
+
+		const int16 TRIBUTE_BEGIN = 400;
+		const int16 TRIBUTE_END = (TRIBUTE_BEGIN + invtype::TRIBUTE_SIZE) - 1;
+
+		const int16 GUILD_TRIBUTE_BEGIN = 450;
+		const int16 GUILD_TRIBUTE_END = (GUILD_TRIBUTE_BEGIN + invtype::GUILD_TRIBUTE_SIZE) - 1;
+
+		const int16 CORPSE_BEGIN = invslot::slotGeneral1;
+		const int16 CORPSE_END = invslot::slotGeneral1 + invslot::slotCursor;
+
+		const uint64 POSSESSIONS_BITMASK = 0x000000027FFFFFFF; // based on 34-slot count (RoF+)
+		const uint64 CORPSE_BITMASK = 0x01FFFFFE7F800000; // based on 34-slot count (RoF+)
+
+		const char* GetInvPossessionsSlotName(int16 inv_slot);
+		const char* GetInvCorpseSlotName(int16 inv_slot);
+		const char* GetInvSlotName(int16 inv_type, int16 inv_slot);
 
 	} /*invslot*/
 
 	namespace invbag {
 		inline EQEmu::versions::ClientVersion GetInvBagRef() { return EQEmu::versions::ClientVersion::UF; }
 
-		enum : int { InvBagInvalid = -1, InvBagBegin };
+		const int16 SLOT_INVALID = IINVALID;
+		const int16 SLOT_BEGIN = INULL;
+		const int16 SLOT_END = 9;
+		const int16 SLOT_COUNT = 10;
+
+		const int16 GENERAL_BAGS_BEGIN = 262;
+		const int16 GENERAL_BAGS_COUNT = invslot::GENERAL_COUNT * SLOT_COUNT;
+		const int16 GENERAL_BAGS_END = (GENERAL_BAGS_BEGIN + GENERAL_BAGS_COUNT) - 1;
+
+		const int16 CURSOR_BAG_BEGIN = 342;
+		const int16 CURSOR_BAG_COUNT = SLOT_COUNT;
+		const int16 CURSOR_BAG_END = (CURSOR_BAG_BEGIN + CURSOR_BAG_COUNT) - 1;
+
+		const int16 BANK_BAGS_BEGIN = 2032;
+		const int16 BANK_BAGS_COUNT = (invtype::BANK_SIZE * SLOT_COUNT);
+		const int16 BANK_BAGS_END = (BANK_BAGS_BEGIN + BANK_BAGS_COUNT) - 1;
+
+		const int16 SHARED_BANK_BAGS_BEGIN = 2532;
+		const int16 SHARED_BANK_BAGS_COUNT = invtype::SHARED_BANK_SIZE * SLOT_COUNT;
+		const int16 SHARED_BANK_BAGS_END = (SHARED_BANK_BAGS_BEGIN + SHARED_BANK_BAGS_COUNT) - 1;
+
+		const int16 TRADE_BAGS_BEGIN = 3031;
+		const int16 TRADE_BAGS_COUNT = invtype::TRADE_SIZE * SLOT_COUNT;
+		const int16 TRADE_BAGS_END = (TRADE_BAGS_BEGIN + TRADE_BAGS_COUNT) - 1;
+
+		const char* GetInvBagIndexName(int16 bag_index);
 
 	} /*invbag*/
 
 	namespace invaug {
 		inline EQEmu::versions::ClientVersion GetInvAugRef() { return EQEmu::versions::ClientVersion::UF; }
 
-		enum : int { InvAugInvalid = -1, InvAugBegin };
+		const int16 SOCKET_INVALID = IINVALID;
+		const int16 SOCKET_BEGIN = INULL;
+		const int16 SOCKET_END = 4;
+		const int16 SOCKET_COUNT = 5;
+
+		const char* GetInvAugIndexName(int16 aug_index);
 	
 	} /*invaug*/
 
@@ -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

@@ -292,7 +292,7 @@ struct Spawn_Struct
 /*0000*/ //uint8     nullterm1; // hack to null terminate name
 /*0064*/ uint32 spawnId;
 /*0068*/ uint8  level;
-/*0069*/ float    unknown1;
+/*0069*/ float  bounding_radius; // used in melee, overrides calc
 /*0073*/ uint8  NPC;           // 0=player,1=npc,2=pc corpse,3=npc corpse
 	 Spawn_Struct_Bitfields	Bitfields;
 /*0000*/ uint8  otherData; // & 4 - has title, & 8 - has suffix, & 1 - it's a chest or untargetable
@@ -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;
@@ -848,6 +848,7 @@ static const uint32 MAX_PP_LANGUAGE		= 25; //
 static const uint32 MAX_PP_SPELLBOOK	= 720; // Confirmed 60 pages on Underfoot now
 static const uint32 MAX_PP_MEMSPELL		= 12; //was 9 now 10 on Underfoot
 static const uint32 MAX_PP_SKILL		= PACKET_SKILL_ARRAY_SIZE;	// 100 - actual skills buffer size
+static const uint32 MAX_PP_INNATE_SKILL	= 25;
 static const uint32 MAX_PP_AA_ARRAY		= 300; //was 299
 static const uint32 MAX_GROUP_MEMBERS	= 6;
 static const uint32 MAX_RECAST_TYPES	= 20;
@@ -954,7 +955,8 @@ struct PlayerProfile_Struct
 /*07336*/ uint32  silver_cursor;		// Silver Pieces on cursor
 /*07340*/ uint32  copper_cursor;		// Copper Pieces on cursor
 /*07344*/ uint32  skills[MAX_PP_SKILL];	// [400] List of skills	// 100 dword buffer
-/*07744*/ uint8   unknown07644[136];
+/*07744*/ uint32  InnateSkills[MAX_PP_INNATE_SKILL];
+/*07844*/ uint8   unknown07644[36];
 /*07880*/ uint32  toxicity;				// Potion Toxicity (15=too toxic, each potion adds 3)
 /*07884*/ uint32  thirst_level;			// Drink (ticks till next drink)
 /*07888*/ uint32  hunger_level;			// Food (ticks till next eat)
@@ -967,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;
@@ -1250,19 +1252,19 @@ struct Action_Struct
 {
 /*00*/	uint16 target;			// id of target
 /*02*/	uint16 source;			// id of caster
-/*04*/	uint16 level;			// level of caster - Seen 0
+/*04*/	uint16 level;			// level of caster for spells, OSX dump says attack rating, guess spells use it for level
-/*06*/  uint32 unknown06;
+/*06*/  uint32 unknown06;		// OSX dump says base_damage, was used for bard mod too, this is 0'd :(
-/*10*/	uint16 instrument_focus;
+/*10*/	float instrument_mod;
-/*12*/	uint16 unknown12;		// seems to always be set to something and it doesn't change between casts except in special cases like changing instrument mods
+/*14*/  float force;
-/*14*/  uint32 unknown14;       // seen 0
+/*18*/  float hit_heading;
-/*18*/  float knockback_angle;  //seems to go from 0-512 then it rolls over again
+/*22*/  float hit_pitch;
-/*22*/  uint32 unknown22;
+/*26*/  uint8 type;				// 231 (0xE7) for spells, skill
-/*26*/  uint8 type;
+/*27*/  uint32 damage;			// OSX says min_damage
-/*27*/  uint32 damage;
+/*31*/  uint16 unknown31;		// OSX says tohit
-/*31*/  uint16 unknown31;
 /*33*/	uint16 spell;			// spell id being cast
-/*35*/	uint8 level2;			// level of caster again? Or maybe the castee
+/*35*/	uint8 spell_level;		// level of caster again? Or maybe the castee
 /*36*/	uint8 effect_flag;		// if this is 4, the effect is valid: or if two are sent at the same time?
+/*37*/
 };
 
 
@@ -1274,27 +1276,22 @@ struct ActionAlt_Struct
 {
 /*00*/	uint16 target;			// id of target
 /*02*/	uint16 source;			// id of caster
-/*04*/	uint16 level;			// level of caster - Seen 0
+/*04*/	uint16 level;			// level of caster for spells, OSX dump says attack rating, guess spells use it for level
-/*06*/  uint32 unknown06;
+/*06*/  uint32 unknown06;		// OSX dump says base_damage, was used for bard mod too, this is 0'd :(
 /*10*/	float instrument_mod;
-/*14*/  uint32 unknown14;       // seen 0
+/*14*/  float force;
-/*18*/  float knockback_angle;  //seems to go from 0-512 then it rolls over again
+/*18*/  float hit_heading;
-/*22*/  uint32 unknown22;
+/*22*/  float hit_pitch;
-/*26*/  uint8 type;
+/*26*/  uint8 type;				// 231 (0xE7) for spells, skill
-/*27*/  uint32 damage;
+/*27*/  uint32 damage;			// OSX says min_damage
-/*31*/  uint16 unknown31;
+/*31*/  uint16 unknown31;		// OSX says tohit
 /*33*/	uint16 spell;			// spell id being cast
-/*35*/	uint8 level2;			// level of caster again? Or maybe the castee
+/*35*/	uint8 spell_level;		// level of caster again? Or maybe the castee
 /*36*/	uint8 effect_flag;		// if this is 4, the effect is valid: or if two are sent at the same time?
-/*37*/	uint32 unknown37;		// New field to Underfoot - Seen 14
+/*37*/	uint8 spell_gem;
-/*41*/	uint8 unknown41;			// New field to Underfoot - Seen 0
+/*38*/	uint8 padding38[2];
-/*42*/	uint8 unknown42;			// New field to Underfoot - Seen 0
+/*40*/	uint32 slot[5];
-/*43*/	uint8 unknown43;			// New field to Underfoot - Seen 0
+/*60*/	uint32 item_cast_type;	// ItemSpellTypes enum from MQ2
-/*44*/	uint32 unknown44;		// New field to Underfoot - Seen 23
-/*48*/	uint32 unknown48;		// New field to Underfoot - Seen -1
-/*52*/	uint32 unknown52;		// New field to Underfoot - Seen -1
-/*56*/	uint32 unknown56;		// New field to Underfoot - Seen 0
-/*60*/	uint32 unknown60;		// New field to Underfoot - Seen 0
 /*64*/
 };
 
@@ -1309,9 +1306,9 @@ struct CombatDamage_Struct
 /* 05 */	uint16	spellid;
 /* 07 */	int32	damage;
 /* 11 */	float	force;		// cd cc cc 3d
-/* 15 */	float	meleepush_xy;		// see above notes in Action_Struct
+/* 15 */	float	hit_heading;		// see above notes in Action_Struct
-/* 19 */	float	meleepush_z;
+/* 19 */	float	hit_pitch;
-/* 23 */	uint8	unknown23;	// was [9]
+/* 23 */	uint8	secondary;	// 0 for primary hand, 1 for secondary
 /* 24 */	uint32	special; // 2 = Rampage, 1 = Wild Rampage
 /* 28 */
 };
@@ -3058,23 +3055,6 @@ struct GuildMakeLeader{
 	char	target[64];
 };
 
-
-
-struct BugStruct{
-/*0000*/	char	chartype[64];
-/*0064*/	char	name[96];
-/*0160*/	char	ui[128];
-/*0288*/	float	x;
-/*0292*/	float	y;
-/*0296*/	float	z;
-/*0300*/	float	heading;
-/*0304*/	uint32	unknown304;
-/*0308*/	uint32	type;
-/*0312*/	char	unknown312[2144];
-/*2456*/	char	bug[1024];
-/*3480*/	char	placeholder[2];
-/*3482*/	char	system_info[4098];
-};
 struct Make_Pet_Struct { //Simple struct for getting pet info
 	uint8 level;
 	uint8 class_;
@@ -3101,20 +3081,21 @@ struct Ground_Spawn{
 struct Ground_Spawns {
 	struct Ground_Spawn spawn[50]; //Assigned max number to allow
 };
-struct PetitionBug_Struct{
+
-	uint32	petition_number;
+//struct PetitionBug_Struct{
-	uint32	unknown4;
+//	uint32	petition_number;
-	char	accountname[64];
+//	uint32	unknown4;
-	uint32	zoneid;
+//	char	accountname[64];
-	char	name[64];
+//	uint32	zoneid;
-	uint32	level;
+//	char	name[64];
-	uint32	class_;
+//	uint32	level;
-	uint32	race;
+//	uint32	class_;
-	uint32	unknown152[3];
+//	uint32	race;
-	uint32	time;
+//	uint32	unknown152[3];
-	uint32	unknown168;
+//	uint32	time;
-	char	text[1028];
+//	uint32	unknown168;
-};
+//	char	text[1028];
+//};
 
 struct ApproveZone_Struct {
 	char	name[64];
@@ -4503,6 +4484,22 @@ struct MercenaryAssign_Struct {
 /*0004*/	uint32	MercUnk01;		//
 /*0008*/	uint32	MercUnk02;		//
 /*0012*/
+};
+
+struct SayLinkBodyFrame_Struct {
+/*000*/	char ActionID[1];
+/*001*/	char ItemID[5];
+/*006*/	char Augment1[5];
+/*011*/	char Augment2[5];
+/*016*/	char Augment3[5];
+/*021*/	char Augment4[5];
+/*026*/	char Augment5[5];
+/*031*/	char IsEvolving[1];
+/*032*/	char EvolveGroup[4];
+/*036*/	char EvolveLevel[1];
+/*037*/	char OrnamentIcon[5];
+/*042*/	char Hash[8];
+/*050*/
 };
 
 	}; /*structs*/

common/races.cpp

@@ -1349,8 +1349,7 @@ const char* GetPlayerRaceName(uint32 player_race_value)
 	return GetRaceIDName(GetRaceIDFromPlayerRaceValue(player_race_value));
 }
 
-uint32 GetPlayerRaceValue(uint16 race_id)
+uint32 GetPlayerRaceValue(uint16 race_id) {
-{
 	switch (race_id) {
 		case HUMAN:
 		case BARBARIAN:
@@ -1379,8 +1378,7 @@ uint32 GetPlayerRaceValue(uint16 race_id)
 	}
 }
 
-uint32 GetPlayerRaceBit(uint16 race_id)
+uint32 GetPlayerRaceBit(uint16 race_id) {
-{
 	switch (race_id) {
 		case HUMAN:
 			return PLAYER_RACE_HUMAN_BIT;
@@ -1419,8 +1417,7 @@ uint32 GetPlayerRaceBit(uint16 race_id)
 	}
 }
 
-uint16 GetRaceIDFromPlayerRaceValue(uint32 player_race_value)
+uint16 GetRaceIDFromPlayerRaceValue(uint32 player_race_value) {
-{
 	switch (player_race_value) {
 		case PLAYER_RACE_HUMAN:
 		case PLAYER_RACE_BARBARIAN:
@@ -1488,6 +1485,122 @@ uint16 GetRaceIDFromPlayerRaceBit(uint32 player_race_bit)
 	}
 }
 
+float GetRaceGenderDefaultHeight(int race, int gender)
+{
+	static float male_height[] = {
+	    6.0f,  6.0f,  7.0f,   6.0f,   5.0f,  6.0f,  5.0f,   5.5f,  4.0f,  8.0f,  9.0f,  3.5f,  3.0f,  6.0f,   6.0f,
+	    2.0f,  8.5f,  8.0f,   21.0f,  20.0f, 6.0f,  6.0f,   3.5f,  3.0f,  6.0f,  2.0f,  5.0f,  5.0f,  6.0f,   6.0f,
+	    6.0f,  7.5f,  6.0f,   6.0f,   6.0f,  6.0f,  6.0f,   6.0f,  5.0f,  6.0f,  6.0f,  7.0f,  4.0f,  4.7f,   6.0f,
+	    8.0f,  3.0f,  12.0f,  5.0f,   21.0f, 6.0f,  6.0f,   3.0f,  9.0f,  6.0f,  6.0f,  2.0f,  6.0f,  3.0f,   6.0f,
+	    4.0f,  20.0f, 5.0f,   5.0f,   6.0f,  9.0f,  25.0f,  6.0f,  6.0f,  10.0f, 6.0f,  6.0f,  6.0f,  6.0f,   2.5f,
+	    7.0f,  6.0f,  5.0f,   6.0f,   1.5f,  1.0f,  3.5f,   7.0f,  6.0f,  6.0f,  6.0f,  6.0f,  7.0f,  3.0f,   3.0f,
+	    7.0f,  12.0f, 8.0f,   9.0f,   4.0f,  11.5f, 8.0f,   6.0f,  6.0f,  12.0f, 6.0f,  6.0f,  6.0f,  20.0f,  10.0f,
+	    6.5f,  6.0f,  17.0f,  1.0f,   4.0f,  6.0f,  8.0f,   5.0f,  1.0f,  6.0f,  6.0f,  5.0f,  5.0f,  5.0f,   9.0f,
+	    3.0f,  8.0f,  2.0f,   24.0f,  6.0f,  10.0f, 6.0f,   6.0f,  6.0f,  3.0f,  7.0f,  9.0f,  6.0f,  11.0f,  2.5f,
+	    14.0f, 8.0f,  7.0f,   12.0f,  6.0f,  27.0f, 6.0f,   6.0f,  6.0f,  6.0f,  2.0f,  9.0f,  9.0f,  6.0f,   9.0f,
+	    3.0f,  3.0f,  6.0f,   6.0f,   10.0f, 6.0f,  6.0f,   15.0f, 15.0f, 9.0f,  7.0f,  6.0f,  6.0f,  7.0f,   8.0f,
+	    3.0f,  3.0f,  6.0f,   7.0f,   13.0f, 6.0f,  6.0f,   9.0f,  5.0f,  7.0f,  9.0f,  6.0f,  6.0f,  8.0f,   6.0f,
+	    6.0f,  5.5f,  6.0f,   4.0f,   25.0f, 6.0f,  6.0f,   6.0f,  22.0f, 20.0f, 6.0f,  10.0f, 13.5f, 12.0f,  3.0f,
+	    30.0f, 6.0f,  6.0f,   35.0f,  1.5f,  8.0f,  3.0f,   6.0f,  2.0f,  6.0f,  6.0f,  5.0f,  2.0f,  7.0f,   6.0f,
+	    6.0f,  6.0f,  6.0f,   4.0f,   6.0f,  6.0f,  6.0f,   8.0f,  8.0f,  7.0f,  8.0f,  6.0f,  7.0f,  6.0f,   7.0f,
+	    6.0f,  10.0f, 3.0f,   6.0f,   8.0f,  9.0f,  15.0f,  5.0f,  10.0f, 7.0f,  6.0f,  7.0f,  6.0f,  7.0f,   7.0f,
+	    12.0f, 6.0f,  4.0f,   6.0f,   5.0f,  3.0f,  30.0f,  30.0f, 15.0f, 20.0f, 6.0f,  10.0f, 6.0f,  14.0f,  14.0f,
+	    16.0f, 15.0f, 30.0f,  15.0f,  7.5f,  5.0f,  4.0f,   6.0f,  15.0f, 6.5f,  3.0f,  12.0f, 10.0f, 10.5f,  10.0f,
+	    7.5f,  6.0f,  6.0f,   12.5f,  9.0f,  20.0f, 2.0f,   10.0f, 25.0f, 8.0f,  6.0f,  6.0f,  10.0f, 18.0f,  45.0f,
+	    13.0f, 15.0f, 8.0f,   30.0f,  25.0f, 25.0f, 10.0f,  13.0f, 5.0f,  3.5f,  15.0f, 35.0f, 11.0f, 15.0f,  50.0f,
+	    13.0f, 6.0f,  7.0f,   6.0f,   60.0f, 6.0f,  22.0f,  22.0f, 21.0f, 22.0f, 15.0f, 25.0f, 23.0f, 8.0f,   15.0f,
+	    10.0f, 6.0f,  7.0f,   6.0f,   12.0f, 9.5f,  6.0f,   12.0f, 12.0f, 12.0f, 15.0f, 4.0f,  5.0f,  105.0f, 20.0f,
+	    5.0f,  10.0f, 10.0f,  10.0f,  20.0f, 13.5f, 8.0f,   10.0f, 3.0f,  5.0f,  9.0f,  6.0f,  6.0f,  6.0f,   10.0f,
+	    8.0f,  8.0f,  8.0f,   6.0f,   6.0f,  5.0f,  5.0f,   5.0f,  9.0f,  9.0f,  9.0f,  6.0f,  8.5f,  6.0f,   7.0f,
+	    8.0f,  7.0f,  11.0f,  6.0f,   7.0f,  9.0f,  8.0f,   6.0f,  8.0f,  6.0f,  6.0f,  6.0f,  6.0f,  9.0f,   10.0f,
+	    6.0f,  3.0f,  4.0f,   3.0f,   3.0f,  4.0f,  10.0f,  10.0f, 2.0f,  8.0f,  6.0f,  6.0f,  14.0f, 7.0f,   5.0f,
+	    9.0f,  7.0f,  7.0f,   10.0f,  10.0f, 12.0f, 9.0f,   7.0f,  12.0f, 13.0f, 16.0f, 6.0f,  9.0f,  6.0f,   6.0f,
+	    10.0f, 25.0f, 15.0f,  6.0f,   25.0f, 6.0f,  6.0f,   8.0f,  11.0f, 6.0f,  9.0f,  2.0f,  6.0f,  5.0f,   4.0f,
+	    8.5f,  6.0f,  6.0f,   6.0f,   4.0f,  6.0f,  15.0f,  1.0f,  2.0f,  6.0f,  40.0f, 8.0f,  12.0f, 3.0f,   8.0f,
+	    99.0f, 9.0f,  100.0f, 100.0f, 10.0f, 6.0f,  27.5f,  20.0f, 6.0f,  6.0f,  5.0f,  6.0f,  8.0f,  5.0f,   3.0f,
+	    11.5f, 25.0f, 80.0f,  20.0f,  9.0f,  8.0f,  5.0f,   4.0f,  7.0f,  10.0f, 6.0f,  11.0f, 8.0f,  5.0f,   6.0f,
+	    6.0f,  30.0f, 7.0f,   15.0f,  9.0f,  6.0f,  9.0f,   6.0f,  3.0f,  32.5f, 15.0f, 7.5f,  10.0f, 10.0f,  6.0f,
+	    6.0f,  6.0f,  6.0f,   6.0f,   6.0f,  9.0f,  20.0f,  6.0f,  6.0f,  6.0f,  25.0f, 12.0f, 6.0f,  8.0f,   6.0f,
+	    6.0f,  20.0f, 10.0f,  8.0f,   12.0f, 8.0f,  2.0f,   6.0f,  3.0f,  6.0f,  7.0f,  1.5f,  6.0f,  3.0f,   3.0f,
+	    3.0f,  3.0f,  2.0f,   3.0f,   3.0f,  6.0f,  6.0f,   6.0f,  4.5f,  7.0f,  6.0f,  7.0f,  6.0f,  22.0f,  8.0f,
+	    15.0f, 22.0f, 8.0f,   15.0f,  6.0f,  80.0f, 150.0f, 7.0f,  6.0f,  6.0f,  6.0f,  12.0f, 6.0f,  6.0f,   6.0f,
+	    6.0f,  6.0f,  6.0f,   6.0f,   6.0f,  6.0f,  6.0f,   35.0f, 20.0f, 9.0f,  6.0f,  6.0f,  6.0f,  20.0f,  20.0f,
+	    20.0f, 20.0f, 20.0f,  9.0f,   4.0f,  4.0f,  10.0f,  5.0f,  8.0f,  6.0f,  10.0f, 6.0f,  6.0f,  2.0f,   36.0f,
+	    14.0f, 7.0f,  250.0f, 6.0f,   9.0f,  6.0f,  7.0f,   4.0f,  6.0f,  8.0f,  6.0f,  23.0f, 6.0f,  6.0f,   6.0f,
+	    70.0f, 6.0f,  7.0f,   6.0f,   6.0f,  6.0f,  20.0f,  6.0f,  6.0f,  6.0f,  5.0f,  1.0f,  6.0f,  6.0f,   6.0f,
+	    6.0f,  6.0f,  6.0f,   6.0f,   6.0f,  6.0f,  6.0f,   6.0f,  6.0f,  6.0f,  6.0f,  6.0f,  6.0f,  6.0f,   6.0f,
+	    6.0f,  6.0f,  6.0f,   6.0f,   6.0f,  6.0f,  6.0f,   6.0f,  6.0f,  6.0f,  6.0f,  6.0f,  6.0f,  6.0f,   6.0f,
+	    6.0f,  6.0f,  6.0f,   6.0f,   6.0f,  6.0f,  6.0f,   6.0f,  6.0f,  6.0f,  6.0f,  6.0f,  6.0f,  6.0f,   6.0f,
+	    4.0f,  4.0f,  6.0f,   6.0f,   6.0f,  6.0f,  6.0f,   6.0f,  6.0f,  6.0f,  6.0f,  10.0f, 6.0f,  6.0f,   6.0f,
+	    6.0f,  6.0f,  6.0f,   6.0f,   6.0f,  6.0f,  6.0f,   6.0f,  6.0f,  6.0f,  6.0f,  6.0f,  6.0f,  6.0f,   6.0f,
+	    6.0f,  6.0f,  6.0f,   6.0f,   6.0f,  6.0f,  6.0f,   6.0f,  6.0f,  6.0f,  6.0f,  6.0f,  6.0f,  6.0f,   6.0f,
+	    6.0f,  6.0f,  6.0f,   6.0f,   6.0f,  7.0f,  7.0f,   7.0f,  7.0f,  6.0f,  6.0f,  6.0f,  6.0f,  6.0f,   8.0f,
+	    6.0f,  6.0f,  6.0f,   7.0f,   6.0f,  6.0f,  6.0f,   7.5f,  6.0f,  6.0f,  4.0f,  6.0f,  3.0f,  6.0f,   6.0f,
+	    1.0f,  9.0f,  7.0f,   8.0f,   7.0f,  8.0f,  6.0f,   6.0f,  6.0f,  6.0f,  6.0f,  8.0f,
+	};
+
+	static float female_height[] = {
+	    6.0f,  6.0f,  7.0f,   6.0f,   5.0f,  6.0f,  5.0f,   5.5f,  4.0f,  8.0f,  9.0f,  3.5f,  3.0f,  6.0f,   6.0f,
+	    2.0f,  8.5f,  8.0f,   21.0f,  20.0f, 6.0f,  6.0f,   3.5f,  3.0f,  6.0f,  2.0f,  5.0f,  5.0f,  6.0f,   6.0f,
+	    6.0f,  7.5f,  6.0f,   6.0f,   6.0f,  6.0f,  6.0f,   6.0f,  5.0f,  6.0f,  6.0f,  7.0f,  4.0f,  4.7f,   6.0f,
+	    8.0f,  3.0f,  12.0f,  5.0f,   21.0f, 6.0f,  6.0f,   3.0f,  9.0f,  6.0f,  6.0f,  2.0f,  6.0f,  3.0f,   6.0f,
+	    4.0f,  20.0f, 5.0f,   5.0f,   6.0f,  9.0f,  25.0f,  6.0f,  6.0f,  10.0f, 6.0f,  6.0f,  6.0f,  6.0f,   2.5f,
+	    7.0f,  6.0f,  5.0f,   6.0f,   1.5f,  1.0f,  3.5f,   7.0f,  6.0f,  6.0f,  6.0f,  6.0f,  7.0f,  3.0f,   3.0f,
+	    7.0f,  12.0f, 8.0f,   9.0f,   4.0f,  11.5f, 8.0f,   6.0f,  6.0f,  12.0f, 6.0f,  6.0f,  6.0f,  20.0f,  10.0f,
+	    6.5f,  6.0f,  17.0f,  1.0f,   4.0f,  6.0f,  8.0f,   5.0f,  1.0f,  6.0f,  6.0f,  5.0f,  5.0f,  5.0f,   9.0f,
+	    3.0f,  8.0f,  2.0f,   24.0f,  6.0f,  10.0f, 6.0f,   6.0f,  6.0f,  3.0f,  7.0f,  9.0f,  6.0f,  11.0f,  2.5f,
+	    14.0f, 8.0f,  7.0f,   12.0f,  6.0f,  27.0f, 6.0f,   6.0f,  6.0f,  6.0f,  2.0f,  9.0f,  9.0f,  6.0f,   9.0f,
+	    3.0f,  3.0f,  6.0f,   6.0f,   10.0f, 6.0f,  6.0f,   15.0f, 15.0f, 9.0f,  7.0f,  6.0f,  6.0f,  7.0f,   8.0f,
+	    3.0f,  3.0f,  6.0f,   7.0f,   13.0f, 6.0f,  6.0f,   9.0f,  5.0f,  7.0f,  9.0f,  6.0f,  6.0f,  8.0f,   6.0f,
+	    6.0f,  5.5f,  6.0f,   4.0f,   25.0f, 6.0f,  6.0f,   6.0f,  22.0f, 20.0f, 6.0f,  10.0f, 13.5f, 12.0f,  3.0f,
+	    30.0f, 6.0f,  6.0f,   35.0f,  1.5f,  8.0f,  3.0f,   6.0f,  2.0f,  6.0f,  6.0f,  5.0f,  2.0f,  7.0f,   6.0f,
+	    6.0f,  6.0f,  6.0f,   4.0f,   6.0f,  6.0f,  6.0f,   8.0f,  8.0f,  7.0f,  8.0f,  6.0f,  7.0f,  6.0f,   7.0f,
+	    6.0f,  10.0f, 3.0f,   6.0f,   8.0f,  9.0f,  15.0f,  5.0f,  10.0f, 7.0f,  6.0f,  7.0f,  6.0f,  7.0f,   7.0f,
+	    12.0f, 6.0f,  4.0f,   6.0f,   5.0f,  3.0f,  30.0f,  30.0f, 15.0f, 20.0f, 6.0f,  10.0f, 6.0f,  14.0f,  14.0f,
+	    16.0f, 15.0f, 30.0f,  15.0f,  7.5f,  5.0f,  4.0f,   6.0f,  15.0f, 6.5f,  3.0f,  12.0f, 10.0f, 10.5f,  10.0f,
+	    7.5f,  6.0f,  6.0f,   12.5f,  9.0f,  20.0f, 2.0f,   10.0f, 25.0f, 8.0f,  6.0f,  6.0f,  10.0f, 18.0f,  45.0f,
+	    13.0f, 15.0f, 8.0f,   30.0f,  25.0f, 25.0f, 10.0f,  13.0f, 5.0f,  3.5f,  15.0f, 35.0f, 11.0f, 15.0f,  50.0f,
+	    13.0f, 6.0f,  7.0f,   6.0f,   60.0f, 6.0f,  22.0f,  22.0f, 21.0f, 22.0f, 15.0f, 25.0f, 23.0f, 8.0f,   15.0f,
+	    10.0f, 6.0f,  7.0f,   6.0f,   12.0f, 9.5f,  6.0f,   12.0f, 12.0f, 12.0f, 15.0f, 4.0f,  5.0f,  105.0f, 20.0f,
+	    5.0f,  10.0f, 10.0f,  10.0f,  20.0f, 13.5f, 8.0f,   10.0f, 3.0f,  5.0f,  9.0f,  6.0f,  6.0f,  6.0f,   10.0f,
+	    8.0f,  8.0f,  8.0f,   6.0f,   6.0f,  5.0f,  5.0f,   5.0f,  9.0f,  9.0f,  9.0f,  6.0f,  8.5f,  6.0f,   7.0f,
+	    8.0f,  7.0f,  11.0f,  6.0f,   7.0f,  9.0f,  8.0f,   6.0f,  8.0f,  6.0f,  6.0f,  6.0f,  6.0f,  9.0f,   10.0f,
+	    6.0f,  3.0f,  4.0f,   3.0f,   3.0f,  4.0f,  10.0f,  10.0f, 2.0f,  8.0f,  6.0f,  6.0f,  14.0f, 7.0f,   5.0f,
+	    9.0f,  7.0f,  7.0f,   10.0f,  10.0f, 12.0f, 9.0f,   7.0f,  12.0f, 13.0f, 16.0f, 6.0f,  9.0f,  6.0f,   6.0f,
+	    10.0f, 25.0f, 15.0f,  6.0f,   25.0f, 6.0f,  6.0f,   8.0f,  11.0f, 6.0f,  9.0f,  2.0f,  6.0f,  5.0f,   4.0f,
+	    8.5f,  6.0f,  6.0f,   6.0f,   4.0f,  6.0f,  15.0f,  1.0f,  2.0f,  6.0f,  40.0f, 8.0f,  12.0f, 3.0f,   8.0f,
+	    99.0f, 9.0f,  100.0f, 100.0f, 10.0f, 6.0f,  27.5f,  20.0f, 6.0f,  6.0f,  5.0f,  6.0f,  8.0f,  5.0f,   3.0f,
+	    11.5f, 25.0f, 80.0f,  20.0f,  9.0f,  8.0f,  5.0f,   4.0f,  7.0f,  10.0f, 6.0f,  11.0f, 8.0f,  5.0f,   6.0f,
+	    6.0f,  30.0f, 7.0f,   15.0f,  9.0f,  6.0f,  9.0f,   6.0f,  3.0f,  32.5f, 15.0f, 7.5f,  10.0f, 10.0f,  6.0f,
+	    6.0f,  6.0f,  6.0f,   6.0f,   6.0f,  9.0f,  20.0f,  6.0f,  6.0f,  6.0f,  25.0f, 12.0f, 6.0f,  8.0f,   6.0f,
+	    6.0f,  20.0f, 9.0f,   8.0f,   12.0f, 8.0f,  2.0f,   6.0f,  3.0f,  6.0f,  7.0f,  1.5f,  6.0f,  3.0f,   3.0f,
+	    3.0f,  3.0f,  2.0f,   3.0f,   3.0f,  6.0f,  6.0f,   6.0f,  4.5f,  7.0f,  6.0f,  7.0f,  5.7f,  22.0f,  8.0f,
+	    15.0f, 22.0f, 8.0f,   15.0f,  6.0f,  80.0f, 150.0f, 7.0f,  6.0f,  6.0f,  6.0f,  12.0f, 6.0f,  6.0f,   6.0f,
+	    6.0f,  6.0f,  6.0f,   6.0f,   6.0f,  6.0f,  6.0f,   35.0f, 20.0f, 9.0f,  6.0f,  6.0f,  6.0f,  20.0f,  20.0f,
+	    20.0f, 20.0f, 20.0f,  9.0f,   4.0f,  4.0f,  10.0f,  5.0f,  8.0f,  6.0f,  10.0f, 5.7f,  6.0f,  2.0f,   36.0f,
+	    14.0f, 7.0f,  250.0f, 6.0f,   9.0f,  6.0f,  7.0f,   4.0f,  6.0f,  8.0f,  6.0f,  23.0f, 6.0f,  6.0f,   6.0f,
+	    70.0f, 6.0f,  7.0f,   6.0f,   6.0f,  6.0f,  20.0f,  6.0f,  6.0f,  6.0f,  5.0f,  1.0f,  6.0f,  6.0f,   6.0f,
+	    6.0f,  6.0f,  6.0f,   6.0f,   6.0f,  6.0f,  6.0f,   6.0f,  6.0f,  6.0f,  6.0f,  6.0f,  6.0f,  6.0f,   6.0f,
+	    6.0f,  6.0f,  6.0f,   6.0f,   6.0f,  6.0f,  6.0f,   6.0f,  6.0f,  6.0f,  6.0f,  6.0f,  6.0f,  6.0f,   6.0f,
+	    6.0f,  6.0f,  6.0f,   6.0f,   6.0f,  6.0f,  6.0f,   6.0f,  6.0f,  6.0f,  6.0f,  6.0f,  6.0f,  6.0f,   6.0f,
+	    4.0f,  4.0f,  6.0f,   6.0f,   6.0f,  6.0f,  6.0f,   6.0f,  6.0f,  6.0f,  6.0f,  10.0f, 6.0f,  6.0f,   6.0f,
+	    6.0f,  6.0f,  6.0f,   6.0f,   6.0f,  6.0f,  6.0f,   6.0f,  6.0f,  6.0f,  6.0f,  6.0f,  6.0f,  6.0f,   6.0f,
+	    6.0f,  6.0f,  6.0f,   6.0f,   6.0f,  6.0f,  6.0f,   6.0f,  6.0f,  6.0f,  6.0f,  6.0f,  6.0f,  6.0f,   6.0f,
+	    6.0f,  6.0f,  6.0f,   6.0f,   6.0f,  7.0f,  7.0f,   7.0f,  7.0f,  6.0f,  6.0f,  6.0f,  6.0f,  6.0f,   8.0f,
+	    6.0f,  6.0f,  6.0f,   7.0f,   6.0f,  6.0f,  6.0f,   7.5f,  6.0f,  6.0f,  4.0f,  6.0f,  3.0f,  6.0f,   6.0f,
+	    1.0f,  9.0f,  7.0f,   8.0f,   7.0f,  8.0f,  6.0f,   6.0f,  6.0f,  6.0f,  6.0f,  8.0f,
+	};
+
+	const auto size = sizeof(male_height) / sizeof(male_height[0]);
+
+	if (race >= size)
+		return 6.0f;
+
+	if (gender == 1)
+		return female_height[race];
+
+	return male_height[race];
+}
 
 // PlayerAppearance prep
 #define HUMAN_MALE ((HUMAN << 8) | MALE)

common/rulesys.cpp

@@ -237,7 +237,7 @@ 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);
@@ -253,12 +253,17 @@ bool RuleManager::LoadRules(Database *database, const char *ruleset_name) {
 		std::string default_ruleset_name = "default";
 		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.",
+			    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;
@@ -295,18 +300,22 @@ void RuleManager::_SaveRule(Database *database, RuleType type, uint16 index) {
 			break;
 	}
 
-	std::string query = StringFormat("REPLACE INTO rule_values "
+	std::string query = StringFormat(
+			"REPLACE INTO rule_values "
 			"(ruleset_id, rule_name, rule_value) "
 			" VALUES(%d, '%s', '%s')",
-                                    m_activeRuleset, _GetRuleName(type, index), value_string);
+			m_activeRuleset,
-    auto results = database->QueryDatabase(query);
+			_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

@@ -44,6 +44,7 @@ RULE_INT(Character, DeathExpLossMaxLevel, 255)	// Any level greater than this wi
 RULE_INT(Character, DeathItemLossLevel, 10)
 RULE_INT(Character, DeathExpLossMultiplier, 3) //Adjust how much exp is lost
 RULE_BOOL(Character, UseDeathExpLossMult, false) //Adjust to use the above multiplier or to use code default.
+RULE_BOOL(Character, UseOldRaceRezEffects, false) // older clients had ID 757 for races with high starting STR, but it doesn't seem used anymore
 RULE_INT(Character, CorpseDecayTimeMS, 10800000)
 RULE_INT(Character, CorpseResTimeMS, 10800000) // time before cant res corpse(3 hours)
 RULE_BOOL(Character, LeaveCorpses, true)
@@ -66,11 +67,12 @@ RULE_INT(Character, AutosaveIntervalS, 300)	//0=disabled
 RULE_INT(Character, HPRegenMultiplier, 100)
 RULE_INT(Character, ManaRegenMultiplier, 100)
 RULE_INT(Character, EnduranceRegenMultiplier, 100)
+RULE_BOOL(Character, OldMinMana, false) // this is used for servers that want to follow older skill cap formulas so they can still have some regen w/o mediate
 RULE_INT(Character, ConsumptionMultiplier, 100) //item's hunger restored = this value * item's food level, 100 = normal, 50 = people eat 2x as fast, 200 = people eat 2x as slow
 RULE_BOOL(Character, HealOnLevel, false)
 RULE_BOOL(Character, FeignKillsPet, false)
 RULE_INT(Character, ItemManaRegenCap, 15)
-RULE_INT(Character, ItemHealthRegenCap, 35)
+RULE_INT(Character, ItemHealthRegenCap, 30)
 RULE_INT(Character, ItemDamageShieldCap, 30)
 RULE_INT(Character, ItemAccuracyCap, 150)
 RULE_INT(Character, ItemAvoidanceCap, 100)
@@ -91,10 +93,12 @@ RULE_INT(Character, HasteCap, 100) // Haste cap for non-v3(overhaste) haste.
 RULE_INT(Character, SkillUpModifier, 100) //skill ups are at 100%
 RULE_BOOL(Character, SharedBankPlat, false) //off by default to prevent duping for now
 RULE_BOOL(Character, BindAnywhere, false)
-RULE_INT(Character, RestRegenPercent, 0) // Set to >0 to enable rest state bonus HP and mana regen.
+RULE_BOOL(Character, RestRegenEnabled, true) // Enable OOC Regen
+RULE_INT(Character, RestRegenHP, 180) // seconds until full from 0. this is actually zone setable, but most or all zones are 180
+RULE_INT(Character, RestRegenMana, 180) // seconds until full from 0. this is actually zone setable, but most or all zones are 180
+RULE_INT(Character, RestRegenEnd, 180) // seconds until full from 0. this is actually zone setable, but most or all zones are 180
 RULE_INT(Character, RestRegenTimeToActivate, 30) // Time in seconds for rest state regen to kick in.
 RULE_INT(Character, RestRegenRaidTimeToActivate, 300) // Time in seconds for rest state regen to kick in with a raid target.
-RULE_BOOL(Character, RestRegenEndurance, false) // Whether rest regen will work for endurance or not.
 RULE_INT(Character, KillsPerGroupLeadershipAA, 250) // Number of dark blues or above per Group Leadership AA
 RULE_INT(Character, KillsPerRaidLeadershipAA, 250) // Number of dark blues or above per Raid Leadership AA
 RULE_INT(Character, MaxFearDurationForPlayerCharacter, 4) //4 tics, each tic calculates every 6 seconds.
@@ -117,7 +121,8 @@ RULE_BOOL(Character, EnableDiscoveredItems, true) // If enabled, it enables EVEN
 RULE_BOOL(Character, EnableXTargetting, true) // Enable Extended Targetting Window, for users with UF and later clients.
 RULE_BOOL(Character, EnableAggroMeter, true) // Enable Aggro Meter, for users with RoF and later clients.
 RULE_BOOL(Character, KeepLevelOverMax, false) // Don't delevel a character that has somehow gone over the level cap
-RULE_INT(Character, FoodLossPerUpdate, 35) // How much food/water you lose per stamina update
+RULE_INT(Character, FoodLossPerUpdate, 32) // How much food/water you lose per stamina update
+RULE_BOOL(Character, EnableHungerPenalties, false) // being hungry/thirsty has negative effects -- it does appear normal live servers do not have penalties
 RULE_INT(Character, BaseInstrumentSoftCap, 36) // Softcap for instrument mods, 36 commonly referred to as "3.6" as well.
 RULE_BOOL(Character, UseSpellFileSongCap, true) // When they removed the AA that increased the cap they removed the above and just use the spell field
 RULE_INT(Character, BaseRunSpeedCap, 158) // Base Run Speed Cap, on live it's 158% which will give you a runspeed of 1.580 hard capped to 225.
@@ -152,6 +157,8 @@ RULE_BOOL(Character, GrantHoTTOnCreate, false) // Grant Health of Target's Targe
 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)
@@ -187,12 +194,14 @@ RULE_INT(Skills, MaxTrainSpecializations, 50)	// Max level a GM trainer will tra
 RULE_INT(Skills, SwimmingStartValue, 100)
 RULE_BOOL(Skills, TrainSenseHeading, false)
 RULE_INT(Skills, SenseHeadingStartValue, 200)
+RULE_BOOL(Skills, SelfLanguageLearning, true)
 RULE_CATEGORY_END()
 
 RULE_CATEGORY(Pets)
 RULE_REAL(Pets, AttackCommandRange, 150)
 RULE_BOOL(Pets, UnTargetableSwarmPet, false)
 RULE_REAL(Pets, PetPowerLevelCap, 10) // Max number of levels your pet can go up with pet power
+RULE_BOOL(Pets, CanTakeNoDrop, false) // Can everyone trade nodrop gear to pets
 RULE_CATEGORY_END()
 
 RULE_CATEGORY(GM)
@@ -227,6 +236,7 @@ RULE_INT(World, TitaniumStartZoneID, -1) //Sets the Starting Zone for Titanium C
 RULE_INT(World, ExpansionSettings, 16383) // Sets the expansion settings for the server, This is sent on login to world and affects client expansion settings. Defaults to all expansions enabled up to TSS.
 RULE_BOOL(World, UseClientBasedExpansionSettings, true) // if true it will overrule World, ExpansionSettings and set someone's expansion based on the client they're using
 RULE_INT(World, PVPSettings, 0) // Sets the PVP settings for the server, 1 = Rallos Zek RuleSet, 2 = Tallon/Vallon Zek Ruleset, 4 = Sullon Zek Ruleset, 6 = Discord Ruleset, anything above 6 is the Discord Ruleset without the no-drop restrictions removed. TODO: Edit IsAttackAllowed in Zone to accomodate for these rules.
+RULE_INT(World, PVPMinLevel, 0) // minimum level to pvp
 RULE_BOOL (World, IsGMPetitionWindowEnabled, false)
 RULE_INT (World, FVNoDropFlag, 0) // Sets the Firiona Vie settings on the client. If set to 2, the flag will be set for GMs only, allowing trading of no-drop items.
 RULE_BOOL (World, IPLimitDisconnectAll, false)
@@ -269,17 +279,10 @@ RULE_INT(Zone, GlobalLootMultiplier, 1) // Sets Global Loot drop multiplier for
 RULE_CATEGORY_END()
 
 RULE_CATEGORY(Map)
-//enable these to help prevent mob hopping when they are pathing
-RULE_BOOL(Map, FixPathingZWhenLoading, true)		//increases zone boot times a bit to reduce hopping.
-RULE_BOOL(Map, FixPathingZAtWaypoints, false)	//alternative to `WhenLoading`, accomplishes the same thing but does it at each waypoint instead of once at boot time.
-RULE_BOOL(Map, FixPathingZWhenMoving, false)		//very CPU intensive, but helps hopping with widely spaced waypoints.
 RULE_BOOL(Map, FixPathingZOnSendTo, false)		//try to repair Z coords in the SendTo routine as well.
 RULE_BOOL(Map, FixZWhenMoving, true)		// Automatically fix NPC Z coordinates when moving/pathing/engaged (Far less CPU intensive than its predecessor)
 RULE_BOOL(Map, MobZVisualDebug, false)		// Displays spell effects determining whether or not NPC is hitting Best Z calcs (blue for hit, red for miss)
-RULE_REAL(Map, FixPathingZMaxDeltaMoving, 20)	//at runtime while pathing: max change in Z to allow the BestZ code to apply.
-RULE_REAL(Map, FixPathingZMaxDeltaWaypoint, 20)	//at runtime at each waypoint: max change in Z to allow the BestZ code to apply.
 RULE_REAL(Map, FixPathingZMaxDeltaSendTo, 20)	//at runtime in SendTo: max change in Z to allow the BestZ code to apply.
-RULE_REAL(Map, FixPathingZMaxDeltaLoading, 45)	//while loading each waypoint: max change in Z to allow the BestZ code to apply.
 RULE_INT(Map, FindBestZHeightAdjust, 1)		// Adds this to the current Z before seeking the best Z position
 RULE_CATEGORY_END()
 
@@ -401,6 +404,7 @@ RULE_BOOL(Spells, IgnoreSpellDmgLvlRestriction, false) // ignore the 5 level spr
 RULE_BOOL(Spells, AllowItemTGB, false) // TGB doesn't work with items on live, custom servers want it though
 RULE_BOOL(Spells, NPCInnateProcOverride, true) //  NPC innate procs override the target type to single target.
 RULE_BOOL(Spells, OldRainTargets, false) // use old incorrectly implemented max targets for rains
+RULE_BOOL(Spells, NPCSpellPush, false) // enable spell push on NPCs
 RULE_CATEGORY_END()
 
 RULE_CATEGORY(Combat)
@@ -503,6 +507,7 @@ RULE_INT(Combat, NPCAssistCapTimer, 6000) // Time in milliseconds a NPC will tak
 RULE_BOOL(Combat, UseRevampHandToHand, false) // use h2h revamped dmg/delays I believe this was implemented during SoF
 RULE_BOOL(Combat, ClassicMasterWu, false) // classic master wu uses a random special, modern doesn't
 RULE_INT(Combat, LevelToStopDamageCaps, 0) // 1 will effectively disable them, 20 should give basically same results as old incorrect system
+RULE_BOOL(Combat, ClassicNPCBackstab, false) // true disables npc facestab - npcs get normal attack if not behind
 RULE_CATEGORY_END()
 
 RULE_CATEGORY(NPC)
@@ -511,6 +516,7 @@ RULE_INT(NPC, MajorNPCCorpseDecayTimeMS, 1500000) //level>=55
 RULE_INT(NPC, CorpseUnlockTimer, 150000)
 RULE_INT(NPC, EmptyNPCCorpseDecayTimeMS, 0)
 RULE_BOOL(NPC, UseItemBonusesForNonPets, true)
+RULE_BOOL(NPC, UseBaneDamage, false)
 RULE_INT(NPC, SayPauseTimeInSec, 5)
 RULE_INT(NPC, OOCRegen, 0)
 RULE_BOOL(NPC, BuffFriends, false)
@@ -543,6 +549,8 @@ RULE_INT(Aggro, IntAggroThreshold, 75) // Int <= this will aggro regardless of l
 RULE_BOOL(Aggro, AllowTickPulling, false) // tick pulling is an exploit in an NPC's call for help fixed sometime in 2006 on live
 RULE_BOOL(Aggro, UseLevelAggro, true) // Level 18+ and Undead will aggro regardless of level difference. (this will disabled Rule:IntAggroThreshold if set to true)
 RULE_INT(Aggro, ClientAggroCheckInterval, 6) // Interval in which clients actually check for aggro - in seconds
+RULE_REAL(Aggro, PetAttackRange, 40000.0) // max squared range /pet attack works at default is 200
+RULE_BOOL(Aggro, NPCAggroMaxDistanceEnabled, true) /* If enabled, NPC's will drop aggro beyond 600 units or what is defined at the zone level */
 RULE_CATEGORY_END()
 
 RULE_CATEGORY(TaskSystem)
@@ -594,6 +602,9 @@ RULE_BOOL(Bots, BotLevelsWithOwner, false) // Auto-updates spawned bots as owner
 RULE_BOOL(Bots, BotCharacterLevelEnabled, false) // Enables required level to spawn bots
 RULE_INT(Bots, BotCharacterLevel, 0) // 0 as default (if level > this value you can spawn bots if BotCharacterLevelEnabled is true)
 RULE_INT(Bots, CasterStopMeleeLevel, 13) // Level at which caster bots stop melee attacks
+RULE_INT(Bots, AllowedClasses, 0xFFFFFFFF) // Bitmask of allowed bot classes
+RULE_INT(Bots, AllowedRaces, 0xFFFFFFFF) // Bitmask of allowed bot races
+RULE_INT(Bots, AllowedGenders, 0x3) // Bitmask of allowed bot genders
 RULE_CATEGORY_END()
 #endif
 
@@ -669,6 +680,12 @@ RULE_CATEGORY_END()
 RULE_CATEGORY(AA)
 RULE_INT(AA, ExpPerPoint, 23976503)	//Amount of exp per AA. Is the same as the amount of exp to go from level 51 to level 52.
 RULE_BOOL(AA, Stacking, true) //Allow AA that belong to the same group to stack on SOF+ clients.
+RULE_BOOL(AA, NormalizedAAEnabled, false) // TSS+ change to AA that normalizes AA XP to a fixed # of white con kills independent of level.
+RULE_INT(AA, NormalizedAANumberOfWhiteConPerAA, 25) // The number of white con kills per AA point.
+RULE_BOOL(AA, ModernAAScalingEnabled, false) // Are we linearly scaling AA XP based on total # of earned AA?
+RULE_REAL(AA, ModernAAScalingStartPercent, 1000) // 1000% or 10x AA XP at the start of the scaling range
+RULE_INT(AA, ModernAAScalingAAMinimum, 0) // The minimum number of earned AA before AA XP scaling begins.
+RULE_INT(AA, ModernAAScalingAALimit, 4000) // The number of earned AA when AA XP scaling ends
 RULE_CATEGORY_END()
 
 RULE_CATEGORY(Console)
@@ -714,6 +731,12 @@ RULE_BOOL(Client, UseLiveFactionMessage, false) // Allows players to see faction
 RULE_BOOL(Client, UseLiveBlockedMessage, false) // Allows players to see faction adjustments like Live
 RULE_CATEGORY_END()
 
+RULE_CATEGORY(Bugs)
+RULE_BOOL(Bugs, ReportingSystemActive, true) // Activates bug reporting
+RULE_BOOL(Bugs, UseOldReportingMethod, true) // Forces the use of the old bug reporting system
+RULE_BOOL(Bugs, DumpTargetEntity, false) // Dumps the target entity, if one is provided
+RULE_CATEGORY_END()
+
 #undef RULE_CATEGORY
 #undef RULE_INT
 #undef RULE_REAL

common/say_link.cpp

@@ -29,10 +29,10 @@
 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::legacy::TEXT_LINK_BODY_LENGTH)
+	if (say_link_body.length() != EQEmu::constants::SAY_LINK_BODY_SIZE)
 		return false;
 
-	say_link_body_struct.unknown_1 = (uint8)strtol(say_link_body.substr(0, 1).c_str(), nullptr, 16);
+	say_link_body_struct.action_id = (uint8)strtol(say_link_body.substr(0, 1).c_str(), nullptr, 16);
 	say_link_body_struct.item_id = (uint32)strtol(say_link_body.substr(1, 5).c_str(), nullptr, 16);
 	say_link_body_struct.augment_1 = (uint32)strtol(say_link_body.substr(6, 5).c_str(), nullptr, 16);
 	say_link_body_struct.augment_2 = (uint32)strtol(say_link_body.substr(11, 5).c_str(), nullptr, 16);
@@ -44,7 +44,7 @@ bool EQEmu::saylink::DegenerateLinkBody(SayLinkBody_Struct& say_link_body_struct
 	say_link_body_struct.evolve_group = (uint32)strtol(say_link_body.substr(37, 4).c_str(), nullptr, 16);
 	say_link_body_struct.evolve_level = (uint8)strtol(say_link_body.substr(41, 2).c_str(), nullptr, 16);
 	say_link_body_struct.ornament_icon = (uint32)strtol(say_link_body.substr(43, 5).c_str(), nullptr, 16);
-	say_link_body_struct.hash = (int)strtol(say_link_body.substr(48, 8).c_str(), nullptr, 16);
+	say_link_body_struct.hash = (uint32)strtol(say_link_body.substr(48, 8).c_str(), nullptr, 16);
 
 	return true;
 }
@@ -53,7 +53,7 @@ bool EQEmu::saylink::GenerateLinkBody(std::string& say_link_body, const SayLinkB
 {
 	say_link_body = StringFormat(
 		"%1X" "%05X" "%05X" "%05X" "%05X" "%05X" "%05X" "%05X" "%1X" "%04X" "%02X" "%05X" "%08X",
-		(0x0F & say_link_body_struct.unknown_1),
+		(0x0F & say_link_body_struct.action_id),
 		(0x000FFFFF & say_link_body_struct.item_id),
 		(0x000FFFFF & say_link_body_struct.augment_1),
 		(0x000FFFFF & say_link_body_struct.augment_2),
@@ -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::legacy::TEXT_LINK_BODY_LENGTH)
+	if (say_link_body.length() != EQEmu::constants::SAY_LINK_BODY_SIZE)
 		return false;
 
 	return true;
@@ -79,7 +79,7 @@ EQEmu::SayLinkEngine::SayLinkEngine()
 	Reset();
 }
 
-std::string EQEmu::SayLinkEngine::GenerateLink()
+const std::string& EQEmu::SayLinkEngine::GenerateLink()
 {
 	m_Link.clear();
 	m_LinkBody.clear();
@@ -88,18 +88,26 @@ std::string EQEmu::SayLinkEngine::GenerateLink()
 	generate_body();
 	generate_text();
 
-	if ((m_LinkBody.length() == EQEmu::legacy::TEXT_LINK_BODY_LENGTH) && (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() > 250)) {
+	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, "TextLink::GenerateLink() failed to generate a useable text link (LinkType: %i, Lengths: {link: %u, body: %u, text: %u})",
+		Log(Logs::General, Logs::Error, "SayLinkEngine::GenerateLink() failed to generate a useable say link");
-			m_LinkType, m_Link.length(), m_LinkBody.length(), m_LinkText.length());
+		Log(Logs::General, Logs::Error, ">> LinkType: %i, Lengths: {link: %u(%u), body: %u(%u), text: %u(%u)}",
+			m_LinkType,
+			m_Link.length(),
+			EQEmu::constants::SAY_LINK_MAXIMUM_SIZE,
+			m_LinkBody.length(),
+			EQEmu::constants::SAY_LINK_BODY_SIZE,
+			m_LinkText.length(),
+			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());
 	}
@@ -113,20 +121,10 @@ void EQEmu::SayLinkEngine::Reset()
 	m_ItemData = nullptr;
 	m_LootData = nullptr;
 	m_ItemInst = nullptr;
-	m_Proxy_unknown_1 = 0;
+
-	m_ProxyItemID = 0;
+	memset(&m_LinkBodyStruct, 0, sizeof(SayLinkBody_Struct));
-	m_ProxyAugment1ID = 0;
+	memset(&m_LinkProxyStruct, 0, sizeof(SayLinkProxy_Struct));
-	m_ProxyAugment2ID = 0;
+
-	m_ProxyAugment3ID = 0;
-	m_ProxyAugment4ID = 0;
-	m_ProxyAugment5ID = 0;
-	m_ProxyAugment6ID = 0;
-	m_ProxyIsEvolving = 0;
-	m_ProxyEvolveGroup = 0;
-	m_ProxyEvolveLevel = 0;
-	m_ProxyOrnamentIcon = 0;
-	m_ProxyHash = 0;
-	m_ProxyText = nullptr;
 	m_TaskUse = false;
 	m_Link.clear();
 	m_LinkBody.clear();
@@ -194,32 +192,32 @@ void EQEmu::SayLinkEngine::generate_body()
 		break;
 	}
 
-	if (m_Proxy_unknown_1)
+	if (m_LinkProxyStruct.action_id)
-		m_LinkBodyStruct.unknown_1 = m_Proxy_unknown_1;
+		m_LinkBodyStruct.action_id = m_LinkProxyStruct.action_id;
-	if (m_ProxyItemID)
+	if (m_LinkProxyStruct.item_id)
-		m_LinkBodyStruct.item_id = m_ProxyItemID;
+		m_LinkBodyStruct.item_id = m_LinkProxyStruct.item_id;
-	if (m_ProxyAugment1ID)
+	if (m_LinkProxyStruct.augment_1)
-		m_LinkBodyStruct.augment_1 = m_ProxyAugment1ID;
+		m_LinkBodyStruct.augment_1 = m_LinkProxyStruct.augment_1;
-	if (m_ProxyAugment2ID)
+	if (m_LinkProxyStruct.augment_2)
-		m_LinkBodyStruct.augment_2 = m_ProxyAugment2ID;
+		m_LinkBodyStruct.augment_2 = m_LinkProxyStruct.augment_2;
-	if (m_ProxyAugment3ID)
+	if (m_LinkProxyStruct.augment_3)
-		m_LinkBodyStruct.augment_3 = m_ProxyAugment3ID;
+		m_LinkBodyStruct.augment_3 = m_LinkProxyStruct.augment_3;
-	if (m_ProxyAugment4ID)
+	if (m_LinkProxyStruct.augment_4)
-		m_LinkBodyStruct.augment_4 = m_ProxyAugment4ID;
+		m_LinkBodyStruct.augment_4 = m_LinkProxyStruct.augment_4;
-	if (m_ProxyAugment5ID)
+	if (m_LinkProxyStruct.augment_5)
-		m_LinkBodyStruct.augment_5 = m_ProxyAugment5ID;
+		m_LinkBodyStruct.augment_5 = m_LinkProxyStruct.augment_5;
-	if (m_ProxyAugment6ID)
+	if (m_LinkProxyStruct.augment_6)
-		m_LinkBodyStruct.augment_6 = m_ProxyAugment6ID;
+		m_LinkBodyStruct.augment_6 = m_LinkProxyStruct.augment_6;
-	if (m_ProxyIsEvolving)
+	if (m_LinkProxyStruct.is_evolving)
-		m_LinkBodyStruct.is_evolving = m_ProxyIsEvolving;
+		m_LinkBodyStruct.is_evolving = m_LinkProxyStruct.is_evolving;
-	if (m_ProxyEvolveGroup)
+	if (m_LinkProxyStruct.evolve_group)
-		m_LinkBodyStruct.evolve_group = m_ProxyEvolveGroup;
+		m_LinkBodyStruct.evolve_group = m_LinkProxyStruct.evolve_group;
-	if (m_ProxyEvolveLevel)
+	if (m_LinkProxyStruct.evolve_level)
-		m_LinkBodyStruct.evolve_level = m_ProxyEvolveLevel;
+		m_LinkBodyStruct.evolve_level = m_LinkProxyStruct.evolve_level;
-	if (m_ProxyOrnamentIcon)
+	if (m_LinkProxyStruct.ornament_icon)
-		m_LinkBodyStruct.ornament_icon = m_ProxyOrnamentIcon;
+		m_LinkBodyStruct.ornament_icon = m_LinkProxyStruct.ornament_icon;
-	if (m_ProxyHash)
+	if (m_LinkProxyStruct.hash)
-		m_LinkBodyStruct.hash = m_ProxyHash;
+		m_LinkBodyStruct.hash = m_LinkProxyStruct.hash;
 
 
 	if (m_TaskUse)
@@ -227,7 +225,7 @@ void EQEmu::SayLinkEngine::generate_body()
 
 	m_LinkBody = StringFormat(
 		"%1X" "%05X" "%05X" "%05X" "%05X" "%05X" "%05X" "%05X" "%1X" "%04X" "%02X" "%05X" "%08X",
-		(0x0F & m_LinkBodyStruct.unknown_1),
+		(0x0F & m_LinkBodyStruct.action_id),
 		(0x000FFFFF & m_LinkBodyStruct.item_id),
 		(0x000FFFFF & m_LinkBodyStruct.augment_1),
 		(0x000FFFFF & m_LinkBodyStruct.augment_2),
@@ -245,8 +243,8 @@ void EQEmu::SayLinkEngine::generate_body()
 
 void EQEmu::SayLinkEngine::generate_text()
 {
-	if (m_ProxyText != nullptr) {
+	if (m_LinkProxyStruct.text != nullptr) {
-		m_LinkText = m_ProxyText;
+		m_LinkText = m_LinkProxyStruct.text;
 		return;
 	}
 

common/say_link.h

@@ -47,7 +47,7 @@ namespace EQEmu
 	} /*saylink*/
 
 	struct SayLinkBody_Struct {
-		uint8 unknown_1;		/* %1X */
+		uint8 action_id;		/* %1X */
 		uint32 item_id;			/* %05X */
 		uint32 augment_1;		/* %05X */
 		uint32 augment_2;		/* %05X */
@@ -56,13 +56,18 @@ namespace EQEmu
 		uint32 augment_5;		/* %05X */
 		uint32 augment_6;		/* %05X */
 		uint8 is_evolving;		/* %1X */
-		uint32 evolve_group;	/* %05X */
+		uint32 evolve_group;	/* %04X */
 		uint8 evolve_level;		/* %02X */
 		uint32 ornament_icon;	/* %05X */
-		int hash;				/* %08X */
+		uint32 hash;			/* %08X */
+	};
+
+	struct SayLinkProxy_Struct : SayLinkBody_Struct {
+		const char* text;
 	};
 
 	class SayLinkEngine {
+		// TODO: consider methods for direct 'saylink' assignments
 	public:
 		SayLinkEngine();
 
@@ -72,29 +77,29 @@ namespace EQEmu
 		void SetItemInst(const ItemInstance* item_inst) { m_ItemInst = item_inst; }
 
 		// mainly for saylinks..but, not limited to
-		void SetProxyUnknown1(uint8 proxy_unknown_1) { m_Proxy_unknown_1 = proxy_unknown_1; }
+		void SetProxyActionID(uint8 proxy_action_id) { m_LinkProxyStruct.action_id = proxy_action_id; } // should always be '0'
-		void SetProxyItemID(uint32 proxy_item_id) { m_ProxyItemID = proxy_item_id; }
+		void SetProxyItemID(uint32 proxy_item_id) { m_LinkProxyStruct.item_id = proxy_item_id; }
-		void SetProxyAugment1ID(uint32 proxy_augment_id) { m_ProxyAugment1ID = proxy_augment_id; }
+		void SetProxyAugment1ID(uint32 proxy_augment_id) { m_LinkProxyStruct.augment_1 = proxy_augment_id; }
-		void SetProxyAugment2ID(uint32 proxy_augment_id) { m_ProxyAugment2ID = proxy_augment_id; }
+		void SetProxyAugment2ID(uint32 proxy_augment_id) { m_LinkProxyStruct.augment_2 = proxy_augment_id; }
-		void SetProxyAugment3ID(uint32 proxy_augment_id) { m_ProxyAugment3ID = proxy_augment_id; }
+		void SetProxyAugment3ID(uint32 proxy_augment_id) { m_LinkProxyStruct.augment_3 = proxy_augment_id; }
-		void SetProxyAugment4ID(uint32 proxy_augment_id) { m_ProxyAugment4ID = proxy_augment_id; }
+		void SetProxyAugment4ID(uint32 proxy_augment_id) { m_LinkProxyStruct.augment_4 = proxy_augment_id; }
-		void SetProxyAugment5ID(uint32 proxy_augment_id) { m_ProxyAugment5ID = proxy_augment_id; }
+		void SetProxyAugment5ID(uint32 proxy_augment_id) { m_LinkProxyStruct.augment_5 = proxy_augment_id; }
-		void SetProxyAugment6ID(uint32 proxy_augment_id) { m_ProxyAugment6ID = proxy_augment_id; }
+		void SetProxyAugment6ID(uint32 proxy_augment_id) { m_LinkProxyStruct.augment_6 = proxy_augment_id; }
-		void SetProxyIsEvolving(uint8 proxy_is_evolving) { m_ProxyIsEvolving = proxy_is_evolving; }
+		void SetProxyIsEvolving(uint8 proxy_is_evolving) { m_LinkProxyStruct.is_evolving = proxy_is_evolving; }
-		void SetProxyEvolveGroup(uint32 proxy_evolve_group) { m_ProxyEvolveGroup = proxy_evolve_group; }
+		void SetProxyEvolveGroup(uint32 proxy_evolve_group) { m_LinkProxyStruct.evolve_group = proxy_evolve_group; }
-		void SetProxyEvolveLevel(uint8 proxy_evolve_level) { m_ProxyEvolveLevel = proxy_evolve_level; }
+		void SetProxyEvolveLevel(uint8 proxy_evolve_level) { m_LinkProxyStruct.evolve_level = proxy_evolve_level; }
-		void SetProxyOrnamentIcon(uint32 proxy_ornament_icon) { m_ProxyOrnamentIcon = proxy_ornament_icon; }
+		void SetProxyOrnamentIcon(uint32 proxy_ornament_icon) { m_LinkProxyStruct.ornament_icon = proxy_ornament_icon; }
-		void SetProxyHash(int proxy_hash) { m_ProxyHash = proxy_hash; }
+		void SetProxyHash(uint32 proxy_hash) { m_LinkProxyStruct.hash = proxy_hash; }
 
-		void SetProxyText(const char* proxy_text) { m_ProxyText = proxy_text; } // overrides standard text use
+		void SetProxyText(const char* proxy_text) { m_LinkProxyStruct.text = proxy_text; } // overrides standard text use
 		void SetTaskUse() { m_TaskUse = true; }
 
-		std::string GenerateLink();
+		const std::string& GenerateLink();
 		bool LinkError() { return m_Error; }
 
-		std::string Link() { return m_Link; }			// contains full string format: '/12x' '<LinkBody>' '<LinkText>' '/12x'
+		const std::string& Link() { return m_Link; }			// contains full string format: '\x12' '<LinkBody>' '<LinkText>' '\x12'
-		std::string LinkBody() { return m_LinkBody; }	// contains string format: '<LinkBody>'
+		const std::string& LinkBody() { return m_LinkBody; }	// contains string format: '<LinkBody>'
-		std::string LinkText() { return m_LinkText; }	// contains string format: '<LinkText>'
+		const std::string& LinkText() { return m_LinkText; }	// contains string format: '<LinkText>'
 
 		void Reset();
 
@@ -106,23 +111,9 @@ namespace EQEmu
 		const ItemData* m_ItemData;
 		const ServerLootItem_Struct* m_LootData;
 		const ItemInstance* m_ItemInst;
-
-		uint8 m_Proxy_unknown_1;
-		uint32 m_ProxyItemID;
-		uint32 m_ProxyAugment1ID;
-		uint32 m_ProxyAugment2ID;
-		uint32 m_ProxyAugment3ID;
-		uint32 m_ProxyAugment4ID;
-		uint32 m_ProxyAugment5ID;
-		uint32 m_ProxyAugment6ID;
-		uint8 m_ProxyIsEvolving;
-		uint32 m_ProxyEvolveGroup;
-		uint8 m_ProxyEvolveLevel;
-		uint32 m_ProxyOrnamentIcon;
-		int m_ProxyHash;
-		const char* m_ProxyText;
-		bool m_TaskUse;
 		SayLinkBody_Struct m_LinkBodyStruct;
+		SayLinkProxy_Struct m_LinkProxyStruct;
+		bool m_TaskUse;
 		std::string m_Link;
 		std::string m_LinkBody;
 		std::string m_LinkText;

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

@@ -190,6 +190,8 @@
 #define ServerOP_ReloadLogs 0x4010
 #define ServerOP_ReloadPerlExportSettings	0x4011
 #define ServerOP_CZSetEntityVariableByClientName 0x4012
+#define ServerOP_UCSServerStatusRequest		0x4013
+#define ServerOP_UCSServerStatusReply		0x4014
 /* Query Server OP Codes */
 #define ServerOP_QSPlayerLogTrades					0x5010
 #define ServerOP_QSPlayerLogHandins					0x5011
@@ -1278,6 +1280,17 @@ struct ServerRequestTellQueue_Struct {
 	char	name[64];
 };
 
+struct UCSServerStatus_Struct {
+	uint8 available; // non-zero=true, 0=false
+	union {
+		struct {
+			uint16 port;
+			uint16 unused;
+		};
+		uint32 timestamp;
+	};
+};
+
 #pragma pack()
 
 #endif

common/shareddb.cpp

@@ -110,14 +110,49 @@ uint32 SharedDatabase::GetTotalTimeEntitledOnAccount(uint32 AccountID) {
 	return EntitledTime;
 }
 
+void SharedDatabase::SetMailKey(int CharID, int IPAddress, int MailKey)
+{
+	char MailKeyString[17];
+
+	if (RuleB(Chat, EnableMailKeyIPVerification) == true)
+		sprintf(MailKeyString, "%08X%08X", IPAddress, MailKey);
+	else
+		sprintf(MailKeyString, "%08X", MailKey);
+
+	std::string query = StringFormat("UPDATE character_data SET mailkey = '%s' WHERE id = '%i'",
+		MailKeyString, CharID);
+	auto results = QueryDatabase(query);
+	if (!results.Success())
+		Log(Logs::General, Logs::Error, "SharedDatabase::SetMailKey(%i, %s) : %s", CharID, MailKeyString, results.ErrorMessage().c_str());
+
+}
+
+std::string SharedDatabase::GetMailKey(int CharID, bool key_only)
+{
+	std::string query = StringFormat("SELECT `mailkey` FROM `character_data` WHERE `id`='%i' LIMIT 1", CharID);
+	auto results = QueryDatabase(query);
+	if (!results.Success()) {
+		Log(Logs::Detail, Logs::MySQLError, "Error retrieving mailkey from database: %s", results.ErrorMessage().c_str());
+		return std::string();
+	}
+
+	auto row = results.begin();
+	std::string mail_key = row[0];
+
+	if (mail_key.length() > 8 && key_only)
+		return mail_key.substr(8);
+	else
+		return mail_key;
+}
+
 bool SharedDatabase::SaveCursor(uint32 char_id, std::list<EQEmu::ItemInstance*>::const_iterator &start, std::list<EQEmu::ItemInstance*>::const_iterator &end)
 {
 	// Delete cursor items
 	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;
@@ -128,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;
 		}
@@ -173,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);
@@ -203,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;
 		}
@@ -235,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));
 		}
@@ -250,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;
 		}
@@ -281,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));
 		}
@@ -307,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);
@@ -333,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));
@@ -439,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]);
@@ -460,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]);
 			}
@@ -535,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]);
@@ -597,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);
 
@@ -620,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]);
 			}
@@ -677,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]);
@@ -738,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]);
 			}
@@ -1817,8 +1854,8 @@ void SharedDatabase::LoadBaseData(void *data, int max_level) {
 		bd->base_hp = atof(row[2]);
 		bd->base_mana = atof(row[3]);
 		bd->base_end = atof(row[4]);
-		bd->unk1 = atof(row[5]);
+		bd->hp_regen = atof(row[5]);
-		bd->unk2 = atof(row[6]);
+		bd->end_regen = atof(row[6]);
 		bd->hp_factor = atof(row[7]);
 		bd->mana_factor = atof(row[8]);
 		bd->endurance_factor = atof(row[9]);

common/shareddb.h

@@ -72,6 +72,8 @@ class SharedDatabase : public Database
 		void	SaveCharacterInspectMessage(uint32 character_id, const InspectMessage_Struct* message);
 		bool	GetCommandSettings(std::map<std::string, std::pair<uint8, std::vector<std::string>>> &command_settings);
 		uint32	GetTotalTimeEntitledOnAccount(uint32 AccountID);
+		void	SetMailKey(int CharID, int IPAddress, int MailKey);
+		std::string	GetMailKey(int CharID, bool key_only = false);
 
 		/*
 		    Character InventoryProfile

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

@@ -73,6 +73,8 @@ enum SpellTypes : uint32
 	SpellTypes_Detrimental = (SpellType_Nuke | SpellType_Root | SpellType_Lifetap | SpellType_Snare | SpellType_DOT | SpellType_Dispel | SpellType_Mez | SpellType_Charm | SpellType_Debuff | SpellType_Slow),
 	SpellTypes_Beneficial = (SpellType_Heal | SpellType_Buff | SpellType_Escape | SpellType_Pet | SpellType_InCombatBuff | SpellType_Cure | SpellType_HateRedux | SpellType_InCombatBuffSong | SpellType_OutOfCombatBuffSong | SpellType_PreCombatBuff | SpellType_PreCombatBuffSong),
 
+	SpellTypes_Innate = (SpellType_Nuke | SpellType_Lifetap | SpellType_DOT | SpellType_Dispel | SpellType_Mez | SpellType_Slow | SpellType_Debuff | SpellType_Charm | SpellType_Root),
+
 	SpellType_Any = 0xFFFFFFFF
 };
 
@@ -131,6 +133,11 @@ enum SpellAffectIndex {
 	SAI_NPC_Special_80			= 80,
 	SAI_Trap_Lock				= 88
 };
+
+enum class GlobalGroup {
+	Lich = 46,
+};
+
 enum RESISTTYPE
 {
 	RESIST_NONE = 0,
@@ -965,7 +972,6 @@ bool IsCastWhileInvis(uint16 spell_id);
 bool IsEffectIgnoredInStacking(int spa);
 
 int CalcPetHp(int levelb, int classb, int STA = 75);
-const char *GetRandPetName();
 int GetSpellEffectDescNum(uint16 spell_id);
 DmgShieldType GetDamageShieldType(uint16 spell_id, int32 DSType = 0);
 bool DetrimentalSpellAllowsRest(uint16 spell_id);

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)
 			return 0;
 		else
 			return (start_time + timer_time) - current_time;
-	}
+	} else {
-	else {
 		return 0xFFFFFFFF;
 	}
 }

common/timer.h

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

common/useperl.h

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

common/version.h

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

libs/format/fmt/format.h

@@ -1886,6 +1886,8 @@ FMT_DEFINE_INT_FORMATTERS(unsigned long)
 FMT_DEFINE_INT_FORMATTERS(LongLong)
 FMT_DEFINE_INT_FORMATTERS(ULongLong)
 
+#define CHAR_WIDTH 1
+
 /**
   \rst
   Returns a string formatter that pads the formatted argument with the fill

libs/recast/detour/src/DetourNavMeshQuery.cpp

@@ -1096,7 +1096,9 @@ dtStatus dtNavMeshQuery::findPath(dtPolyRef startRef, dtPolyRef endRef,
 			// The API input has been cheked already, skip checking internal data.
 			const dtMeshTile* neighbourTile = 0;
 			const dtPoly* neighbourPoly = 0;
-			m_nav->getTileAndPolyByRefUnsafe(neighbourRef, &neighbourTile, &neighbourPoly);			
+			if (dtStatusFailed(m_nav->getTileAndPolyByRef(neighbourRef, &neighbourTile, &neighbourPoly))) {
+				continue;
+			}		
 			
 			if (!filter->passFilter(neighbourRef, neighbourTile, neighbourPoly))
 				continue;

libs/sol/sol_forward.hpp

@@ -0,0 +1,366 @@
+// The MIT License (MIT)
+
+// Copyright (c) 2013-2018 Rapptz, ThePhD and contributors
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy of
+// this software and associated documentation files (the "Software"), to deal in
+// the Software without restriction, including without limitation the rights to
+// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+// the Software, and to permit persons to whom the Software is furnished to do so,
+// subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// This file was generated with a script.
+// Generated 2018-06-16 11:58:58.882218 UTC
+// This header was generated with sol v2.20.3 (revision 968989b)
+// https://github.com/ThePhD/sol2
+
+#ifndef SOL_SINGLE_INCLUDE_FORWARD_HPP
+#define SOL_SINGLE_INCLUDE_FORWARD_HPP
+
+// beginning of sol/forward.hpp
+
+// beginning of sol/feature_test.hpp
+
+#if (defined(__cplusplus) && __cplusplus == 201703L) || (defined(_MSC_VER) && _MSC_VER > 1900 && ((defined(_HAS_CXX17) && _HAS_CXX17 == 1) || (defined(_MSVC_LANG) && (_MSVC_LANG > 201402L))))
+#ifndef SOL_CXX17_FEATURES
+#define SOL_CXX17_FEATURES 1
+#endif // C++17 features macro
+#endif // C++17 features check
+
+#if defined(SOL_CXX17_FEATURES) && SOL_CXX17_FEATURES
+#if defined(__cpp_noexcept_function_type) || ((defined(_MSC_VER) && _MSC_VER > 1911) && (defined(_MSVC_LANG) && ((_MSVC_LANG >= 201403L))))
+#ifndef SOL_NOEXCEPT_FUNCTION_TYPE
+#define SOL_NOEXCEPT_FUNCTION_TYPE 1
+#endif // noexcept is part of a function's type
+#endif // compiler-specific checks
+#if defined(__clang__) && defined(__APPLE__)
+#if defined(__has_include)
+#if __has_include(<variant>)
+#define SOL_STD_VARIANT 1
+#endif // has include nonsense
+#endif // __has_include
+#else
+#define SOL_STD_VARIANT 1
+#endif // Clang screws up variant
+#endif // C++17 only
+
+// beginning of sol/config.hpp
+
+#ifdef _MSC_VER
+	#if defined(_DEBUG) && !defined(NDEBUG)
+
+	#ifndef SOL_IN_DEBUG_DETECTED
+	#define SOL_IN_DEBUG_DETECTED 1
+	#endif
+
+	#endif // VC++ Debug macros
+
+	#ifndef _CPPUNWIND
+	#ifndef SOL_NO_EXCEPTIONS
+	#define SOL_NO_EXCEPTIONS 1
+	#endif
+	#endif // Automatic Exceptions
+
+	#ifndef _CPPRTTI
+	#ifndef SOL_NO_RTTI
+	#define SOL_NO_RTTI 1
+	#endif
+	#endif // Automatic RTTI
+#elif defined(__GNUC__) || defined(__clang__)
+
+	#if !defined(NDEBUG) && !defined(__OPTIMIZE__)
+
+	#ifndef SOL_IN_DEBUG_DETECTED
+	#define SOL_IN_DEBUG_DETECTED 1
+	#endif
+
+	#endif // Not Debug && g++ optimizer flag
+
+	#ifndef __EXCEPTIONS
+	#ifndef SOL_NO_EXCEPTIONS
+	#define SOL_NO_EXCEPTIONS 1
+	#endif
+	#endif // No Exceptions
+
+	#ifndef __GXX_RTTI
+	#ifndef SOL_NO_RTII
+	#define SOL_NO_RTTI 1
+	#endif
+	#endif // No RTTI
+
+#endif // vc++ || clang++/g++
+
+#if defined(SOL_CHECK_ARGUMENTS) && SOL_CHECK_ARGUMENTS
+
+	// Checks low-level getter function
+	// (and thusly, affects nearly entire framework)
+	#if !defined(SOL_SAFE_GETTER)
+	#define SOL_SAFE_GETTER 1
+	#endif
+
+	// Checks access on usertype functions
+	// local my_obj = my_type.new()
+	// my_obj.my_member_function()
+	// -- bad syntax and crash
+	#if !defined(SOL_SAFE_USERTYPE)
+	#define SOL_SAFE_USERTYPE 1
+	#endif
+
+	// Checks sol::reference derived boundaries
+	// sol::function ref(L, 1);
+	// sol::userdata sref(L, 2);
+	#if !defined(SOL_SAFE_REFERENCES)
+	#define SOL_SAFE_REFERENCES 1
+	#endif
+
+	// Changes all typedefs of sol::function to point to the 
+	// protected_function version, instead of unsafe_function
+	#if !defined(SOL_SAFE_FUNCTION)
+	#define SOL_SAFE_FUNCTION 1
+	#endif
+
+	// Checks function parameters and
+	// returns upon call into/from Lua
+	// local a = 1
+	// local b = "woof"
+	// my_c_function(a, b)
+	#if !defined(SOL_SAFE_FUNCTION_CALLS)
+	#define SOL_SAFE_FUNCTION_CALLS 1
+	#endif
+
+	// Checks conversions
+	// int v = lua["bark"];
+	// int v2 = my_sol_function();
+	#if !defined(SOL_SAFE_PROXIES)
+	#define SOL_SAFE_PROXIES 1
+	#endif
+
+	// Check overflowing number conversions
+	// for things like 64 bit integers that don't fit in a typical lua_Number
+	// for Lua 5.1 and 5.2
+	#if !defined(SOL_SAFE_NUMERICS)
+	#define SOL_SAFE_NUMERICS 1
+	#endif
+
+	// Turn off Number Precision Checks
+	// if this is defined, we do not do range 
+	// checks on integers / unsigned integers that might
+	// be bigger than what Lua can represent
+	#if !defined(SOL_NO_CHECK_NUMBER_PRECISION)
+	// off by default
+	#define SOL_NO_CHECK_NUMBER_PRECISION 0
+	#endif
+
+#endif // Turn on Safety for all if top-level macro is defined
+
+#if defined(SOL_IN_DEBUG_DETECTED) && SOL_IN_DEBUG_DETECTED
+
+	#if !defined(SOL_SAFE_REFERENCES)
+	// Ensure that references are forcefully type-checked upon construction
+	#define SOL_SAFE_REFERENCES 1
+	#endif
+
+	// Safe usertypes checks for errors such as
+	// obj = my_type.new()
+	// obj.f() -- note the '.' instead of ':'
+	// usertypes should be safe no matter what
+	#if !defined(SOL_SAFE_USERTYPE)
+	#define SOL_SAFE_USERTYPE 1
+	#endif
+
+	#if !defined(SOL_SAFE_FUNCTION_CALLS)
+	// Function calls from Lua should be automatically safe in debug mode
+	#define SOL_SAFE_FUNCTION_CALLS 1
+	#endif
+
+	// Print any exceptions / errors that occur
+	// in debug mode to the default error stream / console
+	#if !defined(SOL_PRINT_ERRORS)
+	#define SOL_PRINT_ERRORS 1
+	#endif
+
+#endif // DEBUG: Turn on all debug safety features for VC++ / g++ / clang++ and similar
+
+#if !defined(SOL_PRINT_ERRORS)
+#define SOL_PRINT_ERRORS 0
+#endif
+
+#if !defined(SOL_DEFAULT_PASS_ON_ERROR)
+#define SOL_DEFAULT_PASS_ON_ERROR 0
+#endif
+
+#if !defined(SOL_ENABLE_INTEROP)
+#define SOL_ENABLE_INTEROP 0
+#endif
+
+#if defined(__MAC_OS_X_VERSION_MAX_ALLOWED) || defined(__OBJC__) || defined(nil)
+#if !defined(SOL_NO_NIL)
+#define SOL_NO_NIL 1
+#endif
+#endif // avoiding nil defines / keywords
+
+#if defined(SOL_USE_BOOST) && SOL_USE_BOOST
+#ifndef SOL_UNORDERED_MAP_COMPATIBLE_HASH
+#define SOL_UNORDERED_MAP_COMPATIBLE_HASH 1
+#endif // SOL_UNORDERED_MAP_COMPATIBLE_HASH
+#endif 
+
+#ifndef SOL_STACK_STRING_OPTIMIZATION_SIZE
+#define SOL_STACK_STRING_OPTIMIZATION_SIZE 1024
+#endif // Optimized conversion routines using a KB or so off the stack
+
+// end of sol/config.hpp
+
+// beginning of sol/config_setup.hpp
+
+// end of sol/config_setup.hpp
+
+// end of sol/feature_test.hpp
+
+namespace sol {
+
+	template <bool b>
+	class basic_reference;
+	using reference = basic_reference<false>;
+	using main_reference = basic_reference<true>;
+	class stack_reference;
+
+	struct proxy_base_tag;
+	template <typename Super>
+	struct proxy_base;
+	template <typename Table, typename Key>
+	struct proxy;
+
+	template <typename T>
+	class usertype;
+	template <typename T>
+	class simple_usertype;
+	template <bool, typename T>
+	class basic_table_core;
+	template <bool b>
+	using table_core = basic_table_core<b, reference>;
+	template <bool b>
+	using main_table_core = basic_table_core<b, main_reference>;
+	template <bool b>
+	using stack_table_core = basic_table_core<b, stack_reference>;
+	template <typename T>
+	using basic_table = basic_table_core<false, T>;
+	typedef table_core<false> table;
+	typedef table_core<true> global_table;
+	typedef main_table_core<false> main_table;
+	typedef main_table_core<true> main_global_table;
+	typedef stack_table_core<false> stack_table;
+	typedef stack_table_core<true> stack_global_table;
+	template <typename base_t>
+	struct basic_environment;
+	using environment = basic_environment<reference>;
+	using main_environment = basic_environment<main_reference>;
+	using stack_environment = basic_environment<stack_reference>;
+	template <typename T, bool>
+	class basic_function;
+	template <typename T, bool, typename H>
+	class basic_protected_function;
+	using unsafe_function = basic_function<reference, false>;
+	using safe_function = basic_protected_function<reference, false, reference>;
+	using main_unsafe_function = basic_function<main_reference, false>;
+	using main_safe_function = basic_protected_function<main_reference, false, reference>;
+	using stack_unsafe_function = basic_function<stack_reference, false>;
+	using stack_safe_function = basic_protected_function<stack_reference, false, reference>;
+	using stack_aligned_unsafe_function = basic_function<stack_reference, true>;
+	using stack_aligned_safe_function = basic_protected_function<stack_reference, true, reference>;
+	using protected_function = safe_function;
+	using main_protected_function = main_safe_function;
+	using stack_protected_function = stack_safe_function;
+	using stack_aligned_protected_function = stack_aligned_safe_function;
+#if defined(SOL_SAFE_FUNCTION) && SOL_SAFE_FUNCTION
+	using function = protected_function;
+	using main_function = main_protected_function;
+	using stack_function = stack_protected_function;
+#else
+	using function = unsafe_function;
+	using main_function = main_unsafe_function;
+	using stack_function = stack_unsafe_function;
+#endif
+	using stack_aligned_function = stack_aligned_unsafe_function;
+	using stack_aligned_stack_handler_function = basic_protected_function<stack_reference, true, stack_reference>;
+
+	struct unsafe_function_result;
+	struct protected_function_result;
+	using safe_function_result = protected_function_result;
+#if defined(SOL_SAFE_FUNCTION) && SOL_SAFE_FUNCTION
+	using function_result = safe_function_result;
+#else
+	using function_result = unsafe_function_result;
+#endif
+
+	template <typename base_t>
+	class basic_object;
+	template <typename base_t>
+	class basic_userdata;
+	template <typename base_t>
+	class basic_lightuserdata;
+	template <typename base_t>
+	class basic_coroutine;
+	template <typename base_t>
+	class basic_thread;
+
+	using object = basic_object<reference>;
+	using userdata = basic_userdata<reference>;
+	using lightuserdata = basic_lightuserdata<reference>;
+	using thread = basic_thread<reference>;
+	using coroutine = basic_coroutine<reference>;
+	using main_object = basic_object<main_reference>;
+	using main_userdata = basic_userdata<main_reference>;
+	using main_lightuserdata = basic_lightuserdata<main_reference>;
+	using main_coroutine = basic_coroutine<main_reference>;
+	using stack_object = basic_object<stack_reference>;
+	using stack_userdata = basic_userdata<stack_reference>;
+	using stack_lightuserdata = basic_lightuserdata<stack_reference>;
+	using stack_thread = basic_thread<stack_reference>;
+	using stack_coroutine = basic_coroutine<stack_reference>;
+
+	struct stack_proxy_base;
+	struct stack_proxy;
+	struct variadic_args;
+	struct variadic_results;
+	struct stack_count;
+	struct this_state;
+	struct this_main_state;
+	struct this_environment;
+
+	template <typename T>
+	struct as_table_t;
+	template <typename T>
+	struct as_container_t;
+	template <typename T>
+	struct nested;
+	template <typename T>
+	struct light;
+	template <typename T>
+	struct user;
+	template <typename T>
+	struct as_args_t;
+	template <typename T>
+	struct protect_t;
+	template <typename F, typename... Filters>
+	struct filter_wrapper;
+
+	template <typename T>
+	struct usertype_traits;
+	template <typename T>
+	struct unique_usertype_traits;
+} // namespace sol
+
+// end of sol/forward.hpp
+
+#endif // SOL_SINGLE_INCLUDE_FORWARD_HPP

loginserver/database_mysql.cpp

@@ -36,7 +36,7 @@ DatabaseMySQL::DatabaseMySQL(std::string user, std::string pass, std::string hos
 	database = mysql_init(nullptr);
 	if (database)
 	{
-		my_bool r = 1;
+		char r = 1;
 		mysql_options(database, MYSQL_OPT_RECONNECT, &r);
 		if (!mysql_real_connect(database, host.c_str(), user.c_str(), pass.c_str(), name.c_str(), atoi(port.c_str()), nullptr, 0))
 		{