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

Renamed enum class InventoryVersion to MobVersion

Browse Source
This commit is contained in:
Uleat 2016-10-17 06:32:51 -04:00
parent 04f4fd652b
commit 101002d635
9 changed files with 886 additions and 342 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
changelog.txt
View File

@ -4,6 +4,7 @@ EQEMu Changelog (Started on Sept 24, 2003 15:50)
Uleat: Moved namespace ItemField from item_instance.h to shareddb.cpp - the only place it is used Uleat: Moved namespace ItemField from item_instance.h to shareddb.cpp - the only place it is used
Uleat: Separated class Inventory from item_instance files into inventory_profile files Uleat: Separated class Inventory from item_instance files into inventory_profile files
Uleat: Renamed class Inventory to EQEmu::InventoryProfile Uleat: Renamed class Inventory to EQEmu::InventoryProfile
Uleat: Renamed enum class InventoryVersion to MobVersion
== 10/16/2016 == == 10/16/2016 ==
Uleat: Renamed struct EQEmu::ItemBase to EQEmu::ItemData and class ItemInst to EQEmu::ItemInstance Uleat: Renamed struct EQEmu::ItemBase to EQEmu::ItemData and class ItemInst to EQEmu::ItemInstance

226
common/emu_versions.cpp
View File

@ -127,244 +127,244 @@ uint32 EQEmu::versions::ConvertClientVersionToExpansion(ClientVersion client_ver
} }
} }
bool EQEmu::versions::IsValidInventoryVersion(InventoryVersion inventory_version) bool EQEmu::versions::IsValidMobVersion(MobVersion mob_version)
{ {
if (inventory_version <= InventoryVersion::Unknown || inventory_version > LastInventoryVersion) if (mob_version <= MobVersion::Unknown || mob_version > LastMobVersion)
return false; return false;
return true; return true;
} }
bool EQEmu::versions::IsValidPCInventoryVersion(InventoryVersion inventory_version) bool EQEmu::versions::IsValidPCMobVersion(MobVersion mob_version)
{ {
if (inventory_version <= InventoryVersion::Unknown || inventory_version > LastPCInventoryVersion) if (mob_version <= MobVersion::Unknown || mob_version > LastPCMobVersion)
return false; return false;
return true; return true;
} }
bool EQEmu::versions::IsValidNonPCInventoryVersion(InventoryVersion inventory_version) bool EQEmu::versions::IsValidNonPCMobVersion(MobVersion mob_version)
{ {
if (inventory_version <= LastPCInventoryVersion || inventory_version > LastNonPCInventoryVersion) if (mob_version <= LastPCMobVersion || mob_version > LastNonPCMobVersion)
return false; return false;
return true; return true;
} }
bool EQEmu::versions::IsValidOfflinePCInventoryVersion(InventoryVersion inventory_version) bool EQEmu::versions::IsValidOfflinePCMobVersion(MobVersion mob_version)
{ {
if (inventory_version <= LastNonPCInventoryVersion || inventory_version > LastOfflinePCInventoryVersion) if (mob_version <= LastNonPCMobVersion || mob_version > LastOfflinePCMobVersion)
return false; return false;
return true; return true;
} }
EQEmu::versions::InventoryVersion EQEmu::versions::ValidateInventoryVersion(InventoryVersion inventory_version) EQEmu::versions::MobVersion EQEmu::versions::ValidateMobVersion(MobVersion mob_version)
{ {
if (inventory_version <= InventoryVersion::Unknown || inventory_version > LastInventoryVersion) if (mob_version <= MobVersion::Unknown || mob_version > LastMobVersion)
return InventoryVersion::Unknown; return MobVersion::Unknown;
return inventory_version; return mob_version;
} }
EQEmu::versions::InventoryVersion EQEmu::versions::ValidatePCInventoryVersion(InventoryVersion inventory_version) EQEmu::versions::MobVersion EQEmu::versions::ValidatePCMobVersion(MobVersion mob_version)
{ {
if (inventory_version <= InventoryVersion::Unknown || inventory_version > LastPCInventoryVersion) if (mob_version <= MobVersion::Unknown || mob_version > LastPCMobVersion)
return InventoryVersion::Unknown; return MobVersion::Unknown;
return inventory_version; return mob_version;
} }
EQEmu::versions::InventoryVersion EQEmu::versions::ValidateNonPCInventoryVersion(InventoryVersion inventory_version) EQEmu::versions::MobVersion EQEmu::versions::ValidateNonPCMobVersion(MobVersion mob_version)
{ {
if (inventory_version <= LastPCInventoryVersion || inventory_version > LastNonPCInventoryVersion) if (mob_version <= LastPCMobVersion || mob_version > LastNonPCMobVersion)
return InventoryVersion::Unknown; return MobVersion::Unknown;
return inventory_version; return mob_version;
} }
EQEmu::versions::InventoryVersion EQEmu::versions::ValidateOfflinePCInventoryVersion(InventoryVersion inventory_version) EQEmu::versions::MobVersion EQEmu::versions::ValidateOfflinePCMobVersion(MobVersion mob_version)
{ {
if (inventory_version <= LastNonPCInventoryVersion || inventory_version > LastOfflinePCInventoryVersion) if (mob_version <= LastNonPCMobVersion || mob_version > LastOfflinePCMobVersion)
return InventoryVersion::Unknown; return MobVersion::Unknown;
return inventory_version; return mob_version;
} }
const char* EQEmu::versions::InventoryVersionName(InventoryVersion inventory_version) const char* EQEmu::versions::MobVersionName(MobVersion mob_version)
{ {
switch (inventory_version) { switch (mob_version) {
case InventoryVersion::Unknown: case MobVersion::Unknown:
return "Unknown Version"; return "Unknown Version";
case InventoryVersion::Client62: case MobVersion::Client62:
return "Client 6.2"; return "Client 6.2";
case InventoryVersion::Titanium: case MobVersion::Titanium:
return "Titanium"; return "Titanium";
case InventoryVersion::SoF: case MobVersion::SoF:
return "SoF"; return "SoF";
case InventoryVersion::SoD: case MobVersion::SoD:
return "SoD"; return "SoD";
case InventoryVersion::UF: case MobVersion::UF:
return "UF"; return "UF";
case InventoryVersion::RoF: case MobVersion::RoF:
return "RoF"; return "RoF";
case InventoryVersion::RoF2: case MobVersion::RoF2:
return "RoF2"; return "RoF2";
case InventoryVersion::NPC: case MobVersion::NPC:
return "NPC"; return "NPC";
case InventoryVersion::NPCMerchant: case MobVersion::NPCMerchant:
return "NPC Merchant"; return "NPC Merchant";
case InventoryVersion::Merc: case MobVersion::Merc:
return "Merc"; return "Merc";
case InventoryVersion::Bot: case MobVersion::Bot:
return "Bot"; return "Bot";
case InventoryVersion::ClientPet: case MobVersion::ClientPet:
return "Client Pet"; return "Client Pet";
case InventoryVersion::NPCPet: case MobVersion::NPCPet:
return "NPC Pet"; return "NPC Pet";
case InventoryVersion::MercPet: case MobVersion::MercPet:
return "Merc Pet"; return "Merc Pet";
case InventoryVersion::BotPet: case MobVersion::BotPet:
return "Bot Pet"; return "Bot Pet";
case InventoryVersion::OfflineTitanium: case MobVersion::OfflineTitanium:
return "Offline Titanium"; return "Offline Titanium";
case InventoryVersion::OfflineSoF: case MobVersion::OfflineSoF:
return "Offline SoF"; return "Offline SoF";
case InventoryVersion::OfflineSoD: case MobVersion::OfflineSoD:
return "Offline SoD"; return "Offline SoD";
case InventoryVersion::OfflineUF: case MobVersion::OfflineUF:
return "Offline UF"; return "Offline UF";
case InventoryVersion::OfflineRoF: case MobVersion::OfflineRoF:
return "Offline RoF"; return "Offline RoF";
case InventoryVersion::OfflineRoF2: case MobVersion::OfflineRoF2:
return "Offline RoF2"; return "Offline RoF2";
default: default:
return "Invalid Version"; return "Invalid Version";
}; };
} }
EQEmu::versions::ClientVersion EQEmu::versions::ConvertInventoryVersionToClientVersion(InventoryVersion inventory_version) EQEmu::versions::ClientVersion EQEmu::versions::ConvertMobVersionToClientVersion(MobVersion mob_version)
{ {
switch (inventory_version) { switch (mob_version) {
case InventoryVersion::Unknown: case MobVersion::Unknown:
case InventoryVersion::Client62: case MobVersion::Client62:
return ClientVersion::Unknown; return ClientVersion::Unknown;
case InventoryVersion::Titanium: case MobVersion::Titanium:
return ClientVersion::Titanium; return ClientVersion::Titanium;
case InventoryVersion::SoF: case MobVersion::SoF:
return ClientVersion::SoF; return ClientVersion::SoF;
case InventoryVersion::SoD: case MobVersion::SoD:
return ClientVersion::SoD; return ClientVersion::SoD;
case InventoryVersion::UF: case MobVersion::UF:
return ClientVersion::UF; return ClientVersion::UF;
case InventoryVersion::RoF: case MobVersion::RoF:
return ClientVersion::RoF; return ClientVersion::RoF;
case InventoryVersion::RoF2: case MobVersion::RoF2:
return ClientVersion::RoF2; return ClientVersion::RoF2;
default: default:
return ClientVersion::Unknown; return ClientVersion::Unknown;
} }
} }
EQEmu::versions::InventoryVersion EQEmu::versions::ConvertClientVersionToInventoryVersion(ClientVersion client_version) EQEmu::versions::MobVersion EQEmu::versions::ConvertClientVersionToMobVersion(ClientVersion client_version)
{ {
switch (client_version) { switch (client_version) {
case ClientVersion::Unknown: case ClientVersion::Unknown:
case ClientVersion::Client62: case ClientVersion::Client62:
return InventoryVersion::Unknown; return MobVersion::Unknown;
case ClientVersion::Titanium: case ClientVersion::Titanium:
return InventoryVersion::Titanium; return MobVersion::Titanium;
case ClientVersion::SoF: case ClientVersion::SoF:
return InventoryVersion::SoF; return MobVersion::SoF;
case ClientVersion::SoD: case ClientVersion::SoD:
return InventoryVersion::SoD; return MobVersion::SoD;
case ClientVersion::UF: case ClientVersion::UF:
return InventoryVersion::UF; return MobVersion::UF;
case ClientVersion::RoF: case ClientVersion::RoF:
return InventoryVersion::RoF; return MobVersion::RoF;
case ClientVersion::RoF2: case ClientVersion::RoF2:
return InventoryVersion::RoF2; return MobVersion::RoF2;
default: default:
return InventoryVersion::Unknown; return MobVersion::Unknown;
} }
} }
EQEmu::versions::InventoryVersion EQEmu::versions::ConvertPCInventoryVersionToOfflinePCInventoryVersion(InventoryVersion inventory_version) EQEmu::versions::MobVersion EQEmu::versions::ConvertPCMobVersionToOfflinePCMobVersion(MobVersion mob_version)
{ {
switch (inventory_version) { switch (mob_version) {
case InventoryVersion::Titanium: case MobVersion::Titanium:
return InventoryVersion::OfflineTitanium; return MobVersion::OfflineTitanium;
case InventoryVersion::SoF: case MobVersion::SoF:
return InventoryVersion::OfflineSoF; return MobVersion::OfflineSoF;
case InventoryVersion::SoD: case MobVersion::SoD:
return InventoryVersion::OfflineSoD; return MobVersion::OfflineSoD;
case InventoryVersion::UF: case MobVersion::UF:
return InventoryVersion::OfflineUF; return MobVersion::OfflineUF;
case InventoryVersion::RoF: case MobVersion::RoF:
return InventoryVersion::OfflineRoF; return MobVersion::OfflineRoF;
case InventoryVersion::RoF2: case MobVersion::RoF2:
return InventoryVersion::OfflineRoF2; return MobVersion::OfflineRoF2;
default: default:
return InventoryVersion::Unknown; return MobVersion::Unknown;
} }
} }
EQEmu::versions::InventoryVersion EQEmu::versions::ConvertOfflinePCInventoryVersionToPCInventoryVersion(InventoryVersion inventory_version) EQEmu::versions::MobVersion EQEmu::versions::ConvertOfflinePCMobVersionToPCMobVersion(MobVersion mob_version)
{ {
switch (inventory_version) { switch (mob_version) {
case InventoryVersion::OfflineTitanium: case MobVersion::OfflineTitanium:
return InventoryVersion::Titanium; return MobVersion::Titanium;
case InventoryVersion::OfflineSoF: case MobVersion::OfflineSoF:
return InventoryVersion::SoF; return MobVersion::SoF;
case InventoryVersion::OfflineSoD: case MobVersion::OfflineSoD:
return InventoryVersion::SoD; return MobVersion::SoD;
case InventoryVersion::OfflineUF: case MobVersion::OfflineUF:
return InventoryVersion::UF; return MobVersion::UF;
case InventoryVersion::OfflineRoF: case MobVersion::OfflineRoF:
return InventoryVersion::RoF; return MobVersion::RoF;
case InventoryVersion::OfflineRoF2: case MobVersion::OfflineRoF2:
return InventoryVersion::RoF2; return MobVersion::RoF2;
default: default:
return InventoryVersion::Unknown; return MobVersion::Unknown;
} }
} }
EQEmu::versions::ClientVersion EQEmu::versions::ConvertOfflinePCInventoryVersionToClientVersion(InventoryVersion inventory_version) EQEmu::versions::ClientVersion EQEmu::versions::ConvertOfflinePCMobVersionToClientVersion(MobVersion mob_version)
{ {
switch (inventory_version) { switch (mob_version) {
case InventoryVersion::OfflineTitanium: case MobVersion::OfflineTitanium:
return ClientVersion::Titanium; return ClientVersion::Titanium;
case InventoryVersion::OfflineSoF: case MobVersion::OfflineSoF:
return ClientVersion::SoF; return ClientVersion::SoF;
case InventoryVersion::OfflineSoD: case MobVersion::OfflineSoD:
return ClientVersion::SoD; return ClientVersion::SoD;
case InventoryVersion::OfflineUF: case MobVersion::OfflineUF:
return ClientVersion::UF; return ClientVersion::UF;
case InventoryVersion::OfflineRoF: case MobVersion::OfflineRoF:
return ClientVersion::RoF; return ClientVersion::RoF;
case InventoryVersion::OfflineRoF2: case MobVersion::OfflineRoF2:
return ClientVersion::RoF2; return ClientVersion::RoF2;
default: default:
return ClientVersion::Unknown; return ClientVersion::Unknown;
} }
} }
EQEmu::versions::InventoryVersion EQEmu::versions::ConvertClientVersionToOfflinePCInventoryVersion(ClientVersion client_version) EQEmu::versions::MobVersion EQEmu::versions::ConvertClientVersionToOfflinePCMobVersion(ClientVersion client_version)
{ {
switch (client_version) { switch (client_version) {
case ClientVersion::Titanium: case ClientVersion::Titanium:
return InventoryVersion::OfflineTitanium; return MobVersion::OfflineTitanium;
case ClientVersion::SoF: case ClientVersion::SoF:
return InventoryVersion::OfflineSoF; return MobVersion::OfflineSoF;
case ClientVersion::SoD: case ClientVersion::SoD:
return InventoryVersion::OfflineSoD; return MobVersion::OfflineSoD;
case ClientVersion::UF: case ClientVersion::UF:
return InventoryVersion::OfflineUF; return MobVersion::OfflineUF;
case ClientVersion::RoF: case ClientVersion::RoF:
return InventoryVersion::OfflineRoF; return MobVersion::OfflineRoF;
case ClientVersion::RoF2: case ClientVersion::RoF2:
return InventoryVersion::OfflineRoF2; return MobVersion::OfflineRoF2;
default: default:
return InventoryVersion::Unknown; return MobVersion::Unknown;
} }
} }

56
common/emu_versions.h
View File

@ -64,17 +64,15 @@ namespace EQEmu
const ClientVersion LastClientVersion = ClientVersion::RoF2; const ClientVersion LastClientVersion = ClientVersion::RoF2;
const size_t ClientVersionCount = (static_cast<size_t>(LastClientVersion) + 1); const size_t ClientVersionCount = (static_cast<size_t>(LastClientVersion) + 1);
extern bool IsValidClientVersion(ClientVersion client_version); bool IsValidClientVersion(ClientVersion client_version);
extern ClientVersion ValidateClientVersion(ClientVersion client_version); ClientVersion ValidateClientVersion(ClientVersion client_version);
extern const char* ClientVersionName(ClientVersion client_version); const char* ClientVersionName(ClientVersion client_version);
extern uint32 ConvertClientVersionToClientVersionBit(ClientVersion client_version); uint32 ConvertClientVersionToClientVersionBit(ClientVersion client_version);
extern ClientVersion ConvertClientVersionBitToClientVersion(uint32 client_version_bit); ClientVersion ConvertClientVersionBitToClientVersion(uint32 client_version_bit);
extern uint32 ConvertClientVersionToExpansion(ClientVersion client_version); uint32 ConvertClientVersionToExpansion(ClientVersion client_version);
} /*versions*/
namespace versions { enum class MobVersion {
enum class InventoryVersion {
Unknown = 0, Unknown = 0,
Client62, Client62,
Titanium, Titanium,
@ -99,29 +97,29 @@ namespace EQEmu
OfflineRoF2 OfflineRoF2
}; };
const InventoryVersion LastInventoryVersion = InventoryVersion::OfflineRoF2; const MobVersion LastMobVersion = MobVersion::OfflineRoF2;
const InventoryVersion LastPCInventoryVersion = InventoryVersion::RoF2; const MobVersion LastPCMobVersion = MobVersion::RoF2;
const InventoryVersion LastNonPCInventoryVersion = InventoryVersion::BotPet; const MobVersion LastNonPCMobVersion = MobVersion::BotPet;
const InventoryVersion LastOfflinePCInventoryVersion = InventoryVersion::OfflineRoF2; const MobVersion LastOfflinePCMobVersion = MobVersion::OfflineRoF2;
const size_t InventoryVersionCount = (static_cast<size_t>(LastInventoryVersion) + 1); const size_t MobVersionCount = (static_cast<size_t>(LastMobVersion) + 1);
extern bool IsValidInventoryVersion(InventoryVersion inventory_version); bool IsValidMobVersion(MobVersion mob_version);
extern bool IsValidPCInventoryVersion(InventoryVersion inventory_version); bool IsValidPCMobVersion(MobVersion mob_version);
extern bool IsValidNonPCInventoryVersion(InventoryVersion inventory_version); bool IsValidNonPCMobVersion(MobVersion mob_version);
extern bool IsValidOfflinePCInventoryVersion(InventoryVersion inventory_version); bool IsValidOfflinePCMobVersion(MobVersion mob_version);
extern InventoryVersion ValidateInventoryVersion(InventoryVersion inventory_version); MobVersion ValidateMobVersion(MobVersion mob_version);
extern InventoryVersion ValidatePCInventoryVersion(InventoryVersion inventory_version); MobVersion ValidatePCMobVersion(MobVersion mob_version);
extern InventoryVersion ValidateNonPCInventoryVersion(InventoryVersion inventory_version); MobVersion ValidateNonPCMobVersion(MobVersion mob_version);
extern InventoryVersion ValidateOfflinePCInventoryVersion(InventoryVersion inventory_version); MobVersion ValidateOfflinePCMobVersion(MobVersion mob_version);
extern const char* InventoryVersionName(InventoryVersion inventory_version); const char* MobVersionName(MobVersion mob_version);
extern ClientVersion ConvertInventoryVersionToClientVersion(InventoryVersion inventory_version); ClientVersion ConvertMobVersionToClientVersion(MobVersion mob_version);
extern InventoryVersion ConvertClientVersionToInventoryVersion(ClientVersion client_version); MobVersion ConvertClientVersionToMobVersion(ClientVersion client_version);
extern InventoryVersion ConvertPCInventoryVersionToOfflinePCInventoryVersion(InventoryVersion inventory_version); MobVersion ConvertPCMobVersionToOfflinePCMobVersion(MobVersion mob_version);
extern InventoryVersion ConvertOfflinePCInventoryVersionToPCInventoryVersion(InventoryVersion inventory_version); MobVersion ConvertOfflinePCMobVersionToPCMobVersion(MobVersion mob_version);
extern ClientVersion ConvertOfflinePCInventoryVersionToClientVersion(InventoryVersion inventory_version); ClientVersion ConvertOfflinePCMobVersionToClientVersion(MobVersion mob_version);
extern InventoryVersion ConvertClientVersionToOfflinePCInventoryVersion(ClientVersion client_version); MobVersion ConvertClientVersionToOfflinePCMobVersion(ClientVersion client_version);
} /*versions*/ } /*versions*/

912
common/eq_limits.cpp
View File

File diff suppressed because it is too large Load Diff

4
common/eq_limits.h
View File

@ -59,7 +59,7 @@ namespace EQEmu
bool AllowOverLevelEquipment; bool AllowOverLevelEquipment;
}; };
const LookupEntry* Lookup(versions::InventoryVersion inventory_version); const LookupEntry* Lookup(versions::MobVersion mob_version);
} /*inventory*/ } /*inventory*/
@ -69,7 +69,7 @@ namespace EQEmu
bool CoinHasWeight; bool CoinHasWeight;
}; };
const LookupEntry* Lookup(versions::InventoryVersion inventory_version); const LookupEntry* Lookup(versions::MobVersion mob_version);
} /*behavior*/ } /*behavior*/

2
common/inventory_profile.cpp
View File

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

21
common/inventory_profile.h
View File

@ -85,22 +85,21 @@ namespace EQEmu
// Public Methods // Public Methods
/////////////////////////////// ///////////////////////////////
InventoryProfile() { m_inventory_version = versions::InventoryVersion::Unknown; m_inventory_version_set = false; } InventoryProfile() { m_mob_version = versions::MobVersion::Unknown; m_mob_version_set = false; }
~InventoryProfile(); ~InventoryProfile();
// inv2 creep bool SetInventoryVersion(versions::MobVersion inventory_version) {
bool SetInventoryVersion(versions::InventoryVersion inventory_version) { if (!m_mob_version_set) {
if (!m_inventory_version_set) { m_mob_version = versions::ValidateMobVersion(inventory_version);
m_inventory_version = versions::ValidateInventoryVersion(inventory_version); return (m_mob_version_set = true);
return (m_inventory_version_set = true);
} }
else { else {
return false; return false;
} }
} }
bool SetInventoryVersion(versions::ClientVersion client_version) { return SetInventoryVersion(versions::ConvertClientVersionToInventoryVersion(client_version)); } bool SetInventoryVersion(versions::ClientVersion client_version) { return SetInventoryVersion(versions::ConvertClientVersionToMobVersion(client_version)); }
versions::InventoryVersion InventoryVersion() { return m_inventory_version; } versions::MobVersion InventoryVersion() { return m_mob_version; }
static void CleanDirty(); static void CleanDirty();
static void MarkDirty(ItemInstance *inst); static void MarkDirty(ItemInstance *inst);
@ -222,9 +221,9 @@ namespace EQEmu
::ItemInstQueue m_cursor; // Items on cursor: FIFO ::ItemInstQueue m_cursor; // Items on cursor: FIFO
private: private:
// Active inventory version // Active mob version
versions::InventoryVersion m_inventory_version; versions::MobVersion m_mob_version;
bool m_inventory_version_set; bool m_mob_version_set;
}; };
} }

2
zone/client_mods.cpp
View File

@ -1369,7 +1369,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::behavior::Lookup(EQEmu::versions::ConvertClientVersionToInventoryVersion(ClientVersion()))->CoinHasWeight) { if (EQEmu::behavior::Lookup(EQEmu::versions::ConvertClientVersionToMobVersion(ClientVersion()))->CoinHasWeight) {
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/corpse.cpp
View File

@ -999,7 +999,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::Lookup(EQEmu::versions::ConvertClientVersionToInventoryVersion(client->ClientVersion()))->InventoryTypeSize[EQEmu::inventory::typeCorpse]; int corpselootlimit = EQEmu::inventory::Lookup(EQEmu::versions::ConvertClientVersionToMobVersion(client->ClientVersion()))->InventoryTypeSize[EQEmu::inventory::typeCorpse];
for(; cur != end; ++cur) { for(; cur != end; ++cur) {
ServerLootItem_Struct* item_data = *cur; ServerLootItem_Struct* item_data = *cur;
@ -1294,7 +1294,7 @@ void Corpse::QueryLoot(Client* to) {
cur = itemlist.begin(); cur = itemlist.begin();
end = itemlist.end(); end = itemlist.end();
int corpselootlimit = EQEmu::inventory::Lookup(EQEmu::versions::ConvertClientVersionToInventoryVersion(to->ClientVersion()))->InventoryTypeSize[EQEmu::inventory::typeCorpse]; int corpselootlimit = EQEmu::inventory::Lookup(EQEmu::versions::ConvertClientVersionToMobVersion(to->ClientVersion()))->InventoryTypeSize[EQEmu::inventory::typeCorpse];
for(; cur != end; ++cur) { for(; cur != end; ++cur) {
ServerLootItem_Struct* sitem = *cur; ServerLootItem_Struct* sitem = *cur;