pa/eqemu-server
2
0
Fork 0
mirror of https://github.com/EQEmu/Server.git synced 2025-12-13 06:21:28 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Another eq_dictionary pass

Browse Source
This commit is contained in:
Uleat 2016-05-30 06:52:25 -04:00
parent b155a603aa
commit 16895910e4
29 changed files with 630 additions and 521 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
common/emu_limits.cpp
View File

@ -1,4 +1,4 @@
/* EQEMu: Everquest Server Emulator /* EQEMu: Everquest Server Emulator
Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net) Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
@ -10,7 +10,7 @@
but WITHOUT ANY WARRANTY except by those people which sell it, which but WITHOUT ANY WARRANTY except by those people which sell it, which
are required to give you total support for your newly bought product; are required to give you total support for your newly bought product;
without even the implied warranty of MERCHANTABILITY or FITNESS FOR without even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE. See the GNU General Public License for more details. A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software along with this program; if not, write to the Free Software

24
common/emu_limits.h
View File

@ -1,4 +1,4 @@
/* EQEMu: Everquest Server Emulator /* EQEMu: Everquest Server Emulator
Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net) Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
@ -10,7 +10,7 @@
but WITHOUT ANY WARRANTY except by those people which sell it, which but WITHOUT ANY WARRANTY except by those people which sell it, which
are required to give you total support for your newly bought product; are required to give you total support for your newly bought product;
without even the implied warranty of MERCHANTABILITY or FITNESS FOR without even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE. See the GNU General Public License for more details. A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software along with this program; if not, write to the Free Software
@ -31,25 +31,37 @@ namespace EntityLimits
enum : int { Invalid = -1, Null, Safety }; enum : int { Invalid = -1, Null, Safety };
enum : bool { False = false, True = true }; enum : bool { False = false, True = true };
}
const size_t InvTypeTradeSize = 4;
} /*npc*/
namespace merc { namespace merc {
enum : int { Invalid = -1, Null, Safety }; enum : int { Invalid = -1, Null, Safety };
enum : bool { False = false, True = true }; enum : bool { False = false, True = true };
}
const size_t InvTypeTradeSize = 4;
} /*merc*/
namespace bot { namespace bot {
enum : int { Invalid = -1, Null, Safety }; enum : int { Invalid = -1, Null, Safety };
enum : bool { False = false, True = true }; enum : bool { False = false, True = true };
}
const size_t InvTypeTradeSize = 8;
} /*bot*/
namespace pet { namespace pet {
enum : int { Invalid = -1, Null, Safety }; enum : int { Invalid = -1, Null, Safety };
enum : bool { False = false, True = true }; enum : bool { False = false, True = true };
}
const size_t InvTypeTradeSize = 4;
} /*pet*/
}; /*EntityLimits*/ }; /*EntityLimits*/

1
common/eq_constants.h
View File

@ -516,7 +516,6 @@ static const uint8 SkillDamageTypes[EQEmu::skills::HIGHEST_SKILL + 1] = // chang
*/ */
#define INVALID_INDEX -1 #define INVALID_INDEX -1
#define NOT_USED 0
#define NO_ITEM 0 #define NO_ITEM 0
// yes..these are redundant... but, they help to identify and define what is actually being performed // yes..these are redundant... but, they help to identify and define what is actually being performed

568
common/eq_limits.cpp
View File

@ -1,4 +1,4 @@
/* EQEMu: Everquest Server Emulator /* EQEMu: Everquest Server Emulator
Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net) Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
@ -10,7 +10,7 @@
but WITHOUT ANY WARRANTY except by those people which sell it, which but WITHOUT ANY WARRANTY except by those people which sell it, which
are required to give you total support for your newly bought product; are required to give you total support for your newly bought product;
without even the implied warranty of MERCHANTABILITY or FITNESS FOR without even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE. See the GNU General Public License for more details. A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software along with this program; if not, write to the Free Software
@ -21,7 +21,7 @@
#include "emu_limits.h" #include "emu_limits.h"
size_t EQEmu::constants::CharacterCreationLimit(versions::ClientVersion client_version) size_t EQEmu::constants::GetCharacterCreationLimit(versions::ClientVersion client_version)
{ {
static const size_t local[versions::ClientVersionCount] = { static const size_t local[versions::ClientVersionCount] = {
ClientUnknown::Null, ClientUnknown::Null,
@ -37,22 +37,22 @@ size_t EQEmu::constants::CharacterCreationLimit(versions::ClientVersion client_v
return local[static_cast<size_t>(versions::ValidateClientVersion(client_version))]; return local[static_cast<size_t>(versions::ValidateClientVersion(client_version))];
} }
uint16 EQEmu::inventory::InventoryTypeSize(versions::InventoryVersion inventory_version, int16 inv_type) size_t EQEmu::inventory::GetInventoryTypeSize(versions::InventoryVersion inventory_version, int inv_type)
{ {
static const uint16 local[legacy::TypeCount][versions::InventoryVersionCount] = { static const size_t local[legacy::TypeCount][versions::InventoryVersionCount] = {
{ // local[TypePossessions] { // local[TypePossessions]
ClientUnknown::Null, ClientUnknown::Null,
Client62::Null, Client62::Null,
legacy::TYPE_POSSESSIONS_SIZE, legacy::TYPE_POSSESSIONS_SIZE, //Titanium::invtype::InvTypePossessionsSize,
legacy::TYPE_POSSESSIONS_SIZE, legacy::TYPE_POSSESSIONS_SIZE, //SoF::invtype::InvTypePossessionsSize,
legacy::TYPE_POSSESSIONS_SIZE, legacy::TYPE_POSSESSIONS_SIZE, //SoD::invtype::InvTypePossessionsSize,
legacy::TYPE_POSSESSIONS_SIZE, legacy::TYPE_POSSESSIONS_SIZE, //UF::invtype::InvTypePossessionsSize,
legacy::TYPE_POSSESSIONS_SIZE, legacy::TYPE_POSSESSIONS_SIZE, //RoF::invtype::InvTypePossessionsSize,
legacy::TYPE_POSSESSIONS_SIZE, legacy::TYPE_POSSESSIONS_SIZE, //RoF2::invtype::InvTypePossessionsSize,
legacy::TYPE_POSSESSIONS_SIZE, legacy::TYPE_POSSESSIONS_SIZE, //InvTypePossessionsSize,
legacy::TYPE_POSSESSIONS_SIZE, legacy::TYPE_POSSESSIONS_SIZE, //InvTypePossessionsSize,
legacy::TYPE_POSSESSIONS_SIZE, legacy::TYPE_POSSESSIONS_SIZE, //InvTypePossessionsSize,
legacy::TYPE_POSSESSIONS_SIZE, legacy::TYPE_POSSESSIONS_SIZE, //InvTypePossessionsSize,
Titanium::Null, Titanium::Null,
SoF::Null, SoF::Null,
SoD::Null, SoD::Null,
@ -64,11 +64,11 @@ uint16 EQEmu::inventory::InventoryTypeSize(versions::InventoryVersion inventory_
ClientUnknown::Null, ClientUnknown::Null,
Client62::Null, Client62::Null,
Titanium::invtype::InvTypeBankSize, Titanium::invtype::InvTypeBankSize,
legacy::TYPE_BANK_SIZE, SoF::invtype::InvTypeBankSize,
legacy::TYPE_BANK_SIZE, SoD::invtype::InvTypeBankSize,
legacy::TYPE_BANK_SIZE, UF::invtype::InvTypeBankSize,
legacy::TYPE_BANK_SIZE, RoF::invtype::InvTypeBankSize,
legacy::TYPE_BANK_SIZE, RoF2::invtype::InvTypeBankSize,
EntityLimits::npc::Null, EntityLimits::npc::Null,
EntityLimits::merc::Null, EntityLimits::merc::Null,
EntityLimits::bot::Null, EntityLimits::bot::Null,
@ -83,12 +83,12 @@ uint16 EQEmu::inventory::InventoryTypeSize(versions::InventoryVersion inventory_
{ // local[TypeSharedBank] { // local[TypeSharedBank]
ClientUnknown::Null, ClientUnknown::Null,
Client62::Null, Client62::Null,
legacy::TYPE_SHARED_BANK_SIZE, Titanium::invtype::InvTypeSharedBankSize,
legacy::TYPE_SHARED_BANK_SIZE, SoF::invtype::InvTypeSharedBankSize,
legacy::TYPE_SHARED_BANK_SIZE, SoD::invtype::InvTypeSharedBankSize,
legacy::TYPE_SHARED_BANK_SIZE, UF::invtype::InvTypeSharedBankSize,
legacy::TYPE_SHARED_BANK_SIZE, RoF::invtype::InvTypeSharedBankSize,
legacy::TYPE_SHARED_BANK_SIZE, RoF2::invtype::InvTypeSharedBankSize,
EntityLimits::npc::Null, EntityLimits::npc::Null,
EntityLimits::merc::Null, EntityLimits::merc::Null,
EntityLimits::bot::Null, EntityLimits::bot::Null,
@ -103,32 +103,32 @@ uint16 EQEmu::inventory::InventoryTypeSize(versions::InventoryVersion inventory_
{ // local[TypeTrade] { // local[TypeTrade]
ClientUnknown::Null, ClientUnknown::Null,
Client62::Null, Client62::Null,
legacy::TYPE_TRADE_SIZE, Titanium::invtype::InvTypeTradeSize,
legacy::TYPE_TRADE_SIZE, SoF::invtype::InvTypeTradeSize,
legacy::TYPE_TRADE_SIZE, SoD::invtype::InvTypeTradeSize,
legacy::TYPE_TRADE_SIZE, UF::invtype::InvTypeTradeSize,
legacy::TYPE_TRADE_SIZE, RoF::invtype::InvTypeTradeSize,
legacy::TYPE_TRADE_SIZE, RoF2::invtype::InvTypeTradeSize,
4, EntityLimits::npc::InvTypeTradeSize,
4, EntityLimits::merc::InvTypeTradeSize,
legacy::TYPE_TRADE_SIZE, // client thinks this is another client EntityLimits::bot::InvTypeTradeSize, // client thinks this is another client
4, EntityLimits::pet::InvTypeTradeSize,
Titanium::Null, Titanium::invtype::InvTypeTradeSize,
SoF::Null, SoF::invtype::InvTypeTradeSize,
SoD::Null, SoD::invtype::InvTypeTradeSize,
UF::Null, UF::invtype::InvTypeTradeSize,
RoF::Null, RoF::invtype::InvTypeTradeSize,
RoF2::Null RoF2::invtype::InvTypeTradeSize
}, },
{ // local[TypeWorld] { // local[TypeWorld]
ClientUnknown::Null, ClientUnknown::Null,
Client62::Null, Client62::Null,
legacy::TYPE_WORLD_SIZE, Titanium::invtype::InvTypeWorldSize,
legacy::TYPE_WORLD_SIZE, SoF::invtype::InvTypeWorldSize,
legacy::TYPE_WORLD_SIZE, SoD::invtype::InvTypeWorldSize,
legacy::TYPE_WORLD_SIZE, UF::invtype::InvTypeWorldSize,
legacy::TYPE_WORLD_SIZE, RoF::invtype::InvTypeWorldSize,
legacy::TYPE_WORLD_SIZE, RoF2::invtype::InvTypeWorldSize,
EntityLimits::npc::Null, EntityLimits::npc::Null,
EntityLimits::merc::Null, EntityLimits::merc::Null,
EntityLimits::bot::Null, EntityLimits::bot::Null,
@ -143,12 +143,12 @@ uint16 EQEmu::inventory::InventoryTypeSize(versions::InventoryVersion inventory_
{ // local[TypeLimbo] { // local[TypeLimbo]
ClientUnknown::Null, ClientUnknown::Null,
Client62::Null, Client62::Null,
legacy::TYPE_LIMBO_SIZE, Titanium::invtype::InvTypeLimboSize,
legacy::TYPE_LIMBO_SIZE, SoF::invtype::InvTypeLimboSize,
legacy::TYPE_LIMBO_SIZE, SoD::invtype::InvTypeLimboSize,
legacy::TYPE_LIMBO_SIZE, UF::invtype::InvTypeLimboSize,
legacy::TYPE_LIMBO_SIZE, RoF::invtype::InvTypeLimboSize,
legacy::TYPE_LIMBO_SIZE, RoF2::invtype::InvTypeLimboSize,
EntityLimits::npc::Null, EntityLimits::npc::Null,
EntityLimits::merc::Null, EntityLimits::merc::Null,
EntityLimits::bot::Null, EntityLimits::bot::Null,
@ -163,12 +163,12 @@ uint16 EQEmu::inventory::InventoryTypeSize(versions::InventoryVersion inventory_
{ // local[TypeTribute] { // local[TypeTribute]
ClientUnknown::Null, ClientUnknown::Null,
Client62::Null, Client62::Null,
legacy::TYPE_TRIBUTE_SIZE, Titanium::invtype::InvTypeTributeSize,
legacy::TYPE_TRIBUTE_SIZE, SoF::invtype::InvTypeTributeSize,
legacy::TYPE_TRIBUTE_SIZE, SoD::invtype::InvTypeTributeSize,
legacy::TYPE_TRIBUTE_SIZE, UF::invtype::InvTypeTributeSize,
legacy::TYPE_TRIBUTE_SIZE, RoF::invtype::InvTypeTributeSize,
legacy::TYPE_TRIBUTE_SIZE, RoF2::invtype::InvTypeTributeSize,
EntityLimits::npc::Null, EntityLimits::npc::Null,
EntityLimits::merc::Null, EntityLimits::merc::Null,
EntityLimits::bot::Null, EntityLimits::bot::Null,
@ -187,8 +187,8 @@ uint16 EQEmu::inventory::InventoryTypeSize(versions::InventoryVersion inventory_
SoF::Null, SoF::Null,
SoD::Null, SoD::Null,
UF::Null, UF::Null,
legacy::TYPE_TROPHY_TRIBUTE_SIZE, RoF::Null, //RoF::invtype::InvTypeTrophyTributeSize,
legacy::TYPE_TROPHY_TRIBUTE_SIZE, RoF2::Null, //RoF2::invtype::InvTypeTrophyTributeSize,
EntityLimits::npc::Null, EntityLimits::npc::Null,
EntityLimits::merc::Null, EntityLimits::merc::Null,
EntityLimits::bot::Null, EntityLimits::bot::Null,
@ -203,12 +203,12 @@ uint16 EQEmu::inventory::InventoryTypeSize(versions::InventoryVersion inventory_
{ // local[TypeGuildTribute] { // local[TypeGuildTribute]
ClientUnknown::Null, ClientUnknown::Null,
Client62::Null, Client62::Null,
Titanium::Null, Titanium::Null, //Titanium::invtype::InvTypeGuildTributeSize,
SoF::Null, SoF::Null, //SoF::invtype::InvTypeGuildTributeSize,
SoD::Null, SoD::Null, //SoD::invtype::InvTypeGuildTributeSize,
UF::Null, UF::Null, //UF::invtype::InvTypeGuildTributeSize,
legacy::TYPE_GUILD_TRIBUTE_SIZE, RoF::Null, //RoF::invtype::InvTypeGuildTributeSize,
legacy::TYPE_GUILD_TRIBUTE_SIZE, RoF2::Null, //RoF2::invtype::InvTypeGuildTributeSize,
EntityLimits::npc::Null, EntityLimits::npc::Null,
EntityLimits::merc::Null, EntityLimits::merc::Null,
EntityLimits::bot::Null, EntityLimits::bot::Null,
@ -223,22 +223,22 @@ uint16 EQEmu::inventory::InventoryTypeSize(versions::InventoryVersion inventory_
{ // local[TypeMerchant] { // local[TypeMerchant]
ClientUnknown::Null, ClientUnknown::Null,
Client62::Null, Client62::Null,
Titanium::Null, Titanium::invtype::InvTypeMerchantSize,
SoF::Null, SoF::invtype::InvTypeMerchantSize,
SoD::Null, SoD::invtype::InvTypeMerchantSize,
UF::Null, UF::invtype::InvTypeMerchantSize,
legacy::TYPE_MERCHANT_SIZE, RoF::invtype::InvTypeMerchantSize,
legacy::TYPE_MERCHANT_SIZE, RoF2::invtype::InvTypeMerchantSize,
EntityLimits::npc::Null, EntityLimits::npc::Null,
EntityLimits::merc::Null, EntityLimits::merc::Null,
EntityLimits::bot::Null, EntityLimits::bot::Null,
EntityLimits::pet::Null, EntityLimits::pet::Null,
Titanium::Null, Titanium::invtype::InvTypeMerchantSize,
SoF::Null, SoF::invtype::InvTypeMerchantSize,
SoD::Null, SoD::invtype::InvTypeMerchantSize,
UF::Null, UF::invtype::InvTypeMerchantSize,
RoF::Null, RoF::invtype::InvTypeMerchantSize,
RoF2::Null RoF2::invtype::InvTypeMerchantSize
}, },
{ // local[TypeDeleted] { // local[TypeDeleted]
ClientUnknown::Null, ClientUnknown::Null,
@ -247,8 +247,8 @@ uint16 EQEmu::inventory::InventoryTypeSize(versions::InventoryVersion inventory_
SoF::Null, SoF::Null,
SoD::Null, SoD::Null,
UF::Null, UF::Null,
legacy::TYPE_DELETED_SIZE, RoF::Null, //RoF::invtype::InvTypeDeletedSize,
legacy::TYPE_DELETED_SIZE, RoF2::Null, //RoF2::invtype::InvTypeDeletedSize,
EntityLimits::npc::Null, EntityLimits::npc::Null,
EntityLimits::merc::Null, EntityLimits::merc::Null,
EntityLimits::bot::Null, EntityLimits::bot::Null,
@ -269,10 +269,10 @@ uint16 EQEmu::inventory::InventoryTypeSize(versions::InventoryVersion inventory_
UF::invtype::InvTypeCorpseSize, UF::invtype::InvTypeCorpseSize,
RoF::invtype::InvTypeCorpseSize, RoF::invtype::InvTypeCorpseSize,
RoF2::invtype::InvTypeCorpseSize, RoF2::invtype::InvTypeCorpseSize,
EntityLimits::npc::Null, EntityLimits::npc::Null, //InvTypeCorpseSize,
EntityLimits::merc::Null, EntityLimits::merc::Null, //InvTypeCorpseSize,
EntityLimits::bot::Null, EntityLimits::bot::Null, //InvTypeCorpseSize,
EntityLimits::pet::Null, EntityLimits::pet::Null, //InvTypeCorpseSize,
Titanium::Null, Titanium::Null,
SoF::Null, SoF::Null,
SoD::Null, SoD::Null,
@ -283,22 +283,22 @@ uint16 EQEmu::inventory::InventoryTypeSize(versions::InventoryVersion inventory_
{ // local[TypeBazaar] { // local[TypeBazaar]
ClientUnknown::Null, ClientUnknown::Null,
Client62::Null, Client62::Null,
legacy::TYPE_BAZAAR_SIZE, legacy::TYPE_BAZAAR_SIZE, //Titanium::invtype::InvTypeBazaarSize,
legacy::TYPE_BAZAAR_SIZE, legacy::TYPE_BAZAAR_SIZE, //SoF::invtype::InvTypeBazaarSize,
legacy::TYPE_BAZAAR_SIZE, legacy::TYPE_BAZAAR_SIZE, //SoD::invtype::InvTypeBazaarSize,
legacy::TYPE_BAZAAR_SIZE, legacy::TYPE_BAZAAR_SIZE, //UF::invtype::InvTypeBazaarSize,
legacy::TYPE_BAZAAR_SIZE, legacy::TYPE_BAZAAR_SIZE, //RoF::invtype::InvTypeBazaarSize,
legacy::TYPE_BAZAAR_SIZE, legacy::TYPE_BAZAAR_SIZE, //RoF2::invtype::InvTypeBazaarSize,
EntityLimits::npc::Null, EntityLimits::npc::Null,
EntityLimits::merc::Null, EntityLimits::merc::Null,
EntityLimits::bot::Null, EntityLimits::bot::Null,
EntityLimits::pet::Null, EntityLimits::pet::Null,
Titanium::Null, Titanium::Null, //Titanium::invtype::InvTypeBazaarSize,
SoF::Null, SoF::Null, //SoF::invtype::InvTypeBazaarSize,
SoD::Null, SoD::Null, //SoD::invtype::InvTypeBazaarSize,
UF::Null, UF::Null, //UF::invtype::InvTypeBazaarSize,
RoF::Null, RoF::Null, //RoF::invtype::InvTypeBazaarSize,
RoF2::Null RoF2::Null //RoF2::invtype::InvTypeBazaarSize,
}, },
{ // local[TypeInspect] { // local[TypeInspect]
ClientUnknown::Null, ClientUnknown::Null,
@ -313,12 +313,12 @@ uint16 EQEmu::inventory::InventoryTypeSize(versions::InventoryVersion inventory_
EntityLimits::merc::Null, EntityLimits::merc::Null,
EntityLimits::bot::Null, EntityLimits::bot::Null,
EntityLimits::pet::Null, EntityLimits::pet::Null,
Titanium::Null, Titanium::invtype::InvTypeInspectSize,
SoF::Null, SoF::invtype::InvTypeInspectSize,
SoD::Null, SoD::invtype::InvTypeInspectSize,
UF::Null, UF::invtype::InvTypeInspectSize,
RoF::Null, RoF::invtype::InvTypeInspectSize,
RoF2::Null RoF2::invtype::InvTypeInspectSize
}, },
{ // local[TypeRealEstate] { // local[TypeRealEstate]
ClientUnknown::Null, ClientUnknown::Null,
@ -327,8 +327,8 @@ uint16 EQEmu::inventory::InventoryTypeSize(versions::InventoryVersion inventory_
SoF::Null, SoF::Null,
SoD::Null, SoD::Null,
UF::Null, UF::Null,
legacy::TYPE_REAL_ESTATE_SIZE, RoF::Null, //RoF::invtype::InvTypeRealEstateSize,
legacy::TYPE_REAL_ESTATE_SIZE, RoF2::Null, //RoF2::invtype::InvTypeRealEstateSize
EntityLimits::npc::Null, EntityLimits::npc::Null,
EntityLimits::merc::Null, EntityLimits::merc::Null,
EntityLimits::bot::Null, EntityLimits::bot::Null,
@ -343,92 +343,92 @@ uint16 EQEmu::inventory::InventoryTypeSize(versions::InventoryVersion inventory_
{ // local[TypeViewMODPC] { // local[TypeViewMODPC]
ClientUnknown::Null, ClientUnknown::Null,
Client62::Null, Client62::Null,
Titanium::Null, Titanium::invtype::InvTypeViewMODPCSize,
SoF::Null, SoF::invtype::InvTypeViewMODPCSize,
SoD::Null, SoD::invtype::InvTypeViewMODPCSize,
UF::Null, UF::invtype::InvTypeViewMODPCSize,
legacy::TYPE_VIEW_MOD_PC_SIZE, RoF::invtype::InvTypeViewMODPCSize,
legacy::TYPE_VIEW_MOD_PC_SIZE, RoF2::invtype::InvTypeViewMODPCSize,
EntityLimits::npc::Null, EntityLimits::npc::Null,
EntityLimits::merc::Null, EntityLimits::merc::Null,
EntityLimits::bot::Null, EntityLimits::bot::Null,
EntityLimits::pet::Null, EntityLimits::pet::Null,
Titanium::Null, Titanium::invtype::InvTypeViewMODPCSize,
SoF::Null, SoF::invtype::InvTypeViewMODPCSize,
SoD::Null, SoD::invtype::InvTypeViewMODPCSize,
UF::Null, UF::invtype::InvTypeViewMODPCSize,
RoF::Null, RoF::invtype::InvTypeViewMODPCSize,
RoF2::Null RoF2::invtype::InvTypeViewMODPCSize
}, },
{ // local[TypeViewMODBank] { // local[TypeViewMODBank]
ClientUnknown::Null, ClientUnknown::Null,
Client62::Null, Client62::Null,
Titanium::Null, Titanium::invtype::InvTypeViewMODBankSize,
SoF::Null, SoF::invtype::InvTypeViewMODBankSize,
SoD::Null, SoD::invtype::InvTypeViewMODBankSize,
UF::Null, UF::invtype::InvTypeViewMODBankSize,
legacy::TYPE_VIEW_MOD_BANK_SIZE, RoF::invtype::InvTypeViewMODBankSize,
legacy::TYPE_VIEW_MOD_BANK_SIZE, RoF2::invtype::InvTypeViewMODBankSize,
EntityLimits::npc::Null, EntityLimits::npc::Null,
EntityLimits::merc::Null, EntityLimits::merc::Null,
EntityLimits::bot::Null, EntityLimits::bot::Null,
EntityLimits::pet::Null, EntityLimits::pet::Null,
Titanium::Null, Titanium::invtype::InvTypeViewMODBankSize,
SoF::Null, SoF::invtype::InvTypeViewMODBankSize,
SoD::Null, SoD::invtype::InvTypeViewMODBankSize,
UF::Null, UF::invtype::InvTypeViewMODBankSize,
RoF::Null, RoF::invtype::InvTypeViewMODBankSize,
RoF2::Null RoF2::invtype::InvTypeViewMODBankSize
}, },
{ // local[TypeViewMODSharedBank] { // local[TypeViewMODSharedBank]
ClientUnknown::Null, ClientUnknown::Null,
Client62::Null, Client62::Null,
Titanium::Null, Titanium::invtype::InvTypeViewMODSharedBankSize,
SoF::Null, SoF::invtype::InvTypeViewMODSharedBankSize,
SoD::Null, SoD::invtype::InvTypeViewMODSharedBankSize,
UF::Null, UF::invtype::InvTypeViewMODSharedBankSize,
legacy::TYPE_VIEW_MOD_SHARED_BANK_SIZE, RoF::invtype::InvTypeViewMODSharedBankSize,
legacy::TYPE_VIEW_MOD_SHARED_BANK_SIZE, RoF2::invtype::InvTypeViewMODSharedBankSize,
EntityLimits::npc::Null, EntityLimits::npc::Null,
EntityLimits::merc::Null, EntityLimits::merc::Null,
EntityLimits::bot::Null, EntityLimits::bot::Null,
EntityLimits::pet::Null, EntityLimits::pet::Null,
Titanium::Null, Titanium::invtype::InvTypeViewMODSharedBankSize,
SoF::Null, SoF::invtype::InvTypeViewMODSharedBankSize,
SoD::Null, SoD::invtype::InvTypeViewMODSharedBankSize,
UF::Null, UF::invtype::InvTypeViewMODSharedBankSize,
RoF::Null, RoF::invtype::InvTypeViewMODSharedBankSize,
RoF2::Null RoF2::invtype::InvTypeViewMODSharedBankSize
}, },
{ // local[TypeViewMODLimbo] { // local[TypeViewMODLimbo]
ClientUnknown::Null, ClientUnknown::Null,
Client62::Null, Client62::Null,
Titanium::Null, Titanium::invtype::InvTypeViewMODLimboSize,
SoF::Null, SoF::invtype::InvTypeViewMODLimboSize,
SoD::Null, SoD::invtype::InvTypeViewMODLimboSize,
UF::Null, UF::invtype::InvTypeViewMODLimboSize,
legacy::TYPE_VIEW_MOD_LIMBO_SIZE, RoF::invtype::InvTypeViewMODLimboSize,
legacy::TYPE_VIEW_MOD_LIMBO_SIZE, RoF2::invtype::InvTypeViewMODLimboSize,
EntityLimits::npc::Null, EntityLimits::npc::Null,
EntityLimits::merc::Null, EntityLimits::merc::Null,
EntityLimits::bot::Null, EntityLimits::bot::Null,
EntityLimits::pet::Null, EntityLimits::pet::Null,
Titanium::Null, Titanium::invtype::InvTypeViewMODLimboSize,
SoF::Null, SoF::invtype::InvTypeViewMODLimboSize,
SoD::Null, SoD::invtype::InvTypeViewMODLimboSize,
UF::Null, UF::invtype::InvTypeViewMODLimboSize,
RoF::Null, RoF::invtype::InvTypeViewMODLimboSize,
RoF2::Null RoF2::invtype::InvTypeViewMODLimboSize
}, },
{ // local[TypeAltStorage] { // local[TypeAltStorage]
ClientUnknown::Null, ClientUnknown::Null,
Client62::Null, Client62::Null,
Titanium::Null, Titanium::invtype::InvTypeAltStorageSize,
SoF::Null, SoF::invtype::InvTypeAltStorageSize,
SoD::Null, SoD::invtype::InvTypeAltStorageSize,
UF::Null, UF::invtype::InvTypeAltStorageSize,
legacy::TYPE_ALT_STORAGE_SIZE, RoF::invtype::InvTypeAltStorageSize,
legacy::TYPE_ALT_STORAGE_SIZE, RoF2::invtype::InvTypeAltStorageSize,
EntityLimits::npc::Null, EntityLimits::npc::Null,
EntityLimits::merc::Null, EntityLimits::merc::Null,
EntityLimits::bot::Null, EntityLimits::bot::Null,
@ -443,12 +443,12 @@ uint16 EQEmu::inventory::InventoryTypeSize(versions::InventoryVersion inventory_
{ // local[TypeArchived] { // local[TypeArchived]
ClientUnknown::Null, ClientUnknown::Null,
Client62::Null, Client62::Null,
Titanium::Null, Titanium::invtype::InvTypeArchivedSize,
SoF::Null, SoF::invtype::InvTypeArchivedSize,
SoD::Null, SoD::invtype::InvTypeArchivedSize,
UF::Null, UF::invtype::InvTypeArchivedSize,
legacy::TYPE_ARCHIVED_SIZE, RoF::invtype::InvTypeArchivedSize,
legacy::TYPE_ARCHIVED_SIZE, RoF2::invtype::InvTypeArchivedSize,
EntityLimits::npc::Null, EntityLimits::npc::Null,
EntityLimits::merc::Null, EntityLimits::merc::Null,
EntityLimits::bot::Null, EntityLimits::bot::Null,
@ -467,8 +467,8 @@ uint16 EQEmu::inventory::InventoryTypeSize(versions::InventoryVersion inventory_
SoF::Null, SoF::Null,
SoD::Null, SoD::Null,
UF::Null, UF::Null,
legacy::TYPE_MAIL_SIZE, RoF::invtype::InvTypeMailSize,
legacy::TYPE_MAIL_SIZE, RoF2::invtype::InvTypeMailSize,
EntityLimits::npc::Null, EntityLimits::npc::Null,
EntityLimits::merc::Null, EntityLimits::merc::Null,
EntityLimits::bot::Null, EntityLimits::bot::Null,
@ -487,8 +487,8 @@ uint16 EQEmu::inventory::InventoryTypeSize(versions::InventoryVersion inventory_
SoF::Null, SoF::Null,
SoD::Null, SoD::Null,
UF::Null, UF::Null,
legacy::TYPE_GUILD_TROPHY_TRIBUTE_SIZE, RoF::invtype::InvTypeGuildTrophyTributeSize,
legacy::TYPE_GUILD_TROPHY_TRIBUTE_SIZE, RoF2::invtype::InvTypeGuildTrophyTributeSize,
EntityLimits::npc::Null, EntityLimits::npc::Null,
EntityLimits::merc::Null, EntityLimits::merc::Null,
EntityLimits::bot::Null, EntityLimits::bot::Null,
@ -507,8 +507,8 @@ uint16 EQEmu::inventory::InventoryTypeSize(versions::InventoryVersion inventory_
SoF::Null, SoF::Null,
SoD::Null, SoD::Null,
UF::Null, UF::Null,
legacy::TYPE_KRONO_SIZE, RoF::Null,
legacy::TYPE_KRONO_SIZE, RoF2::invtype::InvTypeKronoSize,
EntityLimits::npc::Null, EntityLimits::npc::Null,
EntityLimits::merc::Null, EntityLimits::merc::Null,
EntityLimits::bot::Null, EntityLimits::bot::Null,
@ -523,12 +523,12 @@ uint16 EQEmu::inventory::InventoryTypeSize(versions::InventoryVersion inventory_
{ // local[TypeOther] { // local[TypeOther]
ClientUnknown::Null, ClientUnknown::Null,
Client62::Null, Client62::Null,
Titanium::Null, Titanium::invtype::InvTypeOtherSize,
SoF::Null, SoF::invtype::InvTypeOtherSize,
SoD::Null, SoD::invtype::InvTypeOtherSize,
UF::Null, UF::invtype::InvTypeOtherSize,
legacy::TYPE_OTHER_SIZE, RoF::invtype::InvTypeOtherSize,
legacy::TYPE_OTHER_SIZE, RoF2::invtype::InvTypeOtherSize,
EntityLimits::npc::Null, EntityLimits::npc::Null,
EntityLimits::merc::Null, EntityLimits::merc::Null,
EntityLimits::bot::Null, EntityLimits::bot::Null,
@ -542,23 +542,23 @@ uint16 EQEmu::inventory::InventoryTypeSize(versions::InventoryVersion inventory_
} }
}; };
if ((uint16)inv_type < legacy::TypeCount) if (inv_type < 0 || inv_type >= legacy::TypeCount)
return local[inv_type][static_cast<size_t>(versions::ValidateInventoryVersion(inventory_version))]; return 0;
return NOT_USED; return local[inv_type][static_cast<size_t>(versions::ValidateInventoryVersion(inventory_version))];
} }
uint64 EQEmu::inventory::PossessionsBitmask(versions::InventoryVersion inventory_version) uint64 EQEmu::inventory::GetPossessionsBitmask(versions::InventoryVersion inventory_version)
{ {
static const uint64 local[versions::InventoryVersionCount] = { static const uint64 local[versions::InventoryVersionCount] = {
ClientUnknown::Null, ClientUnknown::Null,
Client62::Null, Client62::Null,
0x000000027FDFFFFF, Titanium::Null, //0x000000027FDFFFFF,
0x000000027FFFFFFF, SoF::Null, //0x000000027FFFFFFF,
0x000000027FFFFFFF, SoD::Null, //0x000000027FFFFFFF,
0x000000027FFFFFFF, UF::Null, //0x000000027FFFFFFF,
0x00000003FFFFFFFF, RoF::Null, //0x00000003FFFFFFFF,
0x00000003FFFFFFFF, RoF2::Null, //0x00000003FFFFFFFF,
EntityLimits::npc::Null, EntityLimits::npc::Null,
EntityLimits::merc::Null, EntityLimits::merc::Null,
EntityLimits::bot::Null, EntityLimits::bot::Null,
@ -571,48 +571,20 @@ uint64 EQEmu::inventory::PossessionsBitmask(versions::InventoryVersion inventory
RoF2::Null RoF2::Null
}; };
return NOT_USED; return local[static_cast<size_t>(versions::ValidateInventoryVersion(inventory_version))];
//return local[static_cast<size_t>(versions::ValidateInventoryVersion(inventory_version))];
} }
bool EQEmu::inventory::AllowEmptyBagInBag(versions::InventoryVersion inventory_version) bool EQEmu::inventory::GetAllowEmptyBagInBag(versions::InventoryVersion inventory_version)
{ {
static const bool local[versions::InventoryVersionCount] = { static const bool local[versions::InventoryVersionCount] = {
ClientUnknown::False, ClientUnknown::False,
Client62::False, Client62::False,
Titanium::behavior::AllowEmptyBagInBag, Titanium::inventory::AllowEmptyBagInBag,
SoF::behavior::AllowEmptyBagInBag, SoF::inventory::AllowEmptyBagInBag,
SoD::behavior::AllowEmptyBagInBag, SoD::inventory::AllowEmptyBagInBag,
UF::behavior::AllowEmptyBagInBag, UF::inventory::AllowEmptyBagInBag,
RoF::behavior::AllowEmptyBagInBag, RoF::False, //RoF::inventory::AllowEmptyBagInBag,
RoF2::behavior::AllowEmptyBagInBag, RoF2::False, //RoF2::inventory::AllowEmptyBagInBag,
EntityLimits::npc::False,
EntityLimits::merc::False,
EntityLimits::bot::False,
EntityLimits::pet::False,
Titanium::False,
SoF::False,
SoD::False,
UF::False,
RoF::False,
RoF2::False
};
return false;
//return local[static_cast<size_t>(versions::ValidateInventoryVersion(inventory_version))];
}
bool EQEmu::inventory::AllowClickCastFromBag(versions::InventoryVersion inventory_version)
{
static const bool local[versions::InventoryVersionCount] = {
ClientUnknown::False,
Client62::False,
Titanium::behavior::AllowClickCastFromBag,
SoF::behavior::AllowClickCastFromBag,
SoD::behavior::AllowClickCastFromBag,
UF::behavior::AllowClickCastFromBag,
RoF::behavior::AllowClickCastFromBag,
RoF2::behavior::AllowClickCastFromBag,
EntityLimits::npc::False, EntityLimits::npc::False,
EntityLimits::merc::False, EntityLimits::merc::False,
EntityLimits::bot::False, EntityLimits::bot::False,
@ -628,21 +600,99 @@ bool EQEmu::inventory::AllowClickCastFromBag(versions::InventoryVersion inventor
return local[static_cast<size_t>(versions::ValidateInventoryVersion(inventory_version))]; return local[static_cast<size_t>(versions::ValidateInventoryVersion(inventory_version))];
} }
uint16 EQEmu::inventory::ItemAugSize(versions::InventoryVersion inventory_version) bool EQEmu::inventory::GetAllowClickCastFromBag(versions::InventoryVersion inventory_version)
{ {
static const uint16 local[versions::InventoryVersionCount] = { static const bool local[versions::InventoryVersionCount] = {
ClientUnknown::False,
Client62::False,
Titanium::inventory::AllowClickCastFromBag,
SoF::inventory::AllowClickCastFromBag,
SoD::inventory::AllowClickCastFromBag,
UF::inventory::AllowClickCastFromBag,
RoF::inventory::AllowClickCastFromBag,
RoF2::inventory::AllowClickCastFromBag,
EntityLimits::npc::False,
EntityLimits::merc::False,
EntityLimits::bot::False,
EntityLimits::pet::False,
Titanium::False,
SoF::False,
SoD::False,
UF::False,
RoF::False,
RoF2::False
};
return local[static_cast<size_t>(versions::ValidateInventoryVersion(inventory_version))];
}
bool EQEmu::inventory::GetConcatenateInvTypeLimbo(versions::InventoryVersion inventory_version)
{
static const bool local[versions::InventoryVersionCount] = {
ClientUnknown::False,
Client62::False,
Titanium::inventory::ConcatenateInvTypeLimbo,
SoF::inventory::ConcatenateInvTypeLimbo,
SoD::inventory::ConcatenateInvTypeLimbo,
UF::inventory::ConcatenateInvTypeLimbo,
RoF::inventory::ConcatenateInvTypeLimbo,
RoF2::inventory::ConcatenateInvTypeLimbo,
EntityLimits::npc::False,
EntityLimits::merc::False,
EntityLimits::bot::False,
EntityLimits::pet::False,
Titanium::False,
SoF::False,
SoD::False,
UF::False,
RoF::False,
RoF2::False
};
return local[static_cast<size_t>(versions::ValidateInventoryVersion(inventory_version))];
}
bool EQEmu::inventory::GetAllowOverLevelEquipment(versions::InventoryVersion inventory_version)
{
static const bool local[versions::InventoryVersionCount] = {
ClientUnknown::False,
Client62::False,
Titanium::inventory::AllowOverLevelEquipment,
SoF::inventory::AllowOverLevelEquipment,
SoD::inventory::AllowOverLevelEquipment,
UF::inventory::AllowOverLevelEquipment,
RoF::inventory::AllowOverLevelEquipment,
RoF2::inventory::AllowOverLevelEquipment,
EntityLimits::npc::False,
EntityLimits::merc::False,
EntityLimits::bot::False,
EntityLimits::pet::False,
Titanium::False,
SoF::False,
SoD::False,
UF::False,
RoF::False,
RoF2::False
};
return local[static_cast<size_t>(versions::ValidateInventoryVersion(inventory_version))];
}
size_t EQEmu::inventory::GetItemAugSize(versions::InventoryVersion inventory_version)
{
static const size_t local[versions::InventoryVersionCount] = {
ClientUnknown::Null, ClientUnknown::Null,
Client62::Null, Client62::Null,
legacy::ITEM_COMMON_SIZE, legacy::ITEM_COMMON_SIZE, //Titanium::invaug::ItemAugSize,
legacy::ITEM_COMMON_SIZE, legacy::ITEM_COMMON_SIZE, //SoF::invaug::ItemAugSize,
legacy::ITEM_COMMON_SIZE, legacy::ITEM_COMMON_SIZE, //SoD::invaug::ItemAugSize,
legacy::ITEM_COMMON_SIZE, legacy::ITEM_COMMON_SIZE, //UF::invaug::ItemAugSize,
legacy::ITEM_COMMON_SIZE, legacy::ITEM_COMMON_SIZE, //RoF::invaug::ItemAugSize,
legacy::ITEM_COMMON_SIZE, legacy::ITEM_COMMON_SIZE, //RoF2::invaug::ItemAugSize,
legacy::ITEM_COMMON_SIZE, legacy::ITEM_COMMON_SIZE, //ItemAugSize,
legacy::ITEM_COMMON_SIZE, legacy::ITEM_COMMON_SIZE, //ItemAugSize,
legacy::ITEM_COMMON_SIZE, legacy::ITEM_COMMON_SIZE, //ItemAugSize,
legacy::ITEM_COMMON_SIZE, legacy::ITEM_COMMON_SIZE, //ItemAugSize,
Titanium::Null, Titanium::Null,
SoF::Null, SoF::Null,
SoD::Null, SoD::Null,
@ -654,33 +704,33 @@ uint16 EQEmu::inventory::ItemAugSize(versions::InventoryVersion inventory_versio
return local[static_cast<size_t>(versions::ValidateInventoryVersion(inventory_version))]; return local[static_cast<size_t>(versions::ValidateInventoryVersion(inventory_version))];
} }
uint16 EQEmu::inventory::ItemBagSize(versions::InventoryVersion inventory_version) size_t EQEmu::inventory::GetItemBagSize(versions::InventoryVersion inventory_version)
{ {
static const uint16 local[versions::InventoryVersionCount] = { static const size_t local[versions::InventoryVersionCount] = {
ClientUnknown::Null, ClientUnknown::Null,
Client62::Null, Client62::Null,
legacy::ITEM_CONTAINER_SIZE, legacy::ITEM_CONTAINER_SIZE, //Titanium::invbag::ItemBagSize,
legacy::ITEM_CONTAINER_SIZE, legacy::ITEM_CONTAINER_SIZE, //SoF::invbag::ItemBagSize,
legacy::ITEM_CONTAINER_SIZE, legacy::ITEM_CONTAINER_SIZE, //SoD::invbag::ItemBagSize,
legacy::ITEM_CONTAINER_SIZE, legacy::ITEM_CONTAINER_SIZE, //UF::invbag::ItemBagSize,
legacy::ITEM_CONTAINER_SIZE, legacy::ITEM_CONTAINER_SIZE, //RoF::invbag::ItemBagSize,
legacy::ITEM_CONTAINER_SIZE, legacy::ITEM_CONTAINER_SIZE, //RoF2::invbag::ItemBagSize,
legacy::ITEM_CONTAINER_SIZE, legacy::ITEM_CONTAINER_SIZE, //ItemBagSize,
legacy::ITEM_CONTAINER_SIZE, legacy::ITEM_CONTAINER_SIZE, //ItemBagSize,
legacy::ITEM_CONTAINER_SIZE, legacy::ITEM_CONTAINER_SIZE, //ItemBagSize,
legacy::ITEM_CONTAINER_SIZE, legacy::ITEM_CONTAINER_SIZE, //ItemBagSize,
Titanium::Null, legacy::ITEM_CONTAINER_SIZE, //Titanium::Null,
SoF::Null, legacy::ITEM_CONTAINER_SIZE, //SoF::Null,
SoD::Null, legacy::ITEM_CONTAINER_SIZE, //SoD::Null,
UF::Null, legacy::ITEM_CONTAINER_SIZE, //UF::Null,
RoF::Null, legacy::ITEM_CONTAINER_SIZE, //RoF::Null,
RoF2::Null legacy::ITEM_CONTAINER_SIZE, //RoF2::Null
}; };
return local[static_cast<size_t>(versions::ValidateInventoryVersion(inventory_version))]; return local[static_cast<size_t>(versions::ValidateInventoryVersion(inventory_version))];
} }
bool EQEmu::profile::CoinHasWeight(versions::InventoryVersion inventory_version) bool EQEmu::behavior::GetCoinHasWeight(versions::InventoryVersion inventory_version)
{ {
static const bool local[versions::InventoryVersionCount] = { static const bool local[versions::InventoryVersionCount] = {
ClientUnknown::True, ClientUnknown::True,
@ -691,10 +741,10 @@ bool EQEmu::profile::CoinHasWeight(versions::InventoryVersion inventory_version)
UF::behavior::CoinHasWeight, UF::behavior::CoinHasWeight,
RoF::behavior::CoinHasWeight, RoF::behavior::CoinHasWeight,
RoF::behavior::CoinHasWeight, RoF::behavior::CoinHasWeight,
EntityLimits::npc::True, EntityLimits::npc::True, //CoinHasWeight,
EntityLimits::merc::True, EntityLimits::merc::True, //CoinHasWeight,
EntityLimits::bot::True, EntityLimits::bot::True, //CoinHasWeight,
EntityLimits::pet::True, EntityLimits::pet::True, //CoinHasWeight,
Titanium::False, Titanium::False,
SoF::False, SoF::False,
SoD::False, SoD::False,

28
common/eq_limits.h
View File

@ -1,4 +1,4 @@
/* EQEMu: Everquest Server Emulator /* EQEMu: Everquest Server Emulator
Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net) Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
@ -10,7 +10,7 @@
but WITHOUT ANY WARRANTY except by those people which sell it, which but WITHOUT ANY WARRANTY except by those people which sell it, which
are required to give you total support for your newly bought product; are required to give you total support for your newly bought product;
without even the implied warranty of MERCHANTABILITY or FITNESS FOR without even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE. See the GNU General Public License for more details. A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software along with this program; if not, write to the Free Software
@ -34,30 +34,30 @@
namespace EQEmu namespace EQEmu
{ {
namespace constants { namespace constants {
extern size_t CharacterCreationLimit(versions::ClientVersion client_version); extern size_t GetCharacterCreationLimit(versions::ClientVersion client_version);
} /*constants*/ } /*constants*/
namespace inventory { namespace inventory {
extern uint16 InventoryTypeSize(versions::InventoryVersion inventory_version, int16 inv_type); extern size_t GetInventoryTypeSize(versions::InventoryVersion inventory_version, int inv_type);
extern uint64 PossessionsBitmask(versions::InventoryVersion inventory_version); extern uint64 GetPossessionsBitmask(versions::InventoryVersion inventory_version);
extern bool AllowEmptyBagInBag(versions::InventoryVersion inventory_version); extern bool GetAllowEmptyBagInBag(versions::InventoryVersion inventory_version);
extern bool AllowClickCastFromBag(versions::InventoryVersion inventory_version); extern bool GetAllowClickCastFromBag(versions::InventoryVersion inventory_version);
extern uint16 ItemAugSize(versions::InventoryVersion inventory_version); extern bool GetConcatenateInvTypeLimbo(versions::InventoryVersion inventory_version);
extern uint16 ItemBagSize(versions::InventoryVersion inventory_version);
extern bool ConcatenateInvTypeLimbo(versions::InventoryVersion inventory_version); extern bool GetAllowOverLevelEquipment(versions::InventoryVersion inventory_version);
extern bool AllowOverLevelEquipment(versions::InventoryVersion inventory_version); extern size_t GetItemAugSize(versions::InventoryVersion inventory_version);
extern size_t GetItemBagSize(versions::InventoryVersion inventory_version);
} /*inventory*/ } /*inventory*/
namespace profile { namespace behavior {
extern bool CoinHasWeight(versions::InventoryVersion inventory_version); extern bool GetCoinHasWeight(versions::InventoryVersion inventory_version);
} /*profile*/ } /*behavior*/
} /*EQEmu*/ } /*EQEmu*/

2
common/eq_packet_structs.h
View File

@ -1542,7 +1542,7 @@ enum ItemPacketType
// ItemPacketTributeItem = /*108*/ 0x6C, // ItemPacketTributeItem = /*108*/ 0x6C,
// ItemPacketGuildTribute = /*109*/ 0x6D, // missing from EQEmu // ItemPacketGuildTribute = /*109*/ 0x6D, // missing from EQEmu
// ItemPacket10 = /*110*/ 0x6E, // ItemPacket10 = /*110*/ 0x6E,
// ItemPacket11 = /*111*/ 0x6F, // UF+ (equipment slots only) (RoF+ checks '(WORD*)slot + 4 != -1' [(WORD*)]slot + 2 would be bag index - if used) (guess) // ItemPacket11 = /*111*/ 0x6F, // UF+ (equipment slots only) (RoF+ checks '(WORD*)slot + 4 != -1' [(WORD*)]slot + 2 would be bag index - if used) (guess) (appearance (over-level) items?)
// ItemPacket12 = /*112*/ 0x70, // RoF+ (causes stat update) (could be TrophyTribute and GuildTrophyTribute together - two case methodology - is it checking for GuildID?) // ItemPacket12 = /*112*/ 0x70, // RoF+ (causes stat update) (could be TrophyTribute and GuildTrophyTribute together - two case methodology - is it checking for GuildID?)
// ItemPacketMerchantRecovery = /*113*/ 0x71, // ItemPacketMerchantRecovery = /*113*/ 0x71,
// ItemPacket14 = /*115*/ 0x73, (real estate/moving crate?) // ItemPacket14 = /*115*/ 0x73, (real estate/moving crate?)

2
common/item.cpp
View File

@ -929,7 +929,7 @@ bool Inventory::SupportsClickCasting(int16 slot_id)
} }
else if (slot_id >= EQEmu::legacy::GENERAL_BAGS_BEGIN && slot_id <= EQEmu::legacy::GENERAL_BAGS_END) else if (slot_id >= EQEmu::legacy::GENERAL_BAGS_BEGIN && slot_id <= EQEmu::legacy::GENERAL_BAGS_END)
{ {
if (EQEmu::inventory::AllowClickCastFromBag(m_inventory_version)) if (EQEmu::inventory::GetAllowClickCastFromBag(m_inventory_version))
return true; return true;
} }

6
common/patches/rof.cpp
View File

@ -5641,11 +5641,11 @@ namespace RoF
{ {
structs::InventorySlot_Struct RoFSlot; structs::InventorySlot_Struct RoFSlot;
RoFSlot.Type = INVALID_INDEX; RoFSlot.Type = INVALID_INDEX;
RoFSlot.Unknown02 = NOT_USED; RoFSlot.Unknown02 = 0;
RoFSlot.Slot = INVALID_INDEX; RoFSlot.Slot = INVALID_INDEX;
RoFSlot.SubIndex = INVALID_INDEX; RoFSlot.SubIndex = INVALID_INDEX;
RoFSlot.AugIndex = INVALID_INDEX; RoFSlot.AugIndex = INVALID_INDEX;
RoFSlot.Unknown01 = NOT_USED; RoFSlot.Unknown01 = 0;
uint32 TempSlot = 0; uint32 TempSlot = 0;
@ -5746,7 +5746,7 @@ namespace RoF
RoFSlot.Slot = INVALID_INDEX; RoFSlot.Slot = INVALID_INDEX;
RoFSlot.SubIndex = INVALID_INDEX; RoFSlot.SubIndex = INVALID_INDEX;
RoFSlot.AugIndex = INVALID_INDEX; RoFSlot.AugIndex = INVALID_INDEX;
RoFSlot.Unknown01 = NOT_USED; RoFSlot.Unknown01 = 0;
uint32 TempSlot = 0; uint32 TempSlot = 0;

6
common/patches/rof2.cpp
View File

@ -5926,11 +5926,11 @@ namespace RoF2
{ {
structs::InventorySlot_Struct RoF2Slot; structs::InventorySlot_Struct RoF2Slot;
RoF2Slot.Type = INVALID_INDEX; RoF2Slot.Type = INVALID_INDEX;
RoF2Slot.Unknown02 = NOT_USED; RoF2Slot.Unknown02 = 0;
RoF2Slot.Slot = INVALID_INDEX; RoF2Slot.Slot = INVALID_INDEX;
RoF2Slot.SubIndex = INVALID_INDEX; RoF2Slot.SubIndex = INVALID_INDEX;
RoF2Slot.AugIndex = INVALID_INDEX; RoF2Slot.AugIndex = INVALID_INDEX;
RoF2Slot.Unknown01 = NOT_USED; RoF2Slot.Unknown01 = 0;
uint32 TempSlot = 0; uint32 TempSlot = 0;
@ -6039,7 +6039,7 @@ namespace RoF2
RoF2Slot.Slot = INVALID_INDEX; RoF2Slot.Slot = INVALID_INDEX;
RoF2Slot.SubIndex = INVALID_INDEX; RoF2Slot.SubIndex = INVALID_INDEX;
RoF2Slot.AugIndex = INVALID_INDEX; RoF2Slot.AugIndex = INVALID_INDEX;
RoF2Slot.Unknown01 = NOT_USED; RoF2Slot.Unknown01 = 0;
uint32 TempSlot = 0; uint32 TempSlot = 0;

18
common/patches/rof2_limits.cpp
View File

@ -10,7 +10,7 @@
but WITHOUT ANY WARRANTY except by those people which sell it, which but WITHOUT ANY WARRANTY except by those people which sell it, which
are required to give you total support for your newly bought product; are required to give you total support for your newly bought product;
without even the implied warranty of MERCHANTABILITY or FITNESS FOR without even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE. See the GNU General Public License for more details. A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software along with this program; if not, write to the Free Software
@ -22,7 +22,7 @@
#include "../string_util.h" #include "../string_util.h"
size_t RoF2::invtype::InvTypeSize(int inv_type) size_t RoF2::invtype::GetInvTypeSize(int inv_type)
{ {
switch (inv_type) { switch (inv_type) {
case invtype::InvTypePossessions: case invtype::InvTypePossessions:
@ -80,7 +80,7 @@ size_t RoF2::invtype::InvTypeSize(int inv_type)
} }
} }
const char* RoF2::invtype::InvTypeName(int inv_type) const char* RoF2::invtype::GetInvTypeName(int inv_type)
{ {
switch (inv_type) { switch (inv_type) {
case invtype::InvTypeInvalid: case invtype::InvTypeInvalid:
@ -140,7 +140,7 @@ const char* RoF2::invtype::InvTypeName(int inv_type)
} }
} }
const char* RoF2::invslot::InvPossessionsSlotName(int inv_slot) const char* RoF2::invslot::GetInvPossessionsSlotName(int inv_slot)
{ {
switch (inv_slot) { switch (inv_slot) {
case invslot::InvSlotInvalid: case invslot::InvSlotInvalid:
@ -218,12 +218,12 @@ const char* RoF2::invslot::InvPossessionsSlotName(int inv_slot)
} }
} }
const char* RoF2::invslot::InvSlotName(int inv_type, int inv_slot) const char* RoF2::invslot::GetInvSlotName(int inv_type, int inv_slot)
{ {
if (inv_type == invtype::InvTypePossessions) if (inv_type == invtype::InvTypePossessions)
return invslot::InvPossessionsSlotName(inv_slot); return invslot::GetInvPossessionsSlotName(inv_slot);
size_t type_size = invtype::InvTypeSize(inv_type); size_t type_size = invtype::GetInvTypeSize(inv_type);
if (!type_size || inv_slot == invslot::InvSlotInvalid) if (!type_size || inv_slot == invslot::InvSlotInvalid)
return "Invalid Slot"; return "Invalid Slot";
@ -237,7 +237,7 @@ const char* RoF2::invslot::InvSlotName(int inv_type, int inv_slot)
return ret_str.c_str(); return ret_str.c_str();
} }
const char* RoF2::invbag::InvBagIndexName(int bag_index) const char* RoF2::invbag::GetInvBagIndexName(int bag_index)
{ {
if (bag_index == invbag::InvBagInvalid) if (bag_index == invbag::InvBagInvalid)
return "Invalid Bag"; return "Invalid Bag";
@ -251,7 +251,7 @@ const char* RoF2::invbag::InvBagIndexName(int bag_index)
return ret_str.c_str(); return ret_str.c_str();
} }
const char* RoF2::invaug::InvAugIndexName(int aug_index) const char* RoF2::invaug::GetInvAugIndexName(int aug_index)
{ {
if (aug_index == invaug::InvAugInvalid) if (aug_index == invaug::InvAugInvalid)
return "Invalid Augment"; return "Invalid Augment";

54
common/patches/rof2_limits.h
View File

@ -10,7 +10,7 @@
but WITHOUT ANY WARRANTY except by those people which sell it, which but WITHOUT ANY WARRANTY except by those people which sell it, which
are required to give you total support for your newly bought product; are required to give you total support for your newly bought product;
without even the implied warranty of MERCHANTABILITY or FITNESS FOR without even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE. See the GNU General Public License for more details. A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software along with this program; if not, write to the Free Software
@ -32,8 +32,13 @@ namespace RoF2
enum : bool { False = false, True = true }; enum : bool { False = false, True = true };
// pre-declarations // pre-declarations
namespace inventory {
inline EQEmu::versions::ClientVersion GetInventoryRef() { return EQEmu::versions::ClientVersion::RoF2; }
} /*inventory*/
namespace invtype { namespace invtype {
inline EQEmu::versions::ClientVersion InvTypeRef() { return EQEmu::versions::ClientVersion::RoF2; } inline EQEmu::versions::ClientVersion GetInvTypeRef() { return EQEmu::versions::ClientVersion::RoF2; }
enum : int { InvTypeInvalid = -1, InvTypeBegin }; enum : int { InvTypeInvalid = -1, InvTypeBegin };
@ -69,7 +74,7 @@ namespace RoF2
} /*invtype*/ } /*invtype*/
namespace invslot { namespace invslot {
inline EQEmu::versions::ClientVersion InvSlotRef() { return EQEmu::versions::ClientVersion::RoF2; } inline EQEmu::versions::ClientVersion GetInvSlotRef() { return EQEmu::versions::ClientVersion::RoF2; }
enum : int { InvSlotInvalid = -1, InvSlotBegin }; enum : int { InvSlotInvalid = -1, InvSlotBegin };
@ -122,21 +127,21 @@ namespace RoF2
} /*invslot*/ } /*invslot*/
namespace invbag { namespace invbag {
inline EQEmu::versions::ClientVersion InvBagRef() { return EQEmu::versions::ClientVersion::RoF2; } inline EQEmu::versions::ClientVersion GetInvBagRef() { return EQEmu::versions::ClientVersion::RoF2; }
enum : int { InvBagInvalid = -1, InvBagBegin }; enum : int { InvBagInvalid = -1, InvBagBegin };
} /*invbag*/ } /*invbag*/
namespace invaug { namespace invaug {
inline EQEmu::versions::ClientVersion InvAugRef() { return EQEmu::versions::ClientVersion::RoF2; } inline EQEmu::versions::ClientVersion GetInvAugRef() { return EQEmu::versions::ClientVersion::RoF2; }
enum : int { InvAugInvalid = -1, InvAugBegin }; enum : int { InvAugInvalid = -1, InvAugBegin };
} /*invaug*/ } /*invaug*/
namespace item { namespace item {
inline EQEmu::versions::ClientVersion ItemRef() { return EQEmu::versions::ClientVersion::RoF2; } inline EQEmu::versions::ClientVersion GetItemRef() { return EQEmu::versions::ClientVersion::RoF2; }
//enum Unknown : int { // looks like item class..but, RoF has it too - nothing in UF- //enum Unknown : int { // looks like item class..but, RoF has it too - nothing in UF-
// Unknown1 = 0, // Unknown1 = 0,
@ -165,27 +170,37 @@ namespace RoF2
} /*item*/ } /*item*/
namespace profile { namespace profile {
inline EQEmu::versions::ClientVersion ProfileRef() { return EQEmu::versions::ClientVersion::RoF2; } inline EQEmu::versions::ClientVersion GetProfileRef() { return EQEmu::versions::ClientVersion::RoF2; }
} /*profile*/ } /*profile*/
namespace constants { namespace constants {
inline EQEmu::versions::ClientVersion ConstantsRef() { return EQEmu::versions::ClientVersion::RoF2; } inline EQEmu::versions::ClientVersion GetConstantsRef() { return EQEmu::versions::ClientVersion::RoF2; }
} /*constants*/ } /*constants*/
namespace behavior { namespace behavior {
inline EQEmu::versions::ClientVersion BehaviorRef() { return EQEmu::versions::ClientVersion::RoF2; } inline EQEmu::versions::ClientVersion GetBehaviorRef() { return EQEmu::versions::ClientVersion::RoF2; }
} /*behavior*/ } /*behavior*/
namespace skills { namespace skills {
inline EQEmu::versions::ClientVersion SkillsRef() { return EQEmu::versions::ClientVersion::RoF2; } inline EQEmu::versions::ClientVersion GetSkillsRef() { return EQEmu::versions::ClientVersion::RoF2; }
} /*skills*/ } /*skills*/
// declarations // declarations
namespace inventory {
const bool ConcatenateInvTypeLimbo = false;
const bool AllowOverLevelEquipment = true;
const bool AllowEmptyBagInBag = true;
const bool AllowClickCastFromBag = true;
} /*inventory*/
namespace invtype { namespace invtype {
const size_t InvTypePossessionsSize = invslot::PossessionsCount; const size_t InvTypePossessionsSize = invslot::PossessionsCount;
const size_t InvTypeBankSize = 24; const size_t InvTypeBankSize = 24;
@ -215,28 +230,28 @@ namespace RoF2
const size_t NPCTradeSize = 4; const size_t NPCTradeSize = 4;
extern size_t InvTypeSize(int inv_type); extern size_t GetInvTypeSize(int inv_type);
extern const char* InvTypeName(int inv_type); extern const char* GetInvTypeName(int inv_type);
} /*invtype*/ } /*invtype*/
namespace invslot { namespace invslot {
extern const char* InvPossessionsSlotName(int inv_slot); extern const char* GetInvPossessionsSlotName(int inv_slot);
extern const char* InvSlotName(int inv_type, int inv_slot); extern const char* GetInvSlotName(int inv_type, int inv_slot);
} /*invslot*/ } /*invslot*/
namespace invbag { namespace invbag {
const size_t ItemBagSize = 255; // server Size will be 255..unsure what actual client is (test) const size_t ItemBagSize = 255; // server Size will be 255..unsure what actual client is (test)
extern const char* InvBagIndexName(int bag_index); extern const char* GetInvBagIndexName(int bag_index);
} /*invbag*/ } /*invbag*/
namespace invaug { namespace invaug {
const size_t ItemAugSize = 6; const size_t ItemAugSize = 6;
extern const char* InvAugIndexName(int aug_index); extern const char* GetInvAugIndexName(int aug_index);
} /*invaug*/ } /*invaug*/
@ -264,13 +279,6 @@ namespace RoF2
} /*constants*/ } /*constants*/
namespace behavior { namespace behavior {
const bool ConcatenateInvTypeLimbo = false;
const bool AllowOverLevelEquipment = true;
const bool AllowEmptyBagInBag = true;
const bool AllowClickCastFromBag = true;
const bool CoinHasWeight = false; const bool CoinHasWeight = false;
} /*behavior*/ } /*behavior*/

18
common/patches/rof_limits.cpp
View File

@ -10,7 +10,7 @@
but WITHOUT ANY WARRANTY except by those people which sell it, which but WITHOUT ANY WARRANTY except by those people which sell it, which
are required to give you total support for your newly bought product; are required to give you total support for your newly bought product;
without even the implied warranty of MERCHANTABILITY or FITNESS FOR without even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE. See the GNU General Public License for more details. A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software along with this program; if not, write to the Free Software
@ -22,7 +22,7 @@
#include "../string_util.h" #include "../string_util.h"
size_t RoF::invtype::InvTypeSize(int inv_type) size_t RoF::invtype::GetInvTypeSize(int inv_type)
{ {
switch (inv_type) { switch (inv_type) {
case invtype::InvTypePossessions: case invtype::InvTypePossessions:
@ -78,7 +78,7 @@ size_t RoF::invtype::InvTypeSize(int inv_type)
} }
} }
const char* RoF::invtype::InvTypeName(int inv_type) const char* RoF::invtype::GetInvTypeName(int inv_type)
{ {
switch (inv_type) { switch (inv_type) {
case invtype::InvTypeInvalid: case invtype::InvTypeInvalid:
@ -136,7 +136,7 @@ const char* RoF::invtype::InvTypeName(int inv_type)
} }
} }
const char* RoF::invslot::InvPossessionsSlotName(int inv_slot) const char* RoF::invslot::GetInvPossessionsSlotName(int inv_slot)
{ {
switch (inv_slot) { switch (inv_slot) {
case invslot::InvSlotInvalid: case invslot::InvSlotInvalid:
@ -214,12 +214,12 @@ const char* RoF::invslot::InvPossessionsSlotName(int inv_slot)
} }
} }
const char* RoF::invslot::InvSlotName(int inv_type, int inv_slot) const char* RoF::invslot::GetInvSlotName(int inv_type, int inv_slot)
{ {
if (inv_type == invtype::InvTypePossessions) if (inv_type == invtype::InvTypePossessions)
return invslot::InvPossessionsSlotName(inv_slot); return invslot::GetInvPossessionsSlotName(inv_slot);
size_t type_size = invtype::InvTypeSize(inv_type); size_t type_size = invtype::GetInvTypeSize(inv_type);
if (!type_size || inv_slot == invslot::InvSlotInvalid) if (!type_size || inv_slot == invslot::InvSlotInvalid)
return "Invalid Slot"; return "Invalid Slot";
@ -233,7 +233,7 @@ const char* RoF::invslot::InvSlotName(int inv_type, int inv_slot)
return ret_str.c_str(); return ret_str.c_str();
} }
const char* RoF::invbag::InvBagIndexName(int bag_index) const char* RoF::invbag::GetInvBagIndexName(int bag_index)
{ {
if (bag_index == invbag::InvBagInvalid) if (bag_index == invbag::InvBagInvalid)
return "Invalid Bag"; return "Invalid Bag";
@ -247,7 +247,7 @@ const char* RoF::invbag::InvBagIndexName(int bag_index)
return ret_str.c_str(); return ret_str.c_str();
} }
const char* RoF::invaug::InvAugIndexName(int aug_index) const char* RoF::invaug::GetInvAugIndexName(int aug_index)
{ {
if (aug_index == invaug::InvAugInvalid) if (aug_index == invaug::InvAugInvalid)
return "Invalid Augment"; return "Invalid Augment";

54
common/patches/rof_limits.h
View File

@ -10,7 +10,7 @@
but WITHOUT ANY WARRANTY except by those people which sell it, which but WITHOUT ANY WARRANTY except by those people which sell it, which
are required to give you total support for your newly bought product; are required to give you total support for your newly bought product;
without even the implied warranty of MERCHANTABILITY or FITNESS FOR without even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE. See the GNU General Public License for more details. A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software along with this program; if not, write to the Free Software
@ -32,8 +32,13 @@ namespace RoF
enum : bool { False = false, True = true }; enum : bool { False = false, True = true };
// pre-declarations // pre-declarations
namespace inventory {
inline EQEmu::versions::ClientVersion GetInventoryRef() { return EQEmu::versions::ClientVersion::RoF; }
} /*inventory*/
namespace invtype { namespace invtype {
inline EQEmu::versions::ClientVersion InvTypeRef() { return EQEmu::versions::ClientVersion::RoF; } inline EQEmu::versions::ClientVersion GetInvTypeRef() { return EQEmu::versions::ClientVersion::RoF; }
enum : int { InvTypeInvalid = -1, InvTypeBegin }; enum : int { InvTypeInvalid = -1, InvTypeBegin };
@ -68,7 +73,7 @@ namespace RoF
} /*invtype*/ } /*invtype*/
namespace invslot { namespace invslot {
inline EQEmu::versions::ClientVersion InvSlotRef() { return EQEmu::versions::ClientVersion::RoF; } inline EQEmu::versions::ClientVersion GetInvSlotRef() { return EQEmu::versions::ClientVersion::RoF; }
enum : int { InvSlotInvalid = -1, InvSlotBegin }; enum : int { InvSlotInvalid = -1, InvSlotBegin };
@ -121,21 +126,21 @@ namespace RoF
} /*invslot*/ } /*invslot*/
namespace invbag { namespace invbag {
inline EQEmu::versions::ClientVersion InvBagRef() { return EQEmu::versions::ClientVersion::RoF; } inline EQEmu::versions::ClientVersion GetInvBagRef() { return EQEmu::versions::ClientVersion::RoF; }
enum : int { InvBagInvalid = -1, InvBagBegin }; enum : int { InvBagInvalid = -1, InvBagBegin };
} /*invbag*/ } /*invbag*/
namespace invaug { namespace invaug {
inline EQEmu::versions::ClientVersion InvAugRef() { return EQEmu::versions::ClientVersion::RoF; } inline EQEmu::versions::ClientVersion GetInvAugRef() { return EQEmu::versions::ClientVersion::RoF; }
enum : int { InvAugInvalid = -1, InvAugBegin }; enum : int { InvAugInvalid = -1, InvAugBegin };
} /*invaug*/ } /*invaug*/
namespace item { namespace item {
inline EQEmu::versions::ClientVersion ItemRef() { return EQEmu::versions::ClientVersion::RoF; } inline EQEmu::versions::ClientVersion GetItemRef() { return EQEmu::versions::ClientVersion::RoF; }
enum ItemPacketType : int { enum ItemPacketType : int {
ItemPacketMerchant = 100, ItemPacketMerchant = 100,
@ -157,27 +162,37 @@ namespace RoF
} /*item*/ } /*item*/
namespace profile { namespace profile {
inline EQEmu::versions::ClientVersion ProfileRef() { return EQEmu::versions::ClientVersion::RoF; } inline EQEmu::versions::ClientVersion GetProfileRef() { return EQEmu::versions::ClientVersion::RoF; }
} /*profile*/ } /*profile*/
namespace constants { namespace constants {
inline EQEmu::versions::ClientVersion ConstantsRef() { return EQEmu::versions::ClientVersion::RoF; } inline EQEmu::versions::ClientVersion GetConstantsRef() { return EQEmu::versions::ClientVersion::RoF; }
} /*constants*/ } /*constants*/
namespace behavior { namespace behavior {
inline EQEmu::versions::ClientVersion BehaviorRef() { return EQEmu::versions::ClientVersion::RoF; } inline EQEmu::versions::ClientVersion GetBehaviorRef() { return EQEmu::versions::ClientVersion::RoF; }
} /*behavior*/ } /*behavior*/
namespace skills { namespace skills {
inline EQEmu::versions::ClientVersion SkillsRef() { return EQEmu::versions::ClientVersion::RoF; } inline EQEmu::versions::ClientVersion GetSkillsRef() { return EQEmu::versions::ClientVersion::RoF; }
} /*skills*/ } /*skills*/
// declarations // declarations
namespace inventory {
const bool ConcatenateInvTypeLimbo = false;
const bool AllowOverLevelEquipment = true;
const bool AllowEmptyBagInBag = true;
const bool AllowClickCastFromBag = true;
} /*inventory*/
namespace invtype { namespace invtype {
const size_t InvTypePossessionsSize = invslot::PossessionsCount; const size_t InvTypePossessionsSize = invslot::PossessionsCount;
const size_t InvTypeBankSize = 24; const size_t InvTypeBankSize = 24;
@ -206,28 +221,28 @@ namespace RoF
const size_t NPCTradeSize = 4; const size_t NPCTradeSize = 4;
extern size_t InvTypeSize(int inv_type); extern size_t GetInvTypeSize(int inv_type);
extern const char* InvTypeName(int inv_type); extern const char* GetInvTypeName(int inv_type);
} /*invtype*/ } /*invtype*/
namespace invslot { namespace invslot {
extern const char* InvPossessionsSlotName(int inv_slot); extern const char* GetInvPossessionsSlotName(int inv_slot);
extern const char* InvSlotName(int inv_type, int inv_slot); extern const char* GetInvSlotName(int inv_type, int inv_slot);
} /*invslot*/ } /*invslot*/
namespace invbag { namespace invbag {
const size_t ItemBagSize = 255; // server Size will be 255..unsure what actual client is (test) const size_t ItemBagSize = 255; // server Size will be 255..unsure what actual client is (test)
extern const char* InvBagIndexName(int bag_index); extern const char* GetInvBagIndexName(int bag_index);
} /*invbag*/ } /*invbag*/
namespace invaug { namespace invaug {
const size_t ItemAugSize = 6; const size_t ItemAugSize = 6;
extern const char* InvAugIndexName(int aug_index); extern const char* GetInvAugIndexName(int aug_index);
} /*invaug*/ } /*invaug*/
@ -255,13 +270,6 @@ namespace RoF
} /*constants*/ } /*constants*/
namespace behavior { namespace behavior {
const bool ConcatenateInvTypeLimbo = false;
const bool AllowOverLevelEquipment = true;
const bool AllowEmptyBagInBag = true;
const bool AllowClickCastFromBag = true;
const bool CoinHasWeight = false; const bool CoinHasWeight = false;
} /*behavior*/ } /*behavior*/

24
common/patches/sod_limits.cpp
View File

@ -10,7 +10,7 @@
but WITHOUT ANY WARRANTY except by those people which sell it, which but WITHOUT ANY WARRANTY except by those people which sell it, which
are required to give you total support for your newly bought product; are required to give you total support for your newly bought product;
without even the implied warranty of MERCHANTABILITY or FITNESS FOR without even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE. See the GNU General Public License for more details. A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software along with this program; if not, write to the Free Software
@ -22,7 +22,7 @@
#include "../string_util.h" #include "../string_util.h"
size_t SoD::invtype::InvTypeSize(int inv_type) size_t SoD::invtype::GetInvTypeSize(int inv_type)
{ {
switch (inv_type) { switch (inv_type) {
case invtype::InvTypePossessions: case invtype::InvTypePossessions:
@ -68,7 +68,7 @@ size_t SoD::invtype::InvTypeSize(int inv_type)
} }
} }
const char* SoD::invtype::InvTypeName(int inv_type) const char* SoD::invtype::GetInvTypeName(int inv_type)
{ {
switch (inv_type) { switch (inv_type) {
case invtype::InvTypeInvalid: case invtype::InvTypeInvalid:
@ -116,7 +116,7 @@ const char* SoD::invtype::InvTypeName(int inv_type)
} }
} }
const char* SoD::invslot::InvPossessionsSlotName(int inv_slot) const char* SoD::invslot::GetInvPossessionsSlotName(int inv_slot)
{ {
switch (inv_slot) { switch (inv_slot) {
case invslot::InvSlotInvalid: case invslot::InvSlotInvalid:
@ -190,9 +190,9 @@ const char* SoD::invslot::InvPossessionsSlotName(int inv_slot)
} }
} }
const char* SoD::invslot::InvCorpseSlotName(int inv_slot) const char* SoD::invslot::GetInvCorpseSlotName(int inv_slot)
{ {
if (!invtype::InvTypeSize(invtype::InvTypeCorpse) || inv_slot == invslot::InvSlotInvalid) if (!invtype::GetInvTypeSize(invtype::InvTypeCorpse) || inv_slot == invslot::InvSlotInvalid)
return "Invalid Slot"; return "Invalid Slot";
// needs work // needs work
@ -205,14 +205,14 @@ const char* SoD::invslot::InvCorpseSlotName(int inv_slot)
return ret_str.c_str(); return ret_str.c_str();
} }
const char* SoD::invslot::InvSlotName(int inv_type, int inv_slot) const char* SoD::invslot::GetInvSlotName(int inv_type, int inv_slot)
{ {
if (inv_type == invtype::InvTypePossessions) if (inv_type == invtype::InvTypePossessions)
return invslot::InvPossessionsSlotName(inv_slot); return invslot::GetInvPossessionsSlotName(inv_slot);
else if (inv_type == invtype::InvTypeCorpse) else if (inv_type == invtype::InvTypeCorpse)
return invslot::InvCorpseSlotName(inv_slot); return invslot::GetInvCorpseSlotName(inv_slot);
size_t type_size = invtype::InvTypeSize(inv_type); size_t type_size = invtype::GetInvTypeSize(inv_type);
if (!type_size || inv_slot == invslot::InvSlotInvalid) if (!type_size || inv_slot == invslot::InvSlotInvalid)
return "Invalid Slot"; return "Invalid Slot";
@ -226,7 +226,7 @@ const char* SoD::invslot::InvSlotName(int inv_type, int inv_slot)
return ret_str.c_str(); return ret_str.c_str();
} }
const char* SoD::invbag::InvBagIndexName(int bag_index) const char* SoD::invbag::GetInvBagIndexName(int bag_index)
{ {
if (bag_index == invbag::InvBagInvalid) if (bag_index == invbag::InvBagInvalid)
return "Invalid Bag"; return "Invalid Bag";
@ -240,7 +240,7 @@ const char* SoD::invbag::InvBagIndexName(int bag_index)
return ret_str.c_str(); return ret_str.c_str();
} }
const char* SoD::invaug::InvAugIndexName(int aug_index) const char* SoD::invaug::GetInvAugIndexName(int aug_index)
{ {
if (aug_index == invaug::InvAugInvalid) if (aug_index == invaug::InvAugInvalid)
return "Invalid Augment"; return "Invalid Augment";

56
common/patches/sod_limits.h
View File

@ -10,7 +10,7 @@
but WITHOUT ANY WARRANTY except by those people which sell it, which but WITHOUT ANY WARRANTY except by those people which sell it, which
are required to give you total support for your newly bought product; are required to give you total support for your newly bought product;
without even the implied warranty of MERCHANTABILITY or FITNESS FOR without even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE. See the GNU General Public License for more details. A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software along with this program; if not, write to the Free Software
@ -32,8 +32,13 @@ namespace SoD
enum : bool { False = false, True = true }; enum : bool { False = false, True = true };
// pre-declarations // pre-declarations
namespace inventory {
inline EQEmu::versions::ClientVersion GetInventoryRef() { return EQEmu::versions::ClientVersion::SoD; }
} /*inventory*/
namespace invtype { namespace invtype {
inline EQEmu::versions::ClientVersion InvTypeRef() { return EQEmu::versions::ClientVersion::SoD; } inline EQEmu::versions::ClientVersion GetInvTypeRef() { return EQEmu::versions::ClientVersion::SoD; }
enum : int { InvTypeInvalid = -1, InvTypeBegin }; enum : int { InvTypeInvalid = -1, InvTypeBegin };
@ -63,7 +68,7 @@ namespace SoD
} /*invtype*/ } /*invtype*/
namespace invslot { namespace invslot {
inline EQEmu::versions::ClientVersion InvSlotRef() { return EQEmu::versions::ClientVersion::SoD; } inline EQEmu::versions::ClientVersion GetInvSlotRef() { return EQEmu::versions::ClientVersion::SoD; }
enum : int { InvSlotInvalid = -1, InvSlotBegin }; enum : int { InvSlotInvalid = -1, InvSlotBegin };
@ -114,21 +119,21 @@ namespace SoD
} /*invslot*/ } /*invslot*/
namespace invbag { namespace invbag {
inline EQEmu::versions::ClientVersion InvBagRef() { return EQEmu::versions::ClientVersion::SoD; } inline EQEmu::versions::ClientVersion GetInvBagRef() { return EQEmu::versions::ClientVersion::SoD; }
enum : int { InvBagInvalid = -1, InvBagBegin }; enum : int { InvBagInvalid = -1, InvBagBegin };
} /*invbag*/ } /*invbag*/
namespace invaug { namespace invaug {
inline EQEmu::versions::ClientVersion InvAugRef() { return EQEmu::versions::ClientVersion::SoD; } inline EQEmu::versions::ClientVersion GetInvAugRef() { return EQEmu::versions::ClientVersion::SoD; }
enum : int { InvAugInvalid = -1, InvAugBegin }; enum : int { InvAugInvalid = -1, InvAugBegin };
} /*invaug*/ } /*invaug*/
namespace item { namespace item {
inline EQEmu::versions::ClientVersion ItemRef() { return EQEmu::versions::ClientVersion::SoD; } inline EQEmu::versions::ClientVersion GetItemRef() { return EQEmu::versions::ClientVersion::SoD; }
enum ItemPacketType : int { enum ItemPacketType : int {
ItemPacketMerchant = 100, ItemPacketMerchant = 100,
@ -146,27 +151,37 @@ namespace SoD
} /*item*/ } /*item*/
namespace profile { namespace profile {
inline EQEmu::versions::ClientVersion ProfileRef() { return EQEmu::versions::ClientVersion::SoD; } inline EQEmu::versions::ClientVersion GetProfileRef() { return EQEmu::versions::ClientVersion::SoD; }
} /*profile*/ } /*profile*/
namespace constants { namespace constants {
inline EQEmu::versions::ClientVersion ConstantsRef() { return EQEmu::versions::ClientVersion::SoD; } inline EQEmu::versions::ClientVersion GetConstantsRef() { return EQEmu::versions::ClientVersion::SoD; }
} /*constants*/ } /*constants*/
namespace behavior { namespace behavior {
inline EQEmu::versions::ClientVersion BehaviorRef() { return EQEmu::versions::ClientVersion::SoD; } inline EQEmu::versions::ClientVersion GetBehaviorRef() { return EQEmu::versions::ClientVersion::SoD; }
} /*behavior*/ } /*behavior*/
namespace skills { namespace skills {
inline EQEmu::versions::ClientVersion SkillsRef() { return EQEmu::versions::ClientVersion::SoD; } inline EQEmu::versions::ClientVersion GetSkillsRef() { return EQEmu::versions::ClientVersion::SoD; }
} /*skills*/ } /*skills*/
// declarations // declarations
namespace inventory {
const bool ConcatenateInvTypeLimbo = true;
const bool AllowOverLevelEquipment = false;
const bool AllowEmptyBagInBag = false;
const bool AllowClickCastFromBag = false;
} /*inventory*/
namespace invtype { namespace invtype {
const size_t InvTypePossessionsSize = invslot::PossessionsCount; const size_t InvTypePossessionsSize = invslot::PossessionsCount;
const size_t InvTypeBankSize = 24; const size_t InvTypeBankSize = 24;
@ -190,8 +205,8 @@ namespace SoD
const size_t NPCTradeSize = 4; const size_t NPCTradeSize = 4;
extern size_t InvTypeSize(int inv_type); extern size_t GetInvTypeSize(int inv_type);
extern const char* InvTypeName(int inv_type); extern const char* GetInvTypeName(int inv_type);
} /*invtype*/ } /*invtype*/
@ -218,9 +233,9 @@ namespace SoD
const int CorpseBegin = invslot::PossessionsGeneral1; const int CorpseBegin = invslot::PossessionsGeneral1;
const int CorpseEnd = invslot::PossessionsGeneral1 + invslot::PossessionsCursor; const int CorpseEnd = invslot::PossessionsGeneral1 + invslot::PossessionsCursor;
extern const char* InvPossessionsSlotName(int inv_slot); extern const char* GetInvPossessionsSlotName(int inv_slot);
extern const char* InvCorpseSlotName(int inv_slot); extern const char* GetInvCorpseSlotName(int inv_slot);
extern const char* InvSlotName(int inv_type, int inv_slot); extern const char* GetInvSlotName(int inv_type, int inv_slot);
} /*invslot*/ } /*invslot*/
@ -247,14 +262,14 @@ namespace SoD
const int TradeBagsSize = invtype::InvTypeTradeSize * ItemBagSize; const int TradeBagsSize = invtype::InvTypeTradeSize * ItemBagSize;
const int TradeBagsEnd = (TradeBagsBegin + TradeBagsSize) - 1; const int TradeBagsEnd = (TradeBagsBegin + TradeBagsSize) - 1;
extern const char* InvBagIndexName(int bag_index); extern const char* GetInvBagIndexName(int bag_index);
} /*invbag*/ } /*invbag*/
namespace invaug { namespace invaug {
const size_t ItemAugSize = 5; const size_t ItemAugSize = 5;
extern const char* InvAugIndexName(int aug_index); extern const char* GetInvAugIndexName(int aug_index);
} /*invaug*/ } /*invaug*/
@ -282,13 +297,6 @@ namespace SoD
} /*constants*/ } /*constants*/
namespace behavior { namespace behavior {
const bool ConcatenateInvTypeLimbo = true;
const bool AllowOverLevelEquipment = false;
const bool AllowEmptyBagInBag = false;
const bool AllowClickCastFromBag = false;
const bool CoinHasWeight = false; const bool CoinHasWeight = false;
} /*behavior*/ } /*behavior*/

24
common/patches/sof_limits.cpp
View File

@ -10,7 +10,7 @@
but WITHOUT ANY WARRANTY except by those people which sell it, which but WITHOUT ANY WARRANTY except by those people which sell it, which
are required to give you total support for your newly bought product; are required to give you total support for your newly bought product;
without even the implied warranty of MERCHANTABILITY or FITNESS FOR without even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE. See the GNU General Public License for more details. A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software along with this program; if not, write to the Free Software
@ -22,7 +22,7 @@
#include "../string_util.h" #include "../string_util.h"
size_t SoF::invtype::InvTypeSize(int inv_type) size_t SoF::invtype::GetInvTypeSize(int inv_type)
{ {
switch (inv_type) { switch (inv_type) {
case invtype::InvTypePossessions: case invtype::InvTypePossessions:
@ -68,7 +68,7 @@ size_t SoF::invtype::InvTypeSize(int inv_type)
} }
} }
const char* SoF::invtype::InvTypeName(int inv_type) const char* SoF::invtype::GetInvTypeName(int inv_type)
{ {
switch (inv_type) { switch (inv_type) {
case invtype::InvTypeInvalid: case invtype::InvTypeInvalid:
@ -116,7 +116,7 @@ const char* SoF::invtype::InvTypeName(int inv_type)
} }
} }
const char* SoF::invslot::InvPossessionsSlotName(int inv_slot) const char* SoF::invslot::GetInvPossessionsSlotName(int inv_slot)
{ {
switch (inv_slot) { switch (inv_slot) {
case invslot::InvSlotInvalid: case invslot::InvSlotInvalid:
@ -190,9 +190,9 @@ const char* SoF::invslot::InvPossessionsSlotName(int inv_slot)
} }
} }
const char* SoF::invslot::InvCorpseSlotName(int inv_slot) const char* SoF::invslot::GetInvCorpseSlotName(int inv_slot)
{ {
if (!invtype::InvTypeSize(invtype::InvTypeCorpse) || inv_slot == invslot::InvSlotInvalid) if (!invtype::GetInvTypeSize(invtype::InvTypeCorpse) || inv_slot == invslot::InvSlotInvalid)
return "Invalid Slot"; return "Invalid Slot";
// needs work // needs work
@ -205,14 +205,14 @@ const char* SoF::invslot::InvCorpseSlotName(int inv_slot)
return ret_str.c_str(); return ret_str.c_str();
} }
const char* SoF::invslot::InvSlotName(int inv_type, int inv_slot) const char* SoF::invslot::GetInvSlotName(int inv_type, int inv_slot)
{ {
if (inv_type == invtype::InvTypePossessions) if (inv_type == invtype::InvTypePossessions)
return invslot::InvPossessionsSlotName(inv_slot); return invslot::GetInvPossessionsSlotName(inv_slot);
else if (inv_type == invtype::InvTypeCorpse) else if (inv_type == invtype::InvTypeCorpse)
return invslot::InvCorpseSlotName(inv_slot); return invslot::GetInvCorpseSlotName(inv_slot);
size_t type_size = invtype::InvTypeSize(inv_type); size_t type_size = invtype::GetInvTypeSize(inv_type);
if (!type_size || inv_slot == invslot::InvSlotInvalid) if (!type_size || inv_slot == invslot::InvSlotInvalid)
return "Invalid Slot"; return "Invalid Slot";
@ -226,7 +226,7 @@ const char* SoF::invslot::InvSlotName(int inv_type, int inv_slot)
return ret_str.c_str(); return ret_str.c_str();
} }
const char* SoF::invbag::InvBagIndexName(int bag_index) const char* SoF::invbag::GetInvBagIndexName(int bag_index)
{ {
if (bag_index == invbag::InvBagInvalid) if (bag_index == invbag::InvBagInvalid)
return "Invalid Bag"; return "Invalid Bag";
@ -240,7 +240,7 @@ const char* SoF::invbag::InvBagIndexName(int bag_index)
return ret_str.c_str(); return ret_str.c_str();
} }
const char* SoF::invaug::InvAugIndexName(int aug_index) const char* SoF::invaug::GetInvAugIndexName(int aug_index)
{ {
if (aug_index == invaug::InvAugInvalid) if (aug_index == invaug::InvAugInvalid)
return "Invalid Augment"; return "Invalid Augment";

56
common/patches/sof_limits.h
View File

@ -10,7 +10,7 @@
but WITHOUT ANY WARRANTY except by those people which sell it, which but WITHOUT ANY WARRANTY except by those people which sell it, which
are required to give you total support for your newly bought product; are required to give you total support for your newly bought product;
without even the implied warranty of MERCHANTABILITY or FITNESS FOR without even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE. See the GNU General Public License for more details. A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software along with this program; if not, write to the Free Software
@ -32,8 +32,13 @@ namespace SoF
enum : bool { False = false, True = true }; enum : bool { False = false, True = true };
// pre-declarations // pre-declarations
namespace inventory {
inline EQEmu::versions::ClientVersion GetInventoryRef() { return EQEmu::versions::ClientVersion::SoF; }
} /*inventory*/
namespace invtype { namespace invtype {
inline EQEmu::versions::ClientVersion InvTypeRef() { return EQEmu::versions::ClientVersion::SoF; } inline EQEmu::versions::ClientVersion GetInvTypeRef() { return EQEmu::versions::ClientVersion::SoF; }
enum : int { InvTypeInvalid = -1, InvTypeBegin }; enum : int { InvTypeInvalid = -1, InvTypeBegin };
@ -63,7 +68,7 @@ namespace SoF
} /*invtype*/ } /*invtype*/
namespace invslot { namespace invslot {
inline EQEmu::versions::ClientVersion InvSlotRef() { return EQEmu::versions::ClientVersion::SoF; } inline EQEmu::versions::ClientVersion GetInvSlotRef() { return EQEmu::versions::ClientVersion::SoF; }
enum : int { InvSlotInvalid = -1, InvSlotBegin }; enum : int { InvSlotInvalid = -1, InvSlotBegin };
@ -114,21 +119,21 @@ namespace SoF
} /*invslot*/ } /*invslot*/
namespace invbag { namespace invbag {
inline EQEmu::versions::ClientVersion InvBagRef() { return EQEmu::versions::ClientVersion::SoF; } inline EQEmu::versions::ClientVersion GetInvBagRef() { return EQEmu::versions::ClientVersion::SoF; }
enum : int { InvBagInvalid = -1, InvBagBegin }; enum : int { InvBagInvalid = -1, InvBagBegin };
} /*invbag*/ } /*invbag*/
namespace invaug { namespace invaug {
inline EQEmu::versions::ClientVersion InvAugRef() { return EQEmu::versions::ClientVersion::SoF; } inline EQEmu::versions::ClientVersion GetInvAugRef() { return EQEmu::versions::ClientVersion::SoF; }
enum : int { InvAugInvalid = -1, InvAugBegin }; enum : int { InvAugInvalid = -1, InvAugBegin };
} /*invaug*/ } /*invaug*/
namespace item { namespace item {
inline EQEmu::versions::ClientVersion ItemRef() { return EQEmu::versions::ClientVersion::SoF; } inline EQEmu::versions::ClientVersion GetItemRef() { return EQEmu::versions::ClientVersion::SoF; }
enum ItemPacketType : int { enum ItemPacketType : int {
ItemPacketMerchant = 100, ItemPacketMerchant = 100,
@ -146,27 +151,37 @@ namespace SoF
} /*item*/ } /*item*/
namespace profile { namespace profile {
inline EQEmu::versions::ClientVersion ProfileRef() { return EQEmu::versions::ClientVersion::SoF; } inline EQEmu::versions::ClientVersion GetProfileRef() { return EQEmu::versions::ClientVersion::SoF; }
} /*profile*/ } /*profile*/
namespace constants { namespace constants {
inline EQEmu::versions::ClientVersion ConstantsRef() { return EQEmu::versions::ClientVersion::SoF; } inline EQEmu::versions::ClientVersion GetConstantsRef() { return EQEmu::versions::ClientVersion::SoF; }
} /*constants*/ } /*constants*/
namespace behavior { namespace behavior {
inline EQEmu::versions::ClientVersion BehaviorRef() { return EQEmu::versions::ClientVersion::SoF; } inline EQEmu::versions::ClientVersion GetBehaviorRef() { return EQEmu::versions::ClientVersion::SoF; }
} /*behavior*/ } /*behavior*/
namespace skills { namespace skills {
inline EQEmu::versions::ClientVersion SkillsRef() { return EQEmu::versions::ClientVersion::SoF; } inline EQEmu::versions::ClientVersion GetSkillsRef() { return EQEmu::versions::ClientVersion::SoF; }
} /*skills*/ } /*skills*/
// declarations // declarations
namespace inventory {
const bool ConcatenateInvTypeLimbo = true;
const bool AllowOverLevelEquipment = false;
const bool AllowEmptyBagInBag = false;
const bool AllowClickCastFromBag = false;
} /*inventory*/
namespace invtype { namespace invtype {
const size_t InvTypePossessionsSize = invslot::PossessionsCount; const size_t InvTypePossessionsSize = invslot::PossessionsCount;
const size_t InvTypeBankSize = 24; const size_t InvTypeBankSize = 24;
@ -190,8 +205,8 @@ namespace SoF
const size_t NPCTradeSize = 4; const size_t NPCTradeSize = 4;
extern size_t InvTypeSize(int inv_type); extern size_t GetInvTypeSize(int inv_type);
extern const char* InvTypeName(int inv_type); extern const char* GetInvTypeName(int inv_type);
} /*invtype*/ } /*invtype*/
@ -218,9 +233,9 @@ namespace SoF
const int CorpseBegin = PossessionsGeneral1; const int CorpseBegin = PossessionsGeneral1;
const int CorpseEnd = PossessionsGeneral1 + PossessionsCursor; const int CorpseEnd = PossessionsGeneral1 + PossessionsCursor;
extern const char* InvPossessionsSlotName(int inv_slot); extern const char* GetInvPossessionsSlotName(int inv_slot);
extern const char* InvCorpseSlotName(int inv_slot); extern const char* GetInvCorpseSlotName(int inv_slot);
extern const char* InvSlotName(int inv_type, int inv_slot); extern const char* GetInvSlotName(int inv_type, int inv_slot);
} /*invslot*/ } /*invslot*/
@ -247,14 +262,14 @@ namespace SoF
const int TradeBagsSize = invtype::InvTypeTradeSize * ItemBagSize; const int TradeBagsSize = invtype::InvTypeTradeSize * ItemBagSize;
const int TradeBagsEnd = (TradeBagsBegin + TradeBagsSize) - 1; const int TradeBagsEnd = (TradeBagsBegin + TradeBagsSize) - 1;
extern const char* InvBagIndexName(int bag_index); extern const char* GetInvBagIndexName(int bag_index);
} /*invbag*/ } /*invbag*/
namespace invaug { namespace invaug {
const size_t ItemAugSize = 5; const size_t ItemAugSize = 5;
extern const char* InvAugIndexName(int aug_index); extern const char* GetInvAugIndexName(int aug_index);
} /*invaug*/ } /*invaug*/
@ -282,13 +297,6 @@ namespace SoF
} /*constants*/ } /*constants*/
namespace behavior { namespace behavior {
const bool ConcatenateInvTypeLimbo = true;
const bool AllowOverLevelEquipment = false;
const bool AllowEmptyBagInBag = false;
const bool AllowClickCastFromBag = false;
const bool CoinHasWeight = true; const bool CoinHasWeight = true;
} /*behavior*/ } /*behavior*/

24
common/patches/titanium_limits.cpp
View File

@ -10,7 +10,7 @@
but WITHOUT ANY WARRANTY except by those people which sell it, which but WITHOUT ANY WARRANTY except by those people which sell it, which
are required to give you total support for your newly bought product; are required to give you total support for your newly bought product;
without even the implied warranty of MERCHANTABILITY or FITNESS FOR without even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE. See the GNU General Public License for more details. A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software along with this program; if not, write to the Free Software
@ -22,7 +22,7 @@
#include "../string_util.h" #include "../string_util.h"
size_t Titanium::invtype::InvTypeSize(int inv_type) size_t Titanium::invtype::GetInvTypeSize(int inv_type)
{ {
switch (inv_type) { switch (inv_type) {
case invtype::InvTypePossessions: case invtype::InvTypePossessions:
@ -68,7 +68,7 @@ size_t Titanium::invtype::InvTypeSize(int inv_type)
} }
} }
const char* Titanium::invtype::InvTypeName(int inv_type) const char* Titanium::invtype::GetInvTypeName(int inv_type)
{ {
switch (inv_type) { switch (inv_type) {
case invtype::InvTypeInvalid: case invtype::InvTypeInvalid:
@ -116,7 +116,7 @@ const char* Titanium::invtype::InvTypeName(int inv_type)
} }
} }
const char* Titanium::invslot::InvPossessionsSlotName(int inv_slot) const char* Titanium::invslot::GetInvPossessionsSlotName(int inv_slot)
{ {
switch (inv_slot) { switch (inv_slot) {
case invslot::InvSlotInvalid: case invslot::InvSlotInvalid:
@ -188,9 +188,9 @@ const char* Titanium::invslot::InvPossessionsSlotName(int inv_slot)
} }
} }
const char* Titanium::invslot::InvCorpseSlotName(int inv_slot) const char* Titanium::invslot::GetInvCorpseSlotName(int inv_slot)
{ {
if (!invtype::InvTypeSize(invtype::InvTypeCorpse) || inv_slot == invslot::InvSlotInvalid) if (!invtype::GetInvTypeSize(invtype::InvTypeCorpse) || inv_slot == invslot::InvSlotInvalid)
return "Invalid Slot"; return "Invalid Slot";
// needs work // needs work
@ -203,14 +203,14 @@ const char* Titanium::invslot::InvCorpseSlotName(int inv_slot)
return ret_str.c_str(); return ret_str.c_str();
} }
const char* Titanium::invslot::InvSlotName(int inv_type, int inv_slot) const char* Titanium::invslot::GetInvSlotName(int inv_type, int inv_slot)
{ {
if (inv_type == invtype::InvTypePossessions) if (inv_type == invtype::InvTypePossessions)
return invslot::InvPossessionsSlotName(inv_slot); return invslot::GetInvPossessionsSlotName(inv_slot);
else if (inv_type == invtype::InvTypeCorpse) else if (inv_type == invtype::InvTypeCorpse)
return invslot::InvCorpseSlotName(inv_slot); return invslot::GetInvCorpseSlotName(inv_slot);
size_t type_size = invtype::InvTypeSize(inv_type); size_t type_size = invtype::GetInvTypeSize(inv_type);
if (!type_size || inv_slot == invslot::InvSlotInvalid) if (!type_size || inv_slot == invslot::InvSlotInvalid)
return "Invalid Slot"; return "Invalid Slot";
@ -224,7 +224,7 @@ const char* Titanium::invslot::InvSlotName(int inv_type, int inv_slot)
return ret_str.c_str(); return ret_str.c_str();
} }
const char* Titanium::invbag::InvBagIndexName(int bag_index) const char* Titanium::invbag::GetInvBagIndexName(int bag_index)
{ {
if (bag_index == invbag::InvBagInvalid) if (bag_index == invbag::InvBagInvalid)
return "Invalid Bag"; return "Invalid Bag";
@ -238,7 +238,7 @@ const char* Titanium::invbag::InvBagIndexName(int bag_index)
return ret_str.c_str(); return ret_str.c_str();
} }
const char* Titanium::invaug::InvAugIndexName(int aug_index) const char* Titanium::invaug::GetInvAugIndexName(int aug_index)
{ {
if (aug_index == invaug::InvAugInvalid) if (aug_index == invaug::InvAugInvalid)
return "Invalid Augment"; return "Invalid Augment";

56
common/patches/titanium_limits.h
View File

@ -10,7 +10,7 @@
but WITHOUT ANY WARRANTY except by those people which sell it, which but WITHOUT ANY WARRANTY except by those people which sell it, which
are required to give you total support for your newly bought product; are required to give you total support for your newly bought product;
without even the implied warranty of MERCHANTABILITY or FITNESS FOR without even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE. See the GNU General Public License for more details. A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software along with this program; if not, write to the Free Software
@ -32,8 +32,13 @@ namespace Titanium
enum : bool { False = false, True = true }; enum : bool { False = false, True = true };
// pre-declarations // pre-declarations
namespace inventory {
inline EQEmu::versions::ClientVersion GetInventoryRef() { return EQEmu::versions::ClientVersion::Titanium; }
} /*inventory*/
namespace invtype { namespace invtype {
inline EQEmu::versions::ClientVersion InvTypeRef() { return EQEmu::versions::ClientVersion::Titanium; } inline EQEmu::versions::ClientVersion GetInvTypeRef() { return EQEmu::versions::ClientVersion::Titanium; }
enum : int { InvTypeInvalid = -1, InvTypeBegin }; enum : int { InvTypeInvalid = -1, InvTypeBegin };
@ -63,7 +68,7 @@ namespace Titanium
} /*invtype*/ } /*invtype*/
namespace invslot { namespace invslot {
inline EQEmu::versions::ClientVersion InvSlotRef() { return EQEmu::versions::ClientVersion::Titanium; } inline EQEmu::versions::ClientVersion GetInvSlotRef() { return EQEmu::versions::ClientVersion::Titanium; }
enum : int { InvSlotInvalid = -1, InvSlotBegin }; enum : int { InvSlotInvalid = -1, InvSlotBegin };
@ -113,21 +118,21 @@ namespace Titanium
} /*invslot*/ } /*invslot*/
namespace invbag { namespace invbag {
inline EQEmu::versions::ClientVersion InvBagRef() { return EQEmu::versions::ClientVersion::Titanium; } inline EQEmu::versions::ClientVersion GetInvBagRef() { return EQEmu::versions::ClientVersion::Titanium; }
enum : int { InvBagInvalid = -1, InvBagBegin }; enum : int { InvBagInvalid = -1, InvBagBegin };
} /*invbag*/ } /*invbag*/
namespace invaug { namespace invaug {
inline EQEmu::versions::ClientVersion InvAugRef() { return EQEmu::versions::ClientVersion::Titanium; } inline EQEmu::versions::ClientVersion GetInvAugRef() { return EQEmu::versions::ClientVersion::Titanium; }
enum : int { InvAugInvalid = -1, InvAugBegin }; enum : int { InvAugInvalid = -1, InvAugBegin };
} /*invaug*/ } /*invaug*/
namespace item { namespace item {
inline EQEmu::versions::ClientVersion ItemRef() { return EQEmu::versions::ClientVersion::Titanium; } inline EQEmu::versions::ClientVersion GetItemRef() { return EQEmu::versions::ClientVersion::Titanium; }
enum ItemPacketType : int { enum ItemPacketType : int {
ItemPacketMerchant = 100, ItemPacketMerchant = 100,
@ -145,27 +150,37 @@ namespace Titanium
} /*item*/ } /*item*/
namespace profile { namespace profile {
inline EQEmu::versions::ClientVersion ProfileRef() { return EQEmu::versions::ClientVersion::Titanium; } inline EQEmu::versions::ClientVersion GetProfileRef() { return EQEmu::versions::ClientVersion::Titanium; }
} /*profile*/ } /*profile*/
namespace constants { namespace constants {
inline EQEmu::versions::ClientVersion ConstantsRef() { return EQEmu::versions::ClientVersion::Titanium; } inline EQEmu::versions::ClientVersion GetConstantsRef() { return EQEmu::versions::ClientVersion::Titanium; }
} /*constants*/ } /*constants*/
namespace behavior { namespace behavior {
inline EQEmu::versions::ClientVersion BehaviorRef() { return EQEmu::versions::ClientVersion::Titanium; } inline EQEmu::versions::ClientVersion GetBehaviorRef() { return EQEmu::versions::ClientVersion::Titanium; }
} /*behavior*/ } /*behavior*/
namespace skills { namespace skills {
inline EQEmu::versions::ClientVersion SkillsRef() { return EQEmu::versions::ClientVersion::Titanium; } inline EQEmu::versions::ClientVersion GetSkillsRef() { return EQEmu::versions::ClientVersion::Titanium; }
} /*skills*/ } /*skills*/
// declarations // declarations
namespace inventory {
const bool ConcatenateInvTypeLimbo = true;
const bool AllowOverLevelEquipment = false;
const bool AllowEmptyBagInBag = false;
const bool AllowClickCastFromBag = false;
} /*inventory*/
namespace invtype { namespace invtype {
const size_t InvTypePossessionsSize = invslot::PossessionsCount; const size_t InvTypePossessionsSize = invslot::PossessionsCount;
const size_t InvTypeBankSize = 16; const size_t InvTypeBankSize = 16;
@ -189,8 +204,8 @@ namespace Titanium
const size_t NPCTradeSize = 4; const size_t NPCTradeSize = 4;
extern size_t InvTypeSize(int inv_type); extern size_t GetInvTypeSize(int inv_type);
extern const char* InvTypeName(int inv_type); extern const char* GetInvTypeName(int inv_type);
} /*invtype*/ } /*invtype*/
@ -217,9 +232,9 @@ namespace Titanium
const int CorpseBegin = PossessionsGeneral1; const int CorpseBegin = PossessionsGeneral1;
const int CorpseEnd = PossessionsGeneral1 + PossessionsCursor; const int CorpseEnd = PossessionsGeneral1 + PossessionsCursor;
extern const char* InvPossessionsSlotName(int inv_slot); extern const char* GetInvPossessionsSlotName(int inv_slot);
extern const char* InvCorpseSlotName(int inv_slot); extern const char* GetInvCorpseSlotName(int inv_slot);
extern const char* InvSlotName(int inv_type, int inv_slot); extern const char* GetInvSlotName(int inv_type, int inv_slot);
} /*invslot*/ } /*invslot*/
@ -246,14 +261,14 @@ namespace Titanium
const int TradeBagsSize = invtype::InvTypeTradeSize * ItemBagSize; const int TradeBagsSize = invtype::InvTypeTradeSize * ItemBagSize;
const int TradeBagsEnd = (TradeBagsBegin + TradeBagsSize) - 1; const int TradeBagsEnd = (TradeBagsBegin + TradeBagsSize) - 1;
extern const char* InvBagIndexName(int bag_index); extern const char* GetInvBagIndexName(int bag_index);
} /*invbag*/ } /*invbag*/
namespace invaug { namespace invaug {
const size_t ItemAugSize = 5; const size_t ItemAugSize = 5;
extern const char* InvAugIndexName(int aug_index); extern const char* GetInvAugIndexName(int aug_index);
} /*invaug*/ } /*invaug*/
@ -281,13 +296,6 @@ namespace Titanium
} /*constants*/ } /*constants*/
namespace behavior { namespace behavior {
const bool ConcatenateInvTypeLimbo = true;
const bool AllowOverLevelEquipment = false;
const bool AllowEmptyBagInBag = false;
const bool AllowClickCastFromBag = false;
const bool CoinHasWeight = true; const bool CoinHasWeight = true;
} /*behavior*/ } /*behavior*/

24
common/patches/uf_limits.cpp
View File

@ -10,7 +10,7 @@
but WITHOUT ANY WARRANTY except by those people which sell it, which but WITHOUT ANY WARRANTY except by those people which sell it, which
are required to give you total support for your newly bought product; are required to give you total support for your newly bought product;
without even the implied warranty of MERCHANTABILITY or FITNESS FOR without even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE. See the GNU General Public License for more details. A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software along with this program; if not, write to the Free Software
@ -22,7 +22,7 @@
#include "../string_util.h" #include "../string_util.h"
size_t UF::invtype::InvTypeSize(int inv_type) size_t UF::invtype::GetInvTypeSize(int inv_type)
{ {
switch (inv_type) { switch (inv_type) {
case invtype::InvTypePossessions: case invtype::InvTypePossessions:
@ -68,7 +68,7 @@ size_t UF::invtype::InvTypeSize(int inv_type)
} }
} }
const char* UF::invtype::InvTypeName(int inv_type) const char* UF::invtype::GetInvTypeName(int inv_type)
{ {
switch (inv_type) { switch (inv_type) {
case invtype::InvTypeInvalid: case invtype::InvTypeInvalid:
@ -116,7 +116,7 @@ const char* UF::invtype::InvTypeName(int inv_type)
} }
} }
const char* UF::invslot::InvPossessionsSlotName(int inv_slot) const char* UF::invslot::GetInvPossessionsSlotName(int inv_slot)
{ {
switch (inv_slot) { switch (inv_slot) {
case invslot::InvSlotInvalid: case invslot::InvSlotInvalid:
@ -190,9 +190,9 @@ const char* UF::invslot::InvPossessionsSlotName(int inv_slot)
} }
} }
const char* UF::invslot::InvCorpseSlotName(int inv_slot) const char* UF::invslot::GetInvCorpseSlotName(int inv_slot)
{ {
if (!invtype::InvTypeSize(invtype::InvTypeCorpse) || inv_slot == invslot::InvSlotInvalid) if (!invtype::GetInvTypeSize(invtype::InvTypeCorpse) || inv_slot == invslot::InvSlotInvalid)
return "Invalid Slot"; return "Invalid Slot";
// needs work // needs work
@ -205,14 +205,14 @@ const char* UF::invslot::InvCorpseSlotName(int inv_slot)
return ret_str.c_str(); return ret_str.c_str();
} }
const char* UF::invslot::InvSlotName(int inv_type, int inv_slot) const char* UF::invslot::GetInvSlotName(int inv_type, int inv_slot)
{ {
if (inv_type == invtype::InvTypePossessions) if (inv_type == invtype::InvTypePossessions)
return invslot::InvPossessionsSlotName(inv_slot); return invslot::GetInvPossessionsSlotName(inv_slot);
else if (inv_type == invtype::InvTypeCorpse) else if (inv_type == invtype::InvTypeCorpse)
return invslot::InvCorpseSlotName(inv_slot); return invslot::GetInvCorpseSlotName(inv_slot);
size_t type_size = invtype::InvTypeSize(inv_type); size_t type_size = invtype::GetInvTypeSize(inv_type);
if (!type_size || inv_slot == invslot::InvSlotInvalid) if (!type_size || inv_slot == invslot::InvSlotInvalid)
return "Invalid Slot"; return "Invalid Slot";
@ -226,7 +226,7 @@ const char* UF::invslot::InvSlotName(int inv_type, int inv_slot)
return ret_str.c_str(); return ret_str.c_str();
} }
const char* UF::invbag::InvBagIndexName(int bag_index) const char* UF::invbag::GetInvBagIndexName(int bag_index)
{ {
if (bag_index == invbag::InvBagInvalid) if (bag_index == invbag::InvBagInvalid)
return "Invalid Bag"; return "Invalid Bag";
@ -240,7 +240,7 @@ const char* UF::invbag::InvBagIndexName(int bag_index)
return ret_str.c_str(); return ret_str.c_str();
} }
const char* UF::invaug::InvAugIndexName(int aug_index) const char* UF::invaug::GetInvAugIndexName(int aug_index)
{ {
if (aug_index == invaug::InvAugInvalid) if (aug_index == invaug::InvAugInvalid)
return "Invalid Augment"; return "Invalid Augment";

56
common/patches/uf_limits.h
View File

@ -10,7 +10,7 @@
but WITHOUT ANY WARRANTY except by those people which sell it, which but WITHOUT ANY WARRANTY except by those people which sell it, which
are required to give you total support for your newly bought product; are required to give you total support for your newly bought product;
without even the implied warranty of MERCHANTABILITY or FITNESS FOR without even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE. See the GNU General Public License for more details. A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software along with this program; if not, write to the Free Software
@ -32,8 +32,13 @@ namespace UF
enum : bool { False = false, True = true }; enum : bool { False = false, True = true };
// pre-declarations // pre-declarations
namespace inventory {
inline EQEmu::versions::ClientVersion GetInventoryRef() { return EQEmu::versions::ClientVersion::UF; }
} /*inventory*/
namespace invtype { namespace invtype {
inline EQEmu::versions::ClientVersion InvTypeRef() { return EQEmu::versions::ClientVersion::UF; } inline EQEmu::versions::ClientVersion GetInvTypeRef() { return EQEmu::versions::ClientVersion::UF; }
enum : int { InvTypeInvalid = -1, InvTypeBegin }; enum : int { InvTypeInvalid = -1, InvTypeBegin };
@ -63,7 +68,7 @@ namespace UF
} /*invtype*/ } /*invtype*/
namespace invslot { namespace invslot {
inline EQEmu::versions::ClientVersion InvSlotRef() { return EQEmu::versions::ClientVersion::UF; } inline EQEmu::versions::ClientVersion GetInvSlotRef() { return EQEmu::versions::ClientVersion::UF; }
enum : int { InvSlotInvalid = -1, InvSlotBegin }; enum : int { InvSlotInvalid = -1, InvSlotBegin };
@ -114,21 +119,21 @@ namespace UF
} /*invslot*/ } /*invslot*/
namespace invbag { namespace invbag {
inline EQEmu::versions::ClientVersion InvBagRef() { return EQEmu::versions::ClientVersion::UF; } inline EQEmu::versions::ClientVersion GetInvBagRef() { return EQEmu::versions::ClientVersion::UF; }
enum : int { InvBagInvalid = -1, InvBagBegin }; enum : int { InvBagInvalid = -1, InvBagBegin };
} /*invbag*/ } /*invbag*/
namespace invaug { namespace invaug {
inline EQEmu::versions::ClientVersion InvAugRef() { return EQEmu::versions::ClientVersion::UF; } inline EQEmu::versions::ClientVersion GetInvAugRef() { return EQEmu::versions::ClientVersion::UF; }
enum : int { InvAugInvalid = -1, InvAugBegin }; enum : int { InvAugInvalid = -1, InvAugBegin };
} /*invaug*/ } /*invaug*/
namespace item { namespace item {
inline EQEmu::versions::ClientVersion ItemRef() { return EQEmu::versions::ClientVersion::UF; } inline EQEmu::versions::ClientVersion GetItemRef() { return EQEmu::versions::ClientVersion::UF; }
enum ItemPacketType : int { enum ItemPacketType : int {
ItemPacketMerchant = 100, ItemPacketMerchant = 100,
@ -147,27 +152,37 @@ namespace UF
} /*item*/ } /*item*/
namespace profile { namespace profile {
inline EQEmu::versions::ClientVersion ProfileRef() { return EQEmu::versions::ClientVersion::UF; } inline EQEmu::versions::ClientVersion GetProfileRef() { return EQEmu::versions::ClientVersion::UF; }
} /*profile*/ } /*profile*/
namespace constants { namespace constants {
inline EQEmu::versions::ClientVersion ConstantsRef() { return EQEmu::versions::ClientVersion::UF; } inline EQEmu::versions::ClientVersion GetConstantsRef() { return EQEmu::versions::ClientVersion::UF; }
} /*constants*/ } /*constants*/
namespace behavior { namespace behavior {
inline EQEmu::versions::ClientVersion BehaviorRef() { return EQEmu::versions::ClientVersion::UF; } inline EQEmu::versions::ClientVersion GetBehaviorRef() { return EQEmu::versions::ClientVersion::UF; }
} /*behavior*/ } /*behavior*/
namespace skills { namespace skills {
inline EQEmu::versions::ClientVersion SkillsRef() { return EQEmu::versions::ClientVersion::UF; } inline EQEmu::versions::ClientVersion GetSkillsRef() { return EQEmu::versions::ClientVersion::UF; }
} /*skills*/ } /*skills*/
// declarations // declarations
namespace inventory {
const bool ConcatenateInvTypeLimbo = true;
const bool AllowOverLevelEquipment = true;
const bool AllowEmptyBagInBag = false;
const bool AllowClickCastFromBag = false;
} /*inventory*/
namespace invtype { namespace invtype {
const size_t InvTypePossessionsSize = invslot::PossessionsCount; const size_t InvTypePossessionsSize = invslot::PossessionsCount;
const size_t InvTypeBankSize = 24; const size_t InvTypeBankSize = 24;
@ -191,8 +206,8 @@ namespace UF
const size_t NPCTradeSize = 4; const size_t NPCTradeSize = 4;
extern size_t InvTypeSize(int inv_type); extern size_t GetInvTypeSize(int inv_type);
extern const char* InvTypeName(int inv_type); extern const char* GetInvTypeName(int inv_type);
} /*invtype*/ } /*invtype*/
@ -219,9 +234,9 @@ namespace UF
const int CorpseBegin = invslot::PossessionsGeneral1; const int CorpseBegin = invslot::PossessionsGeneral1;
const int CorpseEnd = invslot::PossessionsGeneral1 + invslot::PossessionsCursor; const int CorpseEnd = invslot::PossessionsGeneral1 + invslot::PossessionsCursor;
extern const char* InvPossessionsSlotName(int inv_slot); extern const char* GetInvPossessionsSlotName(int inv_slot);
extern const char* InvCorpseSlotName(int inv_slot); extern const char* GetInvCorpseSlotName(int inv_slot);
extern const char* InvSlotName(int inv_type, int inv_slot); extern const char* GetInvSlotName(int inv_type, int inv_slot);
} /*invslot*/ } /*invslot*/
@ -248,14 +263,14 @@ namespace UF
const int TradeBagsSize = invtype::InvTypeTradeSize * ItemBagSize; const int TradeBagsSize = invtype::InvTypeTradeSize * ItemBagSize;
const int TradeBagsEnd = (TradeBagsBegin + TradeBagsSize) - 1; const int TradeBagsEnd = (TradeBagsBegin + TradeBagsSize) - 1;
extern const char* InvBagIndexName(int bag_index); extern const char* GetInvBagIndexName(int bag_index);
} /*invbag*/ } /*invbag*/
namespace invaug { namespace invaug {
const size_t ItemAugSize = 5; const size_t ItemAugSize = 5;
extern const char* InvAugIndexName(int aug_index); extern const char* GetInvAugIndexName(int aug_index);
} /*invaug*/ } /*invaug*/
@ -283,13 +298,6 @@ namespace UF
} /*constants*/ } /*constants*/
namespace behavior { namespace behavior {
const bool ConcatenateInvTypeLimbo = true;
const bool AllowOverLevelEquipment = true;
const bool AllowEmptyBagInBag = false;
const bool AllowClickCastFromBag = false;
const bool CoinHasWeight = false; const bool CoinHasWeight = false;
} /*behavior*/ } /*behavior*/

26
common/say_link.cpp
View File

@ -65,19 +65,19 @@ void EQEmu::saylink::SayLinkEngine::Reset()
m_ItemData = nullptr; m_ItemData = nullptr;
m_LootData = nullptr; m_LootData = nullptr;
m_ItemInst = nullptr; m_ItemInst = nullptr;
m_Proxy_unknown_1 = NOT_USED; m_Proxy_unknown_1 = 0;
m_ProxyItemID = NOT_USED; m_ProxyItemID = 0;
m_ProxyAugment1ID = NOT_USED; m_ProxyAugment1ID = 0;
m_ProxyAugment2ID = NOT_USED; m_ProxyAugment2ID = 0;
m_ProxyAugment3ID = NOT_USED; m_ProxyAugment3ID = 0;
m_ProxyAugment4ID = NOT_USED; m_ProxyAugment4ID = 0;
m_ProxyAugment5ID = NOT_USED; m_ProxyAugment5ID = 0;
m_ProxyAugment6ID = NOT_USED; m_ProxyAugment6ID = 0;
m_ProxyIsEvolving = NOT_USED; m_ProxyIsEvolving = 0;
m_ProxyEvolveGroup = NOT_USED; m_ProxyEvolveGroup = 0;
m_ProxyEvolveLevel = NOT_USED; m_ProxyEvolveLevel = 0;
m_ProxyOrnamentIcon = NOT_USED; m_ProxyOrnamentIcon = 0;
m_ProxyHash = NOT_USED; m_ProxyHash = 0;
m_ProxyText = nullptr; m_ProxyText = nullptr;
m_TaskUse = false; m_TaskUse = false;
m_Link.clear(); m_Link.clear();

4
world/client.cpp
View File

@ -211,7 +211,7 @@ void Client::SendMaxCharCreate() {
auto outapp = new EQApplicationPacket(OP_SendMaxCharacters, sizeof(MaxCharacters_Struct)); auto outapp = new EQApplicationPacket(OP_SendMaxCharacters, sizeof(MaxCharacters_Struct));
MaxCharacters_Struct* mc = (MaxCharacters_Struct*)outapp->pBuffer; MaxCharacters_Struct* mc = (MaxCharacters_Struct*)outapp->pBuffer;
mc->max_chars = EQEmu::constants::CharacterCreationLimit(m_ClientVersion); mc->max_chars = EQEmu::constants::GetCharacterCreationLimit(m_ClientVersion);
if (mc->max_chars > EQEmu::constants::CharacterCreationMax) if (mc->max_chars > EQEmu::constants::CharacterCreationMax)
mc->max_chars = EQEmu::constants::CharacterCreationMax; mc->max_chars = EQEmu::constants::CharacterCreationMax;
@ -746,7 +746,7 @@ bool Client::HandleEnterWorldPacket(const EQApplicationPacket *app) {
// This can probably be moved outside and have another method return requested info (don't forget to remove the #include "../common/shareddb.h" above) // This can probably be moved outside and have another method return requested info (don't forget to remove the #include "../common/shareddb.h" above)
// (This is a literal translation of the original process..I don't see why it can't be changed to a single-target query over account iteration) // (This is a literal translation of the original process..I don't see why it can't be changed to a single-target query over account iteration)
if (!pZoning) { if (!pZoning) {
size_t character_limit = EQEmu::constants::CharacterCreationLimit(eqs->ClientVersion()); size_t character_limit = EQEmu::constants::GetCharacterCreationLimit(eqs->ClientVersion());
if (character_limit > EQEmu::constants::CharacterCreationMax) { character_limit = EQEmu::constants::CharacterCreationMax; } if (character_limit > EQEmu::constants::CharacterCreationMax) { character_limit = EQEmu::constants::CharacterCreationMax; }
if (eqs->ClientVersion() == EQEmu::versions::ClientVersion::Titanium) { character_limit = 8; } if (eqs->ClientVersion() == EQEmu::versions::ClientVersion::Titanium) { character_limit = 8; }

2
world/worlddb.cpp
View File

@ -37,7 +37,7 @@ void WorldDatabase::GetCharSelectInfo(uint32 accountID, EQApplicationPacket **ou
{ {
/* Set Character Creation Limit */ /* Set Character Creation Limit */
EQEmu::versions::ClientVersion client_version = EQEmu::versions::ConvertClientVersionBitToClientVersion(clientVersionBit); EQEmu::versions::ClientVersion client_version = EQEmu::versions::ConvertClientVersionBitToClientVersion(clientVersionBit);
size_t character_limit = EQEmu::constants::CharacterCreationLimit(client_version); size_t character_limit = EQEmu::constants::GetCharacterCreationLimit(client_version);
// Validate against absolute server max // Validate against absolute server max
if (character_limit > EQEmu::constants::CharacterCreationMax) if (character_limit > EQEmu::constants::CharacterCreationMax)

2
zone/bot.cpp
View File

@ -347,7 +347,7 @@ NPCType Bot::FillNPCTypeStruct(uint32 botSpellsID, std::string botName, std::str
BotNPCType.hp_regen = 1; BotNPCType.hp_regen = 1;
BotNPCType.mana_regen = 1; BotNPCType.mana_regen = 1;
BotNPCType.maxlevel = botLevel; BotNPCType.maxlevel = botLevel;
BotNPCType.light = NOT_USED; // due to the way that bots are coded..this is sent post-spawn BotNPCType.light = 0; // due to the way that bots are coded..this is sent post-spawn
return BotNPCType; return BotNPCType;
} }

2
zone/client_mods.cpp
View File

@ -1355,7 +1355,7 @@ uint32 Client::CalcCurrentWeight()
This is the ONLY instance I have seen where the client is hard coded to particular Item IDs to set a certain property for an item. It is very odd. This is the ONLY instance I have seen where the client is hard coded to particular Item IDs to set a certain property for an item. It is very odd.
*/ */
// SoD+ client has no weight for coin // SoD+ client has no weight for coin
if (EQEmu::profile::CoinHasWeight(EQEmu::versions::ConvertClientVersionToInventoryVersion(ClientVersion()))) { if (EQEmu::behavior::GetCoinHasWeight(EQEmu::versions::ConvertClientVersionToInventoryVersion(ClientVersion()))) {
Total += (m_pp.platinum + m_pp.gold + m_pp.silver + m_pp.copper) / 4; Total += (m_pp.platinum + m_pp.gold + m_pp.silver + m_pp.copper) / 4;
} }
float Packrat = (float)spellbonuses.Packrat + (float)aabonuses.Packrat + (float)itembonuses.Packrat; float Packrat = (float)spellbonuses.Packrat + (float)aabonuses.Packrat + (float)itembonuses.Packrat;

4
zone/command.cpp
View File

@ -5627,13 +5627,13 @@ void command_itemsearch(Client *c, const Seperator *sep)
return; return;
} }
int count = NOT_USED; int count = 0;
char sName[64]; char sName[64];
char sCriteria[255]; char sCriteria[255];
strn0cpy(sCriteria, search_criteria, sizeof(sCriteria)); strn0cpy(sCriteria, search_criteria, sizeof(sCriteria));
strupr(sCriteria); strupr(sCriteria);
char* pdest; char* pdest;
uint32 it = NOT_USED; uint32 it = 0;
while ((item = database.IterateItems(&it))) { while ((item = database.IterateItems(&it))) {
strn0cpy(sName, item->Name, sizeof(sName)); strn0cpy(sName, item->Name, sizeof(sName));
strupr(sName); strupr(sName);

4
zone/corpse.cpp
View File

@ -998,7 +998,7 @@ void Corpse::MakeLootRequestPackets(Client* client, const EQApplicationPacket* a
cur = itemlist.begin(); cur = itemlist.begin();
end = itemlist.end(); end = itemlist.end();
int corpselootlimit = EQEmu::inventory::InventoryTypeSize(EQEmu::versions::ConvertClientVersionToInventoryVersion(client->ClientVersion()), EQEmu::legacy::TypeCorpse); int corpselootlimit = EQEmu::inventory::GetInventoryTypeSize(EQEmu::versions::ConvertClientVersionToInventoryVersion(client->ClientVersion()), EQEmu::legacy::TypeCorpse);
for(; cur != end; ++cur) { for(; cur != end; ++cur) {
ServerLootItem_Struct* item_data = *cur; ServerLootItem_Struct* item_data = *cur;
@ -1292,7 +1292,7 @@ void Corpse::QueryLoot(Client* to) {
cur = itemlist.begin(); cur = itemlist.begin();
end = itemlist.end(); end = itemlist.end();
int corpselootlimit = EQEmu::inventory::InventoryTypeSize(EQEmu::versions::ConvertClientVersionToInventoryVersion(to->ClientVersion()), EQEmu::legacy::TypeCorpse); int corpselootlimit = EQEmu::inventory::GetInventoryTypeSize(EQEmu::versions::ConvertClientVersionToInventoryVersion(to->ClientVersion()), EQEmu::legacy::TypeCorpse);
for(; cur != end; ++cur) { for(; cur != end; ++cur) {
ServerLootItem_Struct* sitem = *cur; ServerLootItem_Struct* sitem = *cur;

2
zone/tasks.cpp
View File

@ -2759,7 +2759,7 @@ void TaskManager::SendActiveTaskDescription(Client *c, int TaskID, int SequenceN
+ sizeof(TaskDescriptionData2_Struct) + 1 + sizeof(TaskDescriptionTrailer_Struct); + sizeof(TaskDescriptionData2_Struct) + 1 + sizeof(TaskDescriptionTrailer_Struct);
std::string reward_text; std::string reward_text;
int ItemID = NOT_USED; int ItemID = 0;
// If there is an item make the Reward text into a link to the item (only the first item if a list // If there is an item make the Reward text into a link to the item (only the first item if a list
// is specified). I have been unable to get multiple item links to work. // is specified). I have been unable to get multiple item links to work.