pa/eqemu-server
2
0
Fork 0
mirror of https://github.com/EQEmu/Server.git synced 2025-12-13 14:41: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

20
common/emu_limits.h
View File

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

564
common/eq_limits.cpp
View File

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

24
common/eq_limits.h
View File

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

16
common/patches/rof2_limits.cpp
View File

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

52
common/patches/rof2_limits.h
View File

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

16
common/patches/rof_limits.cpp
View File

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

52
common/patches/rof_limits.h
View File

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

22
common/patches/sod_limits.cpp
View File

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

54
common/patches/sod_limits.h
View File

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

22
common/patches/sof_limits.cpp
View File

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

54
common/patches/sof_limits.h
View File

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

22
common/patches/titanium_limits.cpp
View File

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

54
common/patches/titanium_limits.h
View File

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

22
common/patches/uf_limits.cpp
View File

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

54
common/patches/uf_limits.h
View File

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