pa/eqemu-server
2
0
Fork 0
mirror of https://github.com/EQEmu/Server.git synced 2026-01-26 12:43:52 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #13 from EQEmu/master

Browse Source 
update
This commit is contained in:
regneq 2018-07-22 09:18:19 -07:00 committed by GitHub
commit 082641b1ad
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
414 changed files with 52823 additions and 39726 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
.gitignore vendored
View File

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

45
.travis.yml
View File

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

28
CMakeLists.txt
View File

@ -27,8 +27,6 @@
#EQEMU_USE_MAP_MMFS
#EQEMU_MAP_DIR
#We set a fairly new version (as of 2013) because I found finding perl was a bit... buggy on older ones
#Can change this if you really want but you should upgrade!
CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
#FindMySQL is located here so lets make it so CMake can find it
@ -42,6 +40,8 @@ IF(NOT CMAKE_BUILD_TYPE)
SET(CMAKE_BUILD_TYPE RelWithDebInfo CACHE STRING "Choose the type of build." FORCE)
ENDIF(NOT CMAKE_BUILD_TYPE)
SET(CMAKE_PREFIX_PATH "${CMAKE_CURRENT_SOURCE_DIR}/dependencies" "${CMAKE_PREFIX_PATH}")
#Add our various windows definitions
IF(MSVC OR MINGW)
ADD_DEFINITIONS(-D_WINDOWS)
@ -53,7 +53,6 @@ IF(MSVC OR MINGW)
ENDIF(MSVC OR MINGW)
IF(MSVC)
#Set our default locations for zlib/mysql based on x86/x64
IF(CMAKE_CL_64)
SET(ZLIB_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/zlib_x64")
SET(MYSQL_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/mysql_x64")
@ -100,23 +99,6 @@ IF(MSVC)
ADD_DEFINITIONS(-DCRASH_LOGGING)
ENDIF(EQEMU_ENABLE_CRASH_LOGGING)
#Disable safe SEH or not?
OPTION(EQEMU_DISABLE_SAFESEH "Disable Safe SEH (Needed for Strawberry Perl)" OFF)
IF(EQEMU_DISABLE_SAFESEH)
SET(CMAKE_EXE_LINKER_FLAGS_DEBUG "${CMAKE_EXE_LINKER_FLAGS_DEBUG} /SAFESEH:NO")
SET(CMAKE_EXE_LINKER_FLAGS_MINSIZEREL "${CMAKE_EXE_LINKER_FLAGS_MINSIZEREL} /SAFESEH:NO")
SET(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} /SAFESEH:NO")
SET(CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO "${CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO} /SAFESEH:NO")
SET(CMAKE_SHARED_LINKER_FLAGS_DEBUG "${CMAKE_SHARED_LINKER_FLAGS_DEBUG} /SAFESEH:NO")
SET(CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL "${CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL} /SAFESEH:NO")
SET(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} /SAFESEH:NO")
SET(CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO "${CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO} /SAFESEH:NO")
SET(CMAKE_MODULE_LINKER_FLAGS_DEBUG "${CMAKE_MODULE_LINKER_FLAGS_DEBUG} /SAFESEH:NO")
SET(CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL "${CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL} /SAFESEH:NO")
SET(CMAKE_MODULE_LINKER_FLAGS_RELEASE "${CMAKE_MODULE_LINKER_FLAGS_RELEASE} /SAFESEH:NO")
SET(CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO "${CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO} /SAFESEH:NO")
ENDIF(EQEMU_DISABLE_SAFESEH)
OPTION(EQEMU_BUILD_MSVC_MP "Enable build with multiple processes." ON)
IF(EQEMU_BUILD_MSVC_MP)
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MP")
@ -309,7 +291,7 @@ IF(EQEMU_BUILD_PERL)
INCLUDE_DIRECTORIES(SYSTEM "${PERL_INCLUDE_PATH}")
ENDIF(EQEMU_BUILD_PERL)
SET(SERVER_LIBS common debug ${MySQL_LIBRARY_DEBUG} optimized ${MySQL_LIBRARY_RELEASE} ${ZLIB_LIBRARY} libuv fmt)
SET(SERVER_LIBS common debug ${MySQL_LIBRARY_DEBUG} optimized ${MySQL_LIBRARY_RELEASE} ${ZLIB_LIBRARY} libuv fmt recast_navigation)
FIND_PACKAGE(Sodium REQUIRED)
IF(SODIUM_FOUND)
@ -342,7 +324,7 @@ IF(EQEMU_BUILD_LUA)
FIND_PACKAGE(Boost REQUIRED)
INCLUDE_DIRECTORIES(SYSTEM "${LUA_INCLUDE_DIR}" "${Boost_INCLUDE_DIRS}")
INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/luabind")
INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/libs/luabind")
OPTION(EQEMU_SANITIZE_LUA_LIBS "Sanitize Lua Libraries (Remove OS and IO standard libraries from being able to run)." ON)
IF(EQEMU_SANITIZE_LUA_LIBS)
@ -357,6 +339,8 @@ INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/libs/cereal")
INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/libs/libuv/include" )
INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/libs/libuv/src")
INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/libs/format")
INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/libs/recast/detour/include")
INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/libs/recast/recast/include")
IF(EQEMU_BUILD_SERVER OR EQEMU_BUILD_LOGIN OR EQEMU_BUILD_TESTS OR EQEMU_BUILD_HC)
ADD_SUBDIRECTORY(common)

759
LICENSE
View File

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

6
README.md
View File

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

21
appveyor-bots.yml Normal file
View File

@ -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

21
appveyor-no-bots.yml Normal file
View File

@ -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

53
changelog.txt
View File

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

6
common/CMakeLists.txt
View File

@ -3,6 +3,7 @@ CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
SET(common_sources
base_packet.cpp
classes.cpp
compression.cpp
condition.cpp
crash.cpp
crc16.cpp
@ -13,7 +14,6 @@ SET(common_sources
dbcore.cpp
deity.cpp
emu_constants.cpp
emu_legacy.cpp
emu_limits.cpp
emu_opcodes.cpp
emu_versions.cpp
@ -60,6 +60,7 @@ SET(common_sources
rdtsc.cpp
rulesys.cpp
say_link.cpp
serialize_buffer.cpp
serverinfo.cpp
shareddb.cpp
skills.cpp
@ -113,6 +114,7 @@ SET(common_headers
base_data.h
bodytypes.h
classes.h
compression.h
condition.h
crash.h
crc16.h
@ -122,7 +124,6 @@ SET(common_headers
dbcore.h
deity.h
emu_constants.h
emu_legacy.h
emu_limits.h
emu_opcodes.h
emu_oplist.h
@ -190,6 +191,7 @@ SET(common_headers
ruletypes.h
say_link.h
seperator.h
serialize_buffer.h
serverinfo.h
servertalk.h
shareddb.h

12
common/base_packet.cpp
View File

@ -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)

4
common/base_packet.h
View File

@ -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);

82
common/compression.cpp Normal file
View File

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

8
common/compression.h Normal file
View File

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

23
common/database.cpp
View File

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

2
common/database.h
View File

@ -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();

7
common/database_conversions.cpp
View File

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

35
common/emu_constants.cpp
View File

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

258
common/emu_constants.h
View File

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

20
common/emu_legacy.cpp
View File

@ -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"

182
common/emu_legacy.h
View File

@ -1,182 +0,0 @@
/* EQEMu: Everquest Server Emulator
Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY except by those people which sell it, which
are required to give you total support for your newly bought product;
without even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef COMMON_EMU_LEGACY_H
#define COMMON_EMU_LEGACY_H
#include "types.h"
#include <stdlib.h>
namespace EQEmu
{
// this is for perl and other legacy systems
namespace legacy {
enum InventorySlot {
SLOT_CHARM = 0,
SLOT_EAR01 = 1,
SLOT_HEAD = 2,
SLOT_FACE = 3,
SLOT_EAR02 = 4,
SLOT_NECK = 5,
SLOT_SHOULDER = 6,
SLOT_ARMS = 7,
SLOT_BACK = 8,
SLOT_BRACER01 = 9,
SLOT_BRACER02 = 10,
SLOT_RANGE = 11,
SLOT_HANDS = 12,
SLOT_PRIMARY = 13,
SLOT_SECONDARY = 14,
SLOT_RING01 = 15,
SLOT_RING02 = 16,
SLOT_CHEST = 17,
SLOT_LEGS = 18,
SLOT_FEET = 19,
SLOT_WAIST = 20,
SLOT_POWER_SOURCE = 9999,
SLOT_AMMO = 21,
SLOT_GENERAL_1 = 22,
SLOT_GENERAL_2 = 23,
SLOT_GENERAL_3 = 24,
SLOT_GENERAL_4 = 25,
SLOT_GENERAL_5 = 26,
SLOT_GENERAL_6 = 27,
SLOT_GENERAL_7 = 28,
SLOT_GENERAL_8 = 29,
SLOT_CURSOR = 30,
SLOT_CURSOR_END = (int16)0xFFFE, // I hope no one is using this...
SLOT_TRADESKILL = 1000,
SLOT_AUGMENT = 1001,
SLOT_INVALID = (int16)0xFFFF,
SLOT_POSSESSIONS_BEGIN = 0,
SLOT_POSSESSIONS_END = 30,
SLOT_EQUIPMENT_BEGIN = 0,
SLOT_EQUIPMENT_END = 21,
SLOT_PERSONAL_BEGIN = 22,
SLOT_PERSONAL_END = 29,
SLOT_PERSONAL_BAGS_BEGIN = 251,
SLOT_PERSONAL_BAGS_END = 330,
SLOT_CURSOR_BAG_BEGIN = 331,
SLOT_CURSOR_BAG_END = 340,
SLOT_TRIBUTE_BEGIN = 400,
SLOT_TRIBUTE_END = 404,
SLOT_GUILD_TRIBUTE_BEGIN = 450,
SLOT_GUILD_TRIBUTE_END = 451,
SLOT_BANK_BEGIN = 2000,
SLOT_BANK_END = 2023,
SLOT_BANK_BAGS_BEGIN = 2031,
SLOT_BANK_BAGS_END = 2270,
SLOT_SHARED_BANK_BEGIN = 2500,
SLOT_SHARED_BANK_END = 2501,
SLOT_SHARED_BANK_BAGS_BEGIN = 2531,
SLOT_SHARED_BANK_BAGS_END = 2550,
SLOT_TRADE_BEGIN = 3000,
SLOT_TRADE_END = 3007,
SLOT_TRADE_BAGS_BEGIN = 3031,
SLOT_TRADE_BAGS_END = 3110,
SLOT_WORLD_BEGIN = 4000,
SLOT_WORLD_END = 4009
};
// these are currently hard-coded for existing inventory system..do not use in place of special client version handlers until ready
static const uint16 TYPE_POSSESSIONS_SIZE = 31;
static const uint16 TYPE_BANK_SIZE = 24;
static const uint16 TYPE_SHARED_BANK_SIZE = 2;
static const uint16 TYPE_TRADE_SIZE = 8;
static const uint16 TYPE_WORLD_SIZE = 10;
static const uint16 TYPE_LIMBO_SIZE = 36;
static const uint16 TYPE_TRIBUTE_SIZE = 5; // (need client values)
static const uint16 TYPE_TROPHY_TRIBUTE_SIZE = 0;
static const uint16 TYPE_GUILD_TRIBUTE_SIZE = 0;
static const uint16 TYPE_MERCHANT_SIZE = 0;
static const uint16 TYPE_DELETED_SIZE = 0;
static const uint16 TYPE_CORPSE_SIZE = 31; // no bitmask use..limits to size of client corpse window (see EQLimits::InventoryMapSize(MapCorpse, <EQClientVersion))
static const uint16 TYPE_BAZAAR_SIZE = 80;
static const uint16 TYPE_INSPECT_SIZE = 22;
static const uint16 TYPE_REAL_ESTATE_SIZE = 0;
static const uint16 TYPE_VIEW_MOD_PC_SIZE = 0;
static const uint16 TYPE_VIEW_MOD_BANK_SIZE = 0;
static const uint16 TYPE_VIEW_MOD_SHARED_BANK_SIZE = 0;
static const uint16 TYPE_VIEW_MOD_LIMBO_SIZE = 0;
static const uint16 TYPE_ALT_STORAGE_SIZE = 0;
static const uint16 TYPE_ARCHIVED_SIZE = 0;
static const uint16 TYPE_MAIL_SIZE = 0;
static const uint16 TYPE_GUILD_TROPHY_TRIBUTE_SIZE = 0;
static const uint16 TYPE_KRONO_SIZE = 0;
static const uint16 TYPE_OTHER_SIZE = 0;
// most of these definitions will go away with the structure-based system..this maintains compatibility for now
// (these are mainly to assign specific values to constants used in conversions and to identify per-client ranges/offsets)
static const int16 EQUIPMENT_BEGIN = 0;
static const int16 EQUIPMENT_END = 21;
static const uint16 EQUIPMENT_SIZE = 22; // does not account for 'Power Source' - used mainly for npc equipment arrays
static const int16 GENERAL_BEGIN = 22;
static const int16 GENERAL_END = 29;
static const uint16 GENERAL_SIZE = 8;
static const int16 GENERAL_BAGS_BEGIN = 251;
static const int16 GENERAL_BAGS_END_OFFSET = 79;
static const int16 GENERAL_BAGS_END = GENERAL_BAGS_BEGIN + GENERAL_BAGS_END_OFFSET;
static const int16 CURSOR_BAG_BEGIN = 331;
static const int16 CURSOR_BAG_END_OFFSET = 9;
static const int16 CURSOR_BAG_END = CURSOR_BAG_BEGIN + CURSOR_BAG_END_OFFSET;
static const int16 BANK_BEGIN = 2000;
static const int16 BANK_END = 2023;
static const int16 BANK_BAGS_BEGIN = 2031;
static const int16 BANK_BAGS_END_OFFSET = 239;
static const int16 BANK_BAGS_END = BANK_BAGS_BEGIN + BANK_BAGS_END_OFFSET;
static const int16 SHARED_BANK_BEGIN = 2500;
static const int16 SHARED_BANK_END = 2501;
static const int16 SHARED_BANK_BAGS_BEGIN = 2531;
static const int16 SHARED_BANK_BAGS_END_OFFSET = 19;
static const int16 SHARED_BANK_BAGS_END = SHARED_BANK_BAGS_BEGIN + SHARED_BANK_BAGS_END_OFFSET;
static const int16 TRADE_BEGIN = 3000;
static const int16 TRADE_END = 3007;
static const int16 TRADE_NPC_END = 3003;
static const int16 TRADE_BAGS_BEGIN = 3031;
static const int16 TRADE_BAGS_END_OFFSET = 79;
static const int16 TRADE_BAGS_END = TRADE_BAGS_BEGIN + TRADE_BAGS_END_OFFSET;
static const int16 WORLD_BEGIN = 4000;
static const int16 WORLD_END = 4009;
static const int16 WORLD_SIZE = TYPE_WORLD_SIZE;
static const int16 TRIBUTE_BEGIN = 400;
static const int16 TRIBUTE_END = 404;
static const int16 TRIBUTE_SIZE = TYPE_TRIBUTE_SIZE;
static const int16 CORPSE_BEGIN = 22;
// BANDOLIERS_SIZE sets maximum limit..active limit will need to be handled by the appropriate AA or spell (or item?)
static const size_t BANDOLIERS_SIZE = 20; // number of bandolier instances
static const size_t BANDOLIER_ITEM_COUNT = 4; // number of equipment slots in bandolier instance
// POTION_BELT_SIZE sets maximum limit..active limit will need to be handled by the appropriate AA or spell (or item?)
static const size_t POTION_BELT_ITEM_COUNT = 5;
}
}
#endif /* COMMON_EMU_LEGACY_H */

69
common/emu_limits.h
View File

@ -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*/

14
common/eq_constants.h
View File

@ -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*/

1458
common/eq_limits.cpp
View File

File diff suppressed because it is too large Load Diff

25
common/eq_limits.h
View File

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

3
common/eq_packet.h
View File

@ -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; }

53
common/eq_packet_structs.h
View File

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

11
common/event/background_task.h
View File

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

1
common/features.h
View File

@ -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

285
common/inventory_profile.cpp
View File

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

17
common/inventory_profile.h
View File

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

156
common/inventory_slot.cpp
View File

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

24
common/inventory_slot.h
View File

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

6
common/item_data.h
View File

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

118
common/item_instance.cpp
View File

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

2
common/misc_functions.cpp
View File

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

2
common/misc_functions.h
View File

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

10
common/net/console_server_connection.cpp
View File

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

2
common/net/daybreak_connection.cpp
View File

@ -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);

6
common/net/daybreak_connection.h
View File

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

313
common/patches/rof.cpp
View File

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

325
common/patches/rof2.cpp
View File

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

272
common/patches/rof2_limits.cpp
View File

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

344
common/patches/rof2_limits.h
View File

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

1
common/patches/rof2_ops.h
View File

@ -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)

10
common/patches/rof2_structs.h
View File

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

266
common/patches/rof_limits.cpp
View File

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

340
common/patches/rof_limits.h
View File

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

1
common/patches/rof_ops.h
View File

@ -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)

10
common/patches/rof_structs.h
View File

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

187
common/patches/sod.cpp
View File

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

238
common/patches/sod_limits.cpp
View File

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

400
common/patches/sod_limits.h
View File

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

1
common/patches/sod_ops.h
View File

@ -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)

6
common/patches/sod_structs.h
View File

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

191
common/patches/sof.cpp
View File

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

238
common/patches/sof_limits.cpp
View File

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

400
common/patches/sof_limits.h
View File

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

1
common/patches/sof_ops.h
View File

@ -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)

6
common/patches/sof_structs.h
View File

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

30
common/patches/titanium.cpp
View File

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

236
common/patches/titanium_limits.cpp
View File

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

398
common/patches/titanium_limits.h
View File

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

6
common/patches/titanium_structs.h
View File

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

190
common/patches/uf.cpp
View File

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

238
common/patches/uf_limits.cpp
View File

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

400
common/patches/uf_limits.h
View File

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

1
common/patches/uf_ops.h
View File

@ -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)

6
common/patches/uf_structs.h
View File

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

4
common/perl_eqdb.cpp
View File

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

4
common/perl_eqdb_res.cpp
View File

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

173
common/races.cpp
View File

@ -1349,102 +1349,99 @@ const char* GetPlayerRaceName(uint32 player_race_value)
return GetRaceIDName(GetRaceIDFromPlayerRaceValue(player_race_value));
}
uint32 GetPlayerRaceValue(uint16 race_id)
{
uint32 GetPlayerRaceValue(uint16 race_id) {
switch (race_id) {
case HUMAN:
case BARBARIAN:
case ERUDITE:
case WOOD_ELF:
case HIGH_ELF:
case DARK_ELF:
case HALF_ELF:
case DWARF:
case TROLL:
case OGRE:
case HALFLING:
case GNOME:
return race_id;
case IKSAR:
return PLAYER_RACE_IKSAR;
case VAHSHIR:
return PLAYER_RACE_VAHSHIR;
case FROGLOK:
case FROGLOK2:
return PLAYER_RACE_FROGLOK;
case DRAKKIN:
return PLAYER_RACE_DRAKKIN;
default:
return PLAYER_RACE_UNKNOWN; // watch
case HUMAN:
case BARBARIAN:
case ERUDITE:
case WOOD_ELF:
case HIGH_ELF:
case DARK_ELF:
case HALF_ELF:
case DWARF:
case TROLL:
case OGRE:
case HALFLING:
case GNOME:
return race_id;
case IKSAR:
return PLAYER_RACE_IKSAR;
case VAHSHIR:
return PLAYER_RACE_VAHSHIR;
case FROGLOK:
case FROGLOK2:
return PLAYER_RACE_FROGLOK;
case DRAKKIN:
return PLAYER_RACE_DRAKKIN;
default:
return PLAYER_RACE_UNKNOWN; // watch
}
}
uint32 GetPlayerRaceBit(uint16 race_id)
{
uint32 GetPlayerRaceBit(uint16 race_id) {
switch (race_id) {
case HUMAN:
return PLAYER_RACE_HUMAN_BIT;
case BARBARIAN:
return PLAYER_RACE_BARBARIAN_BIT;
case ERUDITE:
return PLAYER_RACE_ERUDITE_BIT;
case WOOD_ELF:
return PLAYER_RACE_WOOD_ELF_BIT;
case HIGH_ELF:
return PLAYER_RACE_HIGH_ELF_BIT;
case DARK_ELF:
return PLAYER_RACE_DARK_ELF_BIT;
case HALF_ELF:
return PLAYER_RACE_HALF_ELF_BIT;
case DWARF:
return PLAYER_RACE_DWARF_BIT;
case TROLL:
return PLAYER_RACE_TROLL_BIT;
case OGRE:
return PLAYER_RACE_OGRE_BIT;
case HALFLING:
return PLAYER_RACE_HALFLING_BIT;
case GNOME:
return PLAYER_RACE_GNOME_BIT;
case IKSAR:
return PLAYER_RACE_IKSAR_BIT;
case VAHSHIR:
return PLAYER_RACE_VAHSHIR_BIT;
case FROGLOK:
return PLAYER_RACE_FROGLOK_BIT;
case DRAKKIN:
return PLAYER_RACE_DRAKKIN_BIT;
default:
return PLAYER_RACE_UNKNOWN_BIT;
case HUMAN:
return PLAYER_RACE_HUMAN_BIT;
case BARBARIAN:
return PLAYER_RACE_BARBARIAN_BIT;
case ERUDITE:
return PLAYER_RACE_ERUDITE_BIT;
case WOOD_ELF:
return PLAYER_RACE_WOOD_ELF_BIT;
case HIGH_ELF:
return PLAYER_RACE_HIGH_ELF_BIT;
case DARK_ELF:
return PLAYER_RACE_DARK_ELF_BIT;
case HALF_ELF:
return PLAYER_RACE_HALF_ELF_BIT;
case DWARF:
return PLAYER_RACE_DWARF_BIT;
case TROLL:
return PLAYER_RACE_TROLL_BIT;
case OGRE:
return PLAYER_RACE_OGRE_BIT;
case HALFLING:
return PLAYER_RACE_HALFLING_BIT;
case GNOME:
return PLAYER_RACE_GNOME_BIT;
case IKSAR:
return PLAYER_RACE_IKSAR_BIT;
case VAHSHIR:
return PLAYER_RACE_VAHSHIR_BIT;
case FROGLOK:
return PLAYER_RACE_FROGLOK_BIT;
case DRAKKIN:
return PLAYER_RACE_DRAKKIN_BIT;
default:
return PLAYER_RACE_UNKNOWN_BIT;
}
}
uint16 GetRaceIDFromPlayerRaceValue(uint32 player_race_value)
{
uint16 GetRaceIDFromPlayerRaceValue(uint32 player_race_value) {
switch (player_race_value) {
case PLAYER_RACE_HUMAN:
case PLAYER_RACE_BARBARIAN:
case PLAYER_RACE_ERUDITE:
case PLAYER_RACE_WOOD_ELF:
case PLAYER_RACE_HIGH_ELF:
case PLAYER_RACE_DARK_ELF:
case PLAYER_RACE_HALF_ELF:
case PLAYER_RACE_DWARF:
case PLAYER_RACE_TROLL:
case PLAYER_RACE_OGRE:
case PLAYER_RACE_HALFLING:
case PLAYER_RACE_GNOME:
return player_race_value;
case PLAYER_RACE_IKSAR:
return IKSAR;
case PLAYER_RACE_VAHSHIR:
return VAHSHIR;
case PLAYER_RACE_FROGLOK:
return FROGLOK;
case PLAYER_RACE_DRAKKIN:
return DRAKKIN;
default:
return PLAYER_RACE_UNKNOWN; // watch
case PLAYER_RACE_HUMAN:
case PLAYER_RACE_BARBARIAN:
case PLAYER_RACE_ERUDITE:
case PLAYER_RACE_WOOD_ELF:
case PLAYER_RACE_HIGH_ELF:
case PLAYER_RACE_DARK_ELF:
case PLAYER_RACE_HALF_ELF:
case PLAYER_RACE_DWARF:
case PLAYER_RACE_TROLL:
case PLAYER_RACE_OGRE:
case PLAYER_RACE_HALFLING:
case PLAYER_RACE_GNOME:
return player_race_value;
case PLAYER_RACE_IKSAR:
return IKSAR;
case PLAYER_RACE_VAHSHIR:
return VAHSHIR;
case PLAYER_RACE_FROGLOK:
return FROGLOK;
case PLAYER_RACE_DRAKKIN:
return DRAKKIN;
default:
return PLAYER_RACE_UNKNOWN; // watch
}
}
@ -1596,7 +1593,7 @@ float GetRaceGenderDefaultHeight(int race, int gender)
const auto size = sizeof(male_height) / sizeof(male_height[0]);
if (race > size)
if (race >= size)
return 6.0f;
if (gender == 1)

1135
common/races.h
View File

File diff suppressed because it is too large Load Diff

55
common/rulesys.cpp
View File

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

3
common/ruletypes.h
View File

@ -156,7 +156,9 @@ RULE_BOOL(Character, UseOldBindWound, false) // Uses the original bind wound beh
RULE_BOOL(Character, GrantHoTTOnCreate, false) // Grant Health of Target's Target leadership AA on character creation
RULE_BOOL(Character, UseOldConSystem, false) // Grant Health of Target's Target leadership AA on character creation
RULE_BOOL(Character, OPClientUpdateVisualDebug, false) // Shows a pulse and forward directional particle each time the client sends its position to server
RULE_BOOL(Character, AllowCrossClassTrainers, false)
RULE_BOOL(Character, PetsUseReagents, true) //Pets use reagent on spells
RULE_BOOL(Character, DismountWater, true) // Dismount horses when entering water
RULE_CATEGORY_END()
RULE_CATEGORY(Mercs)
@ -548,6 +550,7 @@ RULE_BOOL(Aggro, AllowTickPulling, false) // tick pulling is an exploit in an NP
RULE_BOOL(Aggro, UseLevelAggro, true) // Level 18+ and Undead will aggro regardless of level difference. (this will disabled Rule:IntAggroThreshold if set to true)
RULE_INT(Aggro, ClientAggroCheckInterval, 6) // Interval in which clients actually check for aggro - in seconds
RULE_REAL(Aggro, PetAttackRange, 40000.0) // max squared range /pet attack works at default is 200
RULE_BOOL(Aggro, NPCAggroMaxDistanceEnabled, true) /* If enabled, NPC's will drop aggro beyond 600 units or what is defined at the zone level */
RULE_CATEGORY_END()
RULE_CATEGORY(TaskSystem)

14
common/say_link.cpp
View File

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

23
common/serialize_buffer.cpp Normal file
View File

@ -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;
}

199
common/serialize_buffer.h Normal file
View File

@ -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 */

44
common/shareddb.cpp
View File

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

3
common/spdat.cpp
View File

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

7
common/timer.cpp
View File

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

2
common/timer.h
View File

@ -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();

2
common/version.h
View File

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

3
libs/CMakeLists.txt
View File

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

3
libs/format/.github/pull_request_template vendored Normal file
View File

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

19
libs/format/.gitignore vendored Normal file
View File

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

8
libs/format/.travis.yml
View File

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

32
libs/format/CMakeLists.txt
View File

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

11
libs/format/CONTRIBUTING.rst Normal file
View File

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

110
libs/format/ChangeLog.rst
View File

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

33
libs/format/README.rst
View File

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

2
libs/format/cppformat/format.h
View File

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

2
libs/format/cppformat/posix.h
View File

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

6
libs/format/doc/CMakeLists.txt
View File

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

28
libs/format/doc/_static/breathe.css vendored Normal file
View File

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

51
libs/format/doc/_templates/layout.html vendored
View File

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

90
libs/format/doc/api.rst
View File

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

3
libs/format/doc/basic-bootstrap/layout.html
View File

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

74
libs/format/doc/build.py
View File

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

7
libs/format/doc/conf.py
View File

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

90
libs/format/doc/html/_sources/api.txt
View File

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

Some files were not shown because too many files have changed in this diff Show More