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

Reworked ClientVersion into EQEmu::versions; Added EQEmu::versions::InventoryVersion

Browse Source
This commit is contained in:
Uleat 2016-04-22 03:49:17 -04:00
parent 6bc60391fb
commit b3475d7b50
66 changed files with 732 additions and 561 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
changelog.txt
View File

@ -1,5 +1,8 @@
EQEMu Changelog (Started on Sept 24, 2003 15:50) EQEMu Changelog (Started on Sept 24, 2003 15:50)
------------------------------------------------------- -------------------------------------------------------
== 04/22/2016 ==
Uleat: Reworked ClientVersion into namespace EQEmu; Added InventoryVersion
== 04/19/2016 == == 04/19/2016 ==
Uleat: Changed the recent EQEmu rework to eliminate the nested class design (possible cause of VS2015 update crashes - unverified) Uleat: Changed the recent EQEmu rework to eliminate the nested class design (possible cause of VS2015 update crashes - unverified)
Uleat: Some more inv2 convergence work Uleat: Some more inv2 convergence work

4
common/CMakeLists.txt
View File

@ -3,6 +3,7 @@ CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
SET(common_sources SET(common_sources
base_packet.cpp base_packet.cpp
classes.cpp classes.cpp
client_version.cpp
condition.cpp condition.cpp
crash.cpp crash.cpp
crc16.cpp crc16.cpp
@ -33,6 +34,7 @@ SET(common_sources
faction.cpp faction.cpp
guild_base.cpp guild_base.cpp
guilds.cpp guilds.cpp
inventory_version.cpp
ipc_mutex.cpp ipc_mutex.cpp
item.cpp item.cpp
light_source.cpp light_source.cpp
@ -101,6 +103,7 @@ SET(common_headers
base_data.h base_data.h
bodytypes.h bodytypes.h
classes.h classes.h
client_version.h
condition.h condition.h
crash.h crash.h
crc16.h crc16.h
@ -142,6 +145,7 @@ SET(common_headers
global_define.h global_define.h
guild_base.h guild_base.h
guilds.h guilds.h
inventory_version.h
ipc_mutex.h ipc_mutex.h
item.h item.h
item_fieldlist.h item_fieldlist.h

128
common/client_version.cpp Normal file
View File

@ -0,0 +1,128 @@
/* EQEMu: Everquest Server Emulator
Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY except by those people which sell it, which
are required to give you total support for your newly bought product;
without even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "client_version.h"
bool EQEmu::versions::IsValidClientVersion(ClientVersion client_version)
{
if (client_version <= ClientVersion::Unknown || client_version > LastClientVersion)
return false;
return true;
}
EQEmu::versions::ClientVersion EQEmu::versions::ValidateClientVersion(ClientVersion client_version)
{
if (client_version <= ClientVersion::Unknown || client_version > LastClientVersion)
return ClientVersion::Unknown;
return client_version;
}
const char* EQEmu::versions::ClientVersionName(ClientVersion client_version)
{
switch (client_version) {
case ClientVersion::Unknown:
return "Unknown Version";
case ClientVersion::Client62:
return "Client 6.2";
case ClientVersion::Titanium:
return "Titanium";
case ClientVersion::SoF:
return "SoF";
case ClientVersion::SoD:
return "SoD";
case ClientVersion::UF:
return "UF";
case ClientVersion::RoF:
return "RoF";
case ClientVersion::RoF2:
return "RoF2";
default:
return "Invalid Version";
};
}
uint32 EQEmu::versions::ConvertClientVersionToClientVersionBit(ClientVersion client_version)
{
switch (client_version) {
case ClientVersion::Unknown:
case ClientVersion::Client62:
return bit_Unknown;
case ClientVersion::Titanium:
return bit_Titanium;
case ClientVersion::SoF:
return bit_SoF;
case ClientVersion::SoD:
return bit_SoD;
case ClientVersion::UF:
return bit_UF;
case ClientVersion::RoF:
return bit_RoF;
case ClientVersion::RoF2:
return bit_RoF2;
default:
return bit_Unknown;
}
}
EQEmu::versions::ClientVersion EQEmu::versions::ConvertClientVersionBitToClientVersion(uint32 client_version_bit)
{
switch (client_version_bit) {
case (uint32)static_cast<unsigned int>(ClientVersion::Unknown) :
case ((uint32)1 << (static_cast<unsigned int>(ClientVersion::Client62) - 1)) :
return ClientVersion::Unknown;
case ((uint32)1 << (static_cast<unsigned int>(ClientVersion::Titanium) - 1)) :
return ClientVersion::Titanium;
case ((uint32)1 << (static_cast<unsigned int>(ClientVersion::SoF) - 1)) :
return ClientVersion::SoF;
case ((uint32)1 << (static_cast<unsigned int>(ClientVersion::SoD) - 1)) :
return ClientVersion::SoD;
case ((uint32)1 << (static_cast<unsigned int>(ClientVersion::UF) - 1)) :
return ClientVersion::UF;
case ((uint32)1 << (static_cast<unsigned int>(ClientVersion::RoF) - 1)) :
return ClientVersion::RoF;
case ((uint32)1 << (static_cast<unsigned int>(ClientVersion::RoF2) - 1)) :
return ClientVersion::RoF2;
default:
return ClientVersion::Unknown;
}
}
uint32 EQEmu::versions::ConvertClientVersionToExpansion(ClientVersion client_version)
{
switch (client_version) {
case ClientVersion::Unknown:
case ClientVersion::Client62:
case ClientVersion::Titanium:
return 0x000007FFU;
case ClientVersion::SoF:
return 0x00007FFFU;
case ClientVersion::SoD:
return 0x0000FFFFU;
case ClientVersion::UF:
return 0x0001FFFFU;
case ClientVersion::RoF:
case ClientVersion::RoF2:
return 0x000FFFFFU;
default:
return 0;
}
}

74
common/client_version.h Normal file
View File

@ -0,0 +1,74 @@
/* EQEMu: Everquest Server Emulator
Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY except by those people which sell it, which
are required to give you total support for your newly bought product;
without even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef COMMON_CLIENT_VERSION_H
#define COMMON_CLIENT_VERSION_H
#include "types.h"
namespace EQEmu
{
namespace versions {
enum class ClientVersion {
Unknown = 0,
Client62, // Build: 'Aug 4 2005 15:40:59'
Titanium, // Build: 'Oct 31 2005 10:33:37'
SoF, // Build: 'Sep 7 2007 09:11:49'
SoD, // Build: 'Dec 19 2008 15:22:49'
UF, // Build: 'Jun 8 2010 16:44:32'
RoF, // Build: 'Dec 10 2012 17:35:44'
RoF2 // Build: 'May 10 2013 23:30:08'
};
enum ClientVersionBit : uint32 {
bit_Unknown = 0,
bit_Client62 = 0x00000001, // unsupported (placeholder for scripts)
bit_Titanium = 0x00000002,
bit_SoF = 0x00000004,
bit_SoD = 0x00000008,
bit_UF = 0x00000010,
bit_RoF = 0x00000020,
bit_RoF2 = 0x00000040,
bit_TitaniumAndEarlier = 0x00000003,
bit_SoFAndEarlier = 0x00000007,
bit_SoDAndEarlier = 0x0000000F,
bit_UFAndEarlier = 0x0000001F,
bit_RoFAndEarlier = 0x0000003F,
bit_SoFAndLater = 0xFFFFFFFC,
bit_SoDAndLater = 0xFFFFFFF8,
bit_UFAndLater = 0xFFFFFFF0,
bit_RoFAndLater = 0xFFFFFFE0,
bit_RoF2AndLater = 0xFFFFFFC0,
bit_AllClients = 0xFFFFFFFF
};
static const ClientVersion LastClientVersion = ClientVersion::RoF2;
static const size_t ClientVersionCount = (static_cast<size_t>(LastClientVersion) + 1);
extern bool IsValidClientVersion(ClientVersion client_version);
extern ClientVersion ValidateClientVersion(ClientVersion client_version);
extern const char* ClientVersionName(ClientVersion client_version);
extern uint32 ConvertClientVersionToClientVersionBit(ClientVersion client_version);
extern ClientVersion ConvertClientVersionBitToClientVersion(uint32 client_version_bit);
extern uint32 ConvertClientVersionToExpansion(ClientVersion client_version);
}
}
#endif /* COMMON_CLIENT_VERSION_H */

182
common/clientversions.h
View File

@ -1,182 +0,0 @@
/*
EQEMu: Everquest Server Emulator
Copyright (C) 2001-2015 EQEMu Development Team (http://eqemulator.net)
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY except by those people which sell it, which
are required to give you total support for your newly bought product;
without even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef CLIENTVERSIONS_H
#define CLIENTVERSIONS_H
#include "types.h"
static const uint32 BIT_Client62 = 0x00000001; // 1 (unsupported - placeholder for scripts)
static const uint32 BIT_Titanium = 0x00000002; // 2
static const uint32 BIT_SoF = 0x00000004; // 4
static const uint32 BIT_SoD = 0x00000008; // 8
static const uint32 BIT_UF = 0x00000010; // 16
static const uint32 BIT_RoF = 0x00000020; // 32
static const uint32 BIT_RoF2 = 0x00000040; // 64
static const uint32 BIT_TitaniumAndEarlier = 0x00000003; // 3
static const uint32 BIT_SoFAndEarlier = 0x00000007; // 7
static const uint32 BIT_SoDAndEarlier = 0x0000000F; // 15
static const uint32 BIT_UFAndEarlier = 0x0000001F; // 31
static const uint32 BIT_RoFAndEarlier = 0x0000003F; // 63
static const uint32 BIT_SoFAndLater = 0xFFFFFFFC; // 4294967292
static const uint32 BIT_SoDAndLater = 0xFFFFFFF8; // 4294967288
static const uint32 BIT_UFAndLater = 0xFFFFFFF0; // 4294967280
static const uint32 BIT_RoFAndLater = 0xFFFFFFE0; // 4294967264
static const uint32 BIT_RoF2AndLater = 0xFFFFFFC0; // 4294967232
static const uint32 BIT_AllClients = 0xFFFFFFFF;
enum class ClientVersion
{
Unknown = 0,
Client62, // Build: 'Aug 4 2005 15:40:59'
Titanium, // Build: 'Oct 31 2005 10:33:37'
SoF, // Build: 'Sep 7 2007 09:11:49'
SoD, // Build: 'Dec 19 2008 15:22:49'
UF, // Build: 'Jun 8 2010 16:44:32'
RoF, // Build: 'Dec 10 2012 17:35:44'
RoF2, // Build: 'May 10 2013 23:30:08'
MobNPC,
MobMerc,
MobBot,
MobPet,
};
#define CLIENT_VERSION_COUNT 12
#define LAST_PC_CLIENT ClientVersion::RoF2
#define LAST_NPC_CLIENT ClientVersion::MobPet
static const char* ClientVersionName(ClientVersion version)
{
switch (version)
{
case ClientVersion::Unknown:
return "Unknown";
case ClientVersion::Client62:
return "Client62";
case ClientVersion::Titanium:
return "Titanium";
case ClientVersion::SoF:
return "SoF";
case ClientVersion::SoD:
return "SoD";
case ClientVersion::UF:
return "UF";
case ClientVersion::RoF:
return "RoF";
case ClientVersion::RoF2:
return "RoF2";
case ClientVersion::MobNPC:
return "MobNPC";
case ClientVersion::MobMerc:
return "MobMerc";
case ClientVersion::MobBot:
return "MobBot";
case ClientVersion::MobPet:
return "MobPet";
default:
return "<ERROR> Invalid ClientVersion";
};
}
static uint32 ClientBitFromVersion(ClientVersion clientVersion)
{
switch (clientVersion)
{
case ClientVersion::Unknown:
case ClientVersion::Client62:
return 0;
case ClientVersion::Titanium:
case ClientVersion::SoF:
case ClientVersion::SoD:
case ClientVersion::UF:
case ClientVersion::RoF:
case ClientVersion::RoF2:
case ClientVersion::MobNPC:
case ClientVersion::MobMerc:
case ClientVersion::MobBot:
case ClientVersion::MobPet:
return ((uint32)1 << (static_cast<unsigned int>(clientVersion) - 1));
default:
return 0;
}
}
static ClientVersion ClientVersionFromBit(uint32 clientVersionBit)
{
switch (clientVersionBit)
{
case (uint32)static_cast<unsigned int>(ClientVersion::Unknown):
case ((uint32)1 << (static_cast<unsigned int>(ClientVersion::Client62) - 1)):
return ClientVersion::Unknown;
case ((uint32)1 << (static_cast<unsigned int>(ClientVersion::Titanium) - 1)):
return ClientVersion::Titanium;
case ((uint32)1 << (static_cast<unsigned int>(ClientVersion::SoF) - 1)):
return ClientVersion::SoF;
case ((uint32)1 << (static_cast<unsigned int>(ClientVersion::SoD) - 1)):
return ClientVersion::SoD;
case ((uint32)1 << (static_cast<unsigned int>(ClientVersion::UF) - 1)):
return ClientVersion::UF;
case ((uint32)1 << (static_cast<unsigned int>(ClientVersion::RoF) - 1)):
return ClientVersion::RoF;
case ((uint32)1 << (static_cast<unsigned int>(ClientVersion::RoF2) - 1)):
return ClientVersion::RoF2;
case ((uint32)1 << (static_cast<unsigned int>(ClientVersion::MobNPC) - 1)):
return ClientVersion::MobNPC;
case ((uint32)1 << (static_cast<unsigned int>(ClientVersion::MobMerc) - 1)):
return ClientVersion::MobMerc;
case ((uint32)1 << (static_cast<unsigned int>(ClientVersion::MobBot) - 1)):
return ClientVersion::MobBot;
case ((uint32)1 << (static_cast<unsigned int>(ClientVersion::MobPet) - 1)):
return ClientVersion::MobPet;
default:
return ClientVersion::Unknown;
}
}
static uint32 ExpansionFromClientVersion(ClientVersion clientVersion)
{
switch(clientVersion)
{
case ClientVersion::Unknown:
case ClientVersion::Client62:
case ClientVersion::Titanium:
return 0x000007FFU;
case ClientVersion::SoF:
return 0x00007FFFU;
case ClientVersion::SoD:
return 0x0000FFFFU;
case ClientVersion::UF:
return 0x0001FFFFU;
case ClientVersion::RoF:
case ClientVersion::RoF2:
return 0x000FFFFFU;
default:
return 0;
}
}
#endif /* CLIENTVERSIONS_H */

6
common/emu_constants.h
View File

@ -26,6 +26,7 @@
//using namespace RoF::slots; // server possessions slots enumeration (code and database sync'd to reference) //using namespace RoF::slots; // server possessions slots enumeration (code and database sync'd to reference)
#include "emu_legacy.h" #include "emu_legacy.h"
#include "inventory_version.h"
#include "light_source.h" #include "light_source.h"
#include "deity.h" #include "deity.h"
#include "say_link.h" #include "say_link.h"
@ -44,9 +45,8 @@ namespace EQEmu
// an immutable value is required to initialize arrays, etc... use this class as a repository for those // an immutable value is required to initialize arrays, etc... use this class as a repository for those
namespace constants { namespace constants {
// database // database
static const ClientVersion CHARACTER_CREATION_CLIENT = ClientVersion::RoF2; // adjust according to starting item placement and target client static const EQEmu::versions::ClientVersion CharacterCreationClient = EQEmu::versions::ClientVersion::RoF2;
static const size_t CharacterCreationLimit = RoF2::consts::CHARACTER_CREATION_LIMIT;
static const size_t CHARACTER_CREATION_LIMIT = RoF2::consts::CHARACTER_CREATION_LIMIT;
// inventory // inventory
extern uint16 InventoryTypeSize(int16 type_index); extern uint16 InventoryTypeSize(int16 type_index);

119
common/eq_limits.cpp
View File

@ -20,61 +20,10 @@
#include "emu_constants.h" #include "emu_constants.h"
// client validation
bool EQEmu::limits::IsValidPCClientVersion(ClientVersion clientVersion)
{
if (clientVersion > ClientVersion::Unknown && clientVersion <= LAST_PC_CLIENT)
return true;
return false;
}
ClientVersion EQEmu::limits::ValidatePCClientVersion(ClientVersion clientVersion)
{
if (clientVersion > ClientVersion::Unknown && clientVersion <= LAST_PC_CLIENT)
return clientVersion;
return ClientVersion::Unknown;
}
// npc validation
bool EQEmu::limits::IsValidNPCClientVersion(ClientVersion clientVersion)
{
if (clientVersion > LAST_PC_CLIENT && clientVersion <= LAST_NPC_CLIENT)
return true;
return false;
}
ClientVersion EQEmu::limits::ValidateNPCClientVersion(ClientVersion clientVersion)
{
if (clientVersion > LAST_PC_CLIENT && clientVersion <= LAST_NPC_CLIENT)
return clientVersion;
return ClientVersion::Unknown;
}
// mob validation
bool EQEmu::limits::IsValidMobClientVersion(ClientVersion clientVersion)
{
if (clientVersion > ClientVersion::Unknown && clientVersion <= LAST_NPC_CLIENT)
return true;
return false;
}
ClientVersion EQEmu::limits::ValidateMobClientVersion(ClientVersion clientVersion)
{
if (clientVersion > ClientVersion::Unknown && clientVersion <= LAST_NPC_CLIENT)
return clientVersion;
return ClientVersion::Unknown;
}
// database // database
size_t EQEmu::limits::CharacterCreationLimit(ClientVersion clientVersion) size_t EQEmu::limits::CharacterCreationLimit(versions::ClientVersion client_version)
{ {
static const size_t local[CLIENT_VERSION_COUNT] = { static const size_t local[versions::InventoryVersionCount] = {
/*Unknown*/ NOT_USED, /*Unknown*/ NOT_USED,
/*Client62*/ NOT_USED, /*Client62*/ NOT_USED,
/*Titanium*/ Titanium::consts::CHARACTER_CREATION_LIMIT, /*Titanium*/ Titanium::consts::CHARACTER_CREATION_LIMIT,
@ -90,11 +39,11 @@ size_t EQEmu::limits::CharacterCreationLimit(ClientVersion clientVersion)
/*MobPet*/ NOT_USED /*MobPet*/ NOT_USED
}; };
return local[static_cast<unsigned int>(ValidateMobClientVersion(clientVersion))]; return local[static_cast<size_t>(versions::ValidateClientVersion(client_version))];
} }
// inventory // inventory
uint16 EQEmu::limits::InventoryMapSize(int16 indexMap, ClientVersion clientVersion) uint16 EQEmu::limits::InventoryTypeSize(versions::InventoryVersion inventory_version, int16 inv_type)
{ {
// not all maps will have an instantiated container..some are references for queue generators (i.e., bazaar, mail, etc...) // not all maps will have an instantiated container..some are references for queue generators (i.e., bazaar, mail, etc...)
// a zero '0' indicates a needed value..otherwise, change to '_NOTUSED' for a null value so indices requiring research can be identified // a zero '0' indicates a needed value..otherwise, change to '_NOTUSED' for a null value so indices requiring research can be identified
@ -107,7 +56,7 @@ uint16 EQEmu::limits::InventoryMapSize(int16 indexMap, ClientVersion clientVersi
// //
// when setting NPC-based values, try to adhere to an constants::<property> or NOT_USED value to avoid unnecessary issues // when setting NPC-based values, try to adhere to an constants::<property> or NOT_USED value to avoid unnecessary issues
static const uint16 local[TypeCount][CLIENT_VERSION_COUNT] = { static const uint16 local[TypeCount][versions::InventoryVersionCount] = {
// server and database are sync'd to current TypePossessions's client as set in 'using namespace RoF::slots;' and // server and database are sync'd to current TypePossessions's client as set in 'using namespace RoF::slots;' and
// 'constants::TYPE_POSSESSIONS_SIZE' - use/update EquipmentBitmask(), GeneralBitmask() and CursorBitmask() // 'constants::TYPE_POSSESSIONS_SIZE' - use/update EquipmentBitmask(), GeneralBitmask() and CursorBitmask()
// for partial range validation checks and 'constants::TYPE_POSSESSIONS_SIZE' for full range iterations // for partial range validation checks and 'constants::TYPE_POSSESSIONS_SIZE' for full range iterations
@ -488,20 +437,20 @@ uint16 EQEmu::limits::InventoryMapSize(int16 indexMap, ClientVersion clientVersi
} }
}; };
if ((uint16)indexMap < TypeCount) if ((uint16)inv_type < TypeCount)
return local[indexMap][static_cast<unsigned int>(ValidateMobClientVersion(clientVersion))]; return local[inv_type][static_cast<size_t>(versions::ValidateInventoryVersion(inventory_version))];
return NOT_USED; return NOT_USED;
} }
uint64 EQEmu::limits::PossessionsBitmask(ClientVersion clientVersion) uint64 EQEmu::limits::PossessionsBitmask(versions::InventoryVersion inventory_version)
{ {
// these are for the new inventory system (RoF)..not the current (Ti) one... // these are for the new inventory system (RoF)..not the current (Ti) one...
// 0x0000000000200000 is SlotPowerSource (SoF+) // 0x0000000000200000 is SlotPowerSource (SoF+)
// 0x0000000080000000 is SlotGeneral9 (RoF+) // 0x0000000080000000 is SlotGeneral9 (RoF+)
// 0x0000000100000000 is SlotGeneral10 (RoF+) // 0x0000000100000000 is SlotGeneral10 (RoF+)
static const uint64 local[CLIENT_VERSION_COUNT] = { static const uint64 local[versions::InventoryVersionCount] = {
/*Unknown*/ NOT_USED, /*Unknown*/ NOT_USED,
/*62*/ 0x000000027FDFFFFF, /*62*/ 0x000000027FDFFFFF,
/*Titanium*/ 0x000000027FDFFFFF, /*Titanium*/ 0x000000027FDFFFFF,
@ -518,12 +467,12 @@ uint64 EQEmu::limits::PossessionsBitmask(ClientVersion clientVersion)
}; };
return NOT_USED; return NOT_USED;
//return local[static_cast<unsigned int>(ValidateMobClientVersion(clientVersion))]; //return local[static_cast<size_t>(versions::ValidateInventoryVersion(inventory_version))];
} }
uint64 EQEmu::limits::EquipmentBitmask(ClientVersion clientVersion) uint64 EQEmu::limits::EquipmentBitmask(versions::InventoryVersion inventory_version)
{ {
static const uint64 local[CLIENT_VERSION_COUNT] = { static const uint64 local[versions::InventoryVersionCount] = {
/*Unknown*/ NOT_USED, /*Unknown*/ NOT_USED,
/*62*/ 0x00000000005FFFFF, /*62*/ 0x00000000005FFFFF,
/*Titanium*/ 0x00000000005FFFFF, /*Titanium*/ 0x00000000005FFFFF,
@ -540,12 +489,12 @@ uint64 EQEmu::limits::EquipmentBitmask(ClientVersion clientVersion)
}; };
return NOT_USED; return NOT_USED;
//return local[static_cast<unsigned int>(ValidateMobClientVersion(clientVersion))]; //return local[static_cast<size_t>(versions::ValidateInventoryVersion(inventory_version))];
} }
uint64 EQEmu::limits::GeneralBitmask(ClientVersion clientVersion) uint64 EQEmu::limits::GeneralBitmask(versions::InventoryVersion inventory_version)
{ {
static const uint64 local[CLIENT_VERSION_COUNT] = { static const uint64 local[versions::InventoryVersionCount] = {
/*Unknown*/ NOT_USED, /*Unknown*/ NOT_USED,
/*62*/ 0x000000007F800000, /*62*/ 0x000000007F800000,
/*Titanium*/ 0x000000007F800000, /*Titanium*/ 0x000000007F800000,
@ -562,12 +511,12 @@ uint64 EQEmu::limits::GeneralBitmask(ClientVersion clientVersion)
}; };
return NOT_USED; return NOT_USED;
//return local[static_cast<unsigned int>(ValidateMobClientVersion(clientVersion))]; //return local[static_cast<size_t>(versions::ValidateInventoryVersion(inventory_version))];
} }
uint64 EQEmu::limits::CursorBitmask(ClientVersion clientVersion) uint64 EQEmu::limits::CursorBitmask(versions::InventoryVersion inventory_version)
{ {
static const uint64 local[CLIENT_VERSION_COUNT] = { static const uint64 local[versions::InventoryVersionCount] = {
/*Unknown*/ NOT_USED, /*Unknown*/ NOT_USED,
/*62*/ 0x0000000200000000, /*62*/ 0x0000000200000000,
/*Titanium*/ 0x0000000200000000, /*Titanium*/ 0x0000000200000000,
@ -584,12 +533,12 @@ uint64 EQEmu::limits::CursorBitmask(ClientVersion clientVersion)
}; };
return NOT_USED; return NOT_USED;
//return local[static_cast<unsigned int>(ValidateMobClientVersion(clientVersion))]; //return local[static_cast<size_t>(versions::ValidateInventoryVersion(inventory_version))];
} }
bool EQEmu::limits::AllowsEmptyBagInBag(ClientVersion clientVersion) bool EQEmu::limits::AllowEmptyBagInBag(versions::InventoryVersion inventory_version)
{ {
static const bool local[CLIENT_VERSION_COUNT] = { static const bool local[versions::InventoryVersionCount] = {
/*Unknown*/ false, /*Unknown*/ false,
/*62*/ false, /*62*/ false,
/*Titanium*/ Titanium::limits::ALLOWS_EMPTY_BAG_IN_BAG, /*Titanium*/ Titanium::limits::ALLOWS_EMPTY_BAG_IN_BAG,
@ -606,12 +555,12 @@ bool EQEmu::limits::AllowsEmptyBagInBag(ClientVersion clientVersion)
}; };
return false; // not implemented return false; // not implemented
//return local[static_cast<unsigned int>(ValidateMobClientVersion(clientVersion))]; //return local[static_cast<size_t>(versions::ValidateInventoryVersion(inventory_version))];
} }
bool EQEmu::limits::AllowsClickCastFromBag(ClientVersion clientVersion) bool EQEmu::limits::AllowClickCastFromBag(versions::InventoryVersion inventory_version)
{ {
static const bool local[CLIENT_VERSION_COUNT] = { static const bool local[versions::InventoryVersionCount] = {
/*Unknown*/ false, /*Unknown*/ false,
/*62*/ false, /*62*/ false,
/*Titanium*/ Titanium::limits::ALLOWS_CLICK_CAST_FROM_BAG, /*Titanium*/ Titanium::limits::ALLOWS_CLICK_CAST_FROM_BAG,
@ -627,13 +576,13 @@ bool EQEmu::limits::AllowsClickCastFromBag(ClientVersion clientVersion)
/*Pet*/ false /*Pet*/ false
}; };
return local[static_cast<unsigned int>(ValidateMobClientVersion(clientVersion))]; return local[static_cast<size_t>(versions::ValidateInventoryVersion(inventory_version))];
} }
// items // items
uint16 EQEmu::limits::ItemCommonSize(ClientVersion clientVersion) uint16 EQEmu::limits::ItemCommonSize(versions::InventoryVersion inventory_version)
{ {
static const uint16 local[CLIENT_VERSION_COUNT] = { static const uint16 local[versions::InventoryVersionCount] = {
/*Unknown*/ NOT_USED, /*Unknown*/ NOT_USED,
/*62*/ constants::ITEM_COMMON_SIZE, /*62*/ constants::ITEM_COMMON_SIZE,
/*Titanium*/ constants::ITEM_COMMON_SIZE, /*Titanium*/ constants::ITEM_COMMON_SIZE,
@ -649,12 +598,12 @@ uint16 EQEmu::limits::ItemCommonSize(ClientVersion clientVersion)
/*Pet*/ constants::ITEM_COMMON_SIZE /*Pet*/ constants::ITEM_COMMON_SIZE
}; };
return local[static_cast<unsigned int>(ValidateMobClientVersion(clientVersion))]; return local[static_cast<size_t>(versions::ValidateInventoryVersion(inventory_version))];
} }
uint16 EQEmu::limits::ItemContainerSize(ClientVersion clientVersion) uint16 EQEmu::limits::ItemContainerSize(versions::InventoryVersion inventory_version)
{ {
static const uint16 local[CLIENT_VERSION_COUNT] = { static const uint16 local[versions::InventoryVersionCount] = {
/*Unknown*/ NOT_USED, /*Unknown*/ NOT_USED,
/*62*/ constants::ITEM_CONTAINER_SIZE, /*62*/ constants::ITEM_CONTAINER_SIZE,
/*Titanium*/ constants::ITEM_CONTAINER_SIZE, /*Titanium*/ constants::ITEM_CONTAINER_SIZE,
@ -670,12 +619,12 @@ uint16 EQEmu::limits::ItemContainerSize(ClientVersion clientVersion)
/*Pet*/ constants::ITEM_CONTAINER_SIZE /*Pet*/ constants::ITEM_CONTAINER_SIZE
}; };
return local[static_cast<unsigned int>(ValidateMobClientVersion(clientVersion))]; return local[static_cast<size_t>(versions::ValidateInventoryVersion(inventory_version))];
} }
bool EQEmu::limits::CoinHasWeight(ClientVersion clientVersion) bool EQEmu::limits::CoinHasWeight(versions::InventoryVersion inventory_version)
{ {
static const bool local[CLIENT_VERSION_COUNT] = { static const bool local[versions::InventoryVersionCount] = {
/*Unknown*/ true, /*Unknown*/ true,
/*62*/ true, /*62*/ true,
/*Titanium*/ Titanium::limits::COIN_HAS_WEIGHT, /*Titanium*/ Titanium::limits::COIN_HAS_WEIGHT,
@ -691,5 +640,5 @@ bool EQEmu::limits::CoinHasWeight(ClientVersion clientVersion)
/*Pet*/ true /*Pet*/ true
}; };
return local[static_cast<unsigned int>(ValidateMobClientVersion(clientVersion))]; return local[static_cast<size_t>(versions::ValidateInventoryVersion(inventory_version))];
} }

40
common/eq_limits.h
View File

@ -22,7 +22,7 @@
#include "types.h" #include "types.h"
#include "eq_constants.h" #include "eq_constants.h"
#include "clientversions.h" #include "inventory_version.h" // inv2 watch
#include "../common/patches/titanium_constants.h" #include "../common/patches/titanium_constants.h"
#include "../common/patches/sof_constants.h" #include "../common/patches/sof_constants.h"
#include "../common/patches/sod_constants.h" #include "../common/patches/sod_constants.h"
@ -39,42 +39,26 @@
namespace EQEmu namespace EQEmu
{ {
// values should default to a non-beneficial value..unless value conflicts with intended operation
//
// EQEmu::Constants may be used as references..but, not every reference needs to be in EQEmu::Constants (i.e., AllowsEmptyBagInBag(), CoinHasWeight(), etc...)
namespace limits { namespace limits {
// client version validation (checks to avoid crashing zone server when accessing reference arrays)
// use this inside of class Client (limits to actual clients)
extern bool IsValidPCClientVersion(ClientVersion clientVersion);
extern ClientVersion ValidatePCClientVersion(ClientVersion clientVersion);
// basically..any non-client classes - do not invoke when setting a valid client
extern bool IsValidNPCClientVersion(ClientVersion clientVersion);
extern ClientVersion ValidateNPCClientVersion(ClientVersion clientVersion);
// these are 'universal' - do not invoke when setting a valid client
extern bool IsValidMobClientVersion(ClientVersion clientVersion);
extern ClientVersion ValidateMobClientVersion(ClientVersion clientVersion);
// database // database
extern size_t CharacterCreationLimit(ClientVersion clientVersion); extern size_t CharacterCreationLimit(versions::ClientVersion client_version);
// inventory // inventory
extern uint16 InventoryMapSize(int16 indexMap, ClientVersion clientVersion); extern uint16 InventoryTypeSize(versions::InventoryVersion inventory_version, int16 inv_type);
extern uint64 PossessionsBitmask(ClientVersion clientVersion); extern uint64 PossessionsBitmask(versions::InventoryVersion inventory_version);
extern uint64 EquipmentBitmask(ClientVersion clientVersion); extern uint64 EquipmentBitmask(versions::InventoryVersion inventory_version);
extern uint64 GeneralBitmask(ClientVersion clientVersion); extern uint64 GeneralBitmask(versions::InventoryVersion inventory_version);
extern uint64 CursorBitmask(ClientVersion clientVersion); extern uint64 CursorBitmask(versions::InventoryVersion inventory_version);
extern bool AllowsEmptyBagInBag(ClientVersion clientVersion); extern bool AllowEmptyBagInBag(versions::InventoryVersion inventory_version);
extern bool AllowsClickCastFromBag(ClientVersion clientVersion); extern bool AllowClickCastFromBag(versions::InventoryVersion inventory_version);
// items // items
extern uint16 ItemCommonSize(ClientVersion clientVersion); extern uint16 ItemCommonSize(versions::InventoryVersion inventory_version);
extern uint16 ItemContainerSize(ClientVersion clientVersion); extern uint16 ItemContainerSize(versions::InventoryVersion inventory_version);
// player profile // player profile
extern bool CoinHasWeight(ClientVersion clientVersion); extern bool CoinHasWeight(versions::InventoryVersion inventory_version);
} }
} }

4
common/eq_stream_intf.h
View File

@ -4,7 +4,7 @@
//this is the only part of an EQStream that is seen by the application. //this is the only part of an EQStream that is seen by the application.
#include <string> #include <string>
#include "clientversions.h" #include "client_version.h" // inv2 watch
typedef enum { typedef enum {
ESTABLISHED, ESTABLISHED,
@ -35,7 +35,7 @@ public:
virtual const uint32 GetBytesRecieved() const { return 0; } virtual const uint32 GetBytesRecieved() const { return 0; }
virtual const uint32 GetBytesSentPerSecond() const { return 0; } virtual const uint32 GetBytesSentPerSecond() const { return 0; }
virtual const uint32 GetBytesRecvPerSecond() const { return 0; } virtual const uint32 GetBytesRecvPerSecond() const { return 0; }
virtual const ClientVersion GetClientVersion() const { return ClientVersion::Unknown; } virtual const EQEmu::versions::ClientVersion ClientVersion() const { return EQEmu::versions::ClientVersion::Unknown; }
}; };
#endif /*EQSTREAMINTF_H_*/ #endif /*EQSTREAMINTF_H_*/

4
common/eq_stream_proxy.cpp
View File

@ -21,9 +21,9 @@ std::string EQStreamProxy::Describe() const {
return(m_structs->Describe()); return(m_structs->Describe());
} }
const ClientVersion EQStreamProxy::GetClientVersion() const const EQEmu::versions::ClientVersion EQStreamProxy::ClientVersion() const
{ {
return m_structs->GetClientVersion(); return m_structs->ClientVersion();
} }
void EQStreamProxy::QueuePacket(const EQApplicationPacket *p, bool ack_req) { void EQStreamProxy::QueuePacket(const EQApplicationPacket *p, bool ack_req) {

2
common/eq_stream_proxy.h
View File

@ -28,7 +28,7 @@ public:
virtual void RemoveData(); virtual void RemoveData();
virtual bool CheckState(EQStreamState state); virtual bool CheckState(EQStreamState state);
virtual std::string Describe() const; virtual std::string Describe() const;
virtual const ClientVersion GetClientVersion() const; virtual const EQEmu::versions::ClientVersion ClientVersion() const;
virtual const uint32 GetBytesSent() const; virtual const uint32 GetBytesSent() const;
virtual const uint32 GetBytesRecieved() const; virtual const uint32 GetBytesRecieved() const;

147
common/inventory_version.cpp Normal file
View File

@ -0,0 +1,147 @@
/* EQEMu: Everquest Server Emulator
Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY except by those people which sell it, which
are required to give you total support for your newly bought product;
without even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "inventory_version.h"
bool EQEmu::versions::IsValidInventoryVersion(InventoryVersion inventory_version)
{
if (inventory_version <= InventoryVersion::Unknown || inventory_version > LastInventoryVersion)
return false;
return true;
}
bool EQEmu::versions::IsValidPCInventoryVersion(InventoryVersion inventory_version)
{
if (inventory_version <= InventoryVersion::Unknown || inventory_version > LastPCInventoryVersion)
return false;
return true;
}
bool EQEmu::versions::IsValidNonPCInventoryVersion(InventoryVersion inventory_version)
{
if (inventory_version <= LastPCInventoryVersion || inventory_version > LastNonPCInventoryVersion)
return false;
return true;
}
EQEmu::versions::InventoryVersion EQEmu::versions::ValidateInventoryVersion(InventoryVersion inventory_version)
{
if (inventory_version <= InventoryVersion::Unknown || inventory_version > LastInventoryVersion)
return InventoryVersion::Unknown;
return inventory_version;
}
EQEmu::versions::InventoryVersion EQEmu::versions::ValidatePCInventoryVersion(InventoryVersion inventory_version)
{
if (inventory_version <= InventoryVersion::Unknown || inventory_version > LastPCInventoryVersion)
return InventoryVersion::Unknown;
return inventory_version;
}
EQEmu::versions::InventoryVersion EQEmu::versions::ValidateNonPCInventoryVersion(InventoryVersion inventory_version)
{
if (inventory_version <= LastPCInventoryVersion || inventory_version > LastNonPCInventoryVersion)
return InventoryVersion::Unknown;
return inventory_version;
}
const char* EQEmu::versions::InventoryVersionName(InventoryVersion inventory_version)
{
switch (inventory_version) {
case InventoryVersion::Unknown:
return "Unknown Version";
case InventoryVersion::Client62:
return "Client 6.2";
case InventoryVersion::Titanium:
return "Titanium";
case InventoryVersion::SoF:
return "SoF";
case InventoryVersion::SoD:
return "SoD";
case InventoryVersion::UF:
return "UF";
case InventoryVersion::RoF:
return "RoF";
case InventoryVersion::RoF2:
return "RoF2";
case InventoryVersion::NPC:
return "NPC";
case InventoryVersion::Merc:
return "Merc";
case InventoryVersion::Bot:
return "Bot";
case InventoryVersion::Pet:
return "Pet";
default:
return "Invalid Version";
};
}
EQEmu::versions::ClientVersion EQEmu::versions::ConvertInventoryVersionToClientVersion(InventoryVersion inventory_version)
{
switch (inventory_version) {
case InventoryVersion::Unknown:
case InventoryVersion::Client62:
return ClientVersion::Unknown;
case InventoryVersion::Titanium:
return ClientVersion::Titanium;
case InventoryVersion::SoF:
return ClientVersion::SoF;
case InventoryVersion::SoD:
return ClientVersion::SoD;
case InventoryVersion::UF:
return ClientVersion::UF;
case InventoryVersion::RoF:
return ClientVersion::RoF;
case InventoryVersion::RoF2:
return ClientVersion::RoF2;
default:
return ClientVersion::Unknown;
}
}
EQEmu::versions::InventoryVersion EQEmu::versions::ConvertClientVersionToInventoryVersion(ClientVersion client_version)
{
switch (client_version) {
case ClientVersion::Unknown:
case ClientVersion::Client62:
return InventoryVersion::Unknown;
case ClientVersion::Titanium:
return InventoryVersion::Titanium;
case ClientVersion::SoF:
return InventoryVersion::SoF;
case ClientVersion::SoD:
return InventoryVersion::SoD;
case ClientVersion::UF:
return InventoryVersion::UF;
case ClientVersion::RoF:
return InventoryVersion::RoF;
case ClientVersion::RoF2:
return InventoryVersion::RoF2;
default:
return InventoryVersion::Unknown;
}
}

62
common/inventory_version.h Normal file
View File

@ -0,0 +1,62 @@
/* EQEMu: Everquest Server Emulator
Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY except by those people which sell it, which
are required to give you total support for your newly bought product;
without even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef COMMON_INVENTORY_VERSION_H
#define COMMON_INVENTORY_VERSION_H
#include "types.h"
#include "client_version.h"
namespace EQEmu
{
namespace versions {
enum class InventoryVersion {
Unknown = 0,
Client62,
Titanium,
SoF,
SoD,
UF,
RoF,
RoF2,
NPC,
Merc,
Bot,
Pet
};
static const InventoryVersion LastInventoryVersion = InventoryVersion::Pet;
static const InventoryVersion LastPCInventoryVersion = InventoryVersion::RoF2;
static const InventoryVersion LastNonPCInventoryVersion = InventoryVersion::Pet;
static const size_t InventoryVersionCount = (static_cast<size_t>(LastInventoryVersion) + 1);
extern bool IsValidInventoryVersion(InventoryVersion inventory_version);
extern bool IsValidPCInventoryVersion(InventoryVersion inventory_version);
extern bool IsValidNonPCInventoryVersion(InventoryVersion inventory_version);
extern InventoryVersion ValidateInventoryVersion(InventoryVersion inventory_version);
extern InventoryVersion ValidatePCInventoryVersion(InventoryVersion inventory_version);
extern InventoryVersion ValidateNonPCInventoryVersion(InventoryVersion inventory_version);
extern const char* InventoryVersionName(InventoryVersion inventory_version);
extern ClientVersion ConvertInventoryVersionToClientVersion(InventoryVersion inventory_version);
extern InventoryVersion ConvertClientVersionToInventoryVersion(ClientVersion client_version);
}
}
#endif /* COMMON_INVENTORY_VERSION_H */

2
common/item.cpp
View File

@ -927,7 +927,7 @@ bool Inventory::SupportsClickCasting(int16 slot_id)
} }
else if (slot_id >= EQEmu::constants::GENERAL_BAGS_BEGIN && slot_id <= EQEmu::constants::GENERAL_BAGS_END) else if (slot_id >= EQEmu::constants::GENERAL_BAGS_BEGIN && slot_id <= EQEmu::constants::GENERAL_BAGS_END)
{ {
if (EQEmu::limits::AllowsClickCastFromBag(m_version)) if (EQEmu::limits::AllowClickCastFromBag(m_inventory_version))
return true; return true;
} }

19
common/item.h
View File

@ -115,21 +115,22 @@ public:
// Public Methods // Public Methods
/////////////////////////////// ///////////////////////////////
Inventory() { m_version = ClientVersion::Unknown; m_versionset = false; } Inventory() { m_inventory_version = EQEmu::versions::InventoryVersion::Unknown; m_inventory_version_set = false; }
~Inventory(); ~Inventory();
// Inventory v2 creep // inv2 creep
bool SetInventoryVersion(ClientVersion version) { bool SetInventoryVersion(EQEmu::versions::InventoryVersion inventory_version) {
if (!m_versionset) { if (!m_inventory_version_set) {
m_version = version; m_inventory_version = EQEmu::versions::ValidateInventoryVersion(inventory_version);
return (m_versionset = true); return (m_inventory_version_set = true);
} }
else { else {
return false; return false;
} }
} }
bool SetInventoryVersion(EQEmu::versions::ClientVersion client_version) { return SetInventoryVersion(EQEmu::versions::ConvertClientVersionToInventoryVersion(client_version)); }
ClientVersion GetInventoryVersion() { return m_version; } EQEmu::versions::InventoryVersion InventoryVersion() { return m_inventory_version; }
static void CleanDirty(); static void CleanDirty();
static void MarkDirty(ItemInst *inst); static void MarkDirty(ItemInst *inst);
@ -252,8 +253,8 @@ protected:
private: private:
// Active inventory version // Active inventory version
ClientVersion m_version; EQEmu::versions::InventoryVersion m_inventory_version;
bool m_versionset; bool m_inventory_version_set;
}; };
class SharedDatabase; class SharedDatabase;

4
common/patches/rof.cpp
View File

@ -117,9 +117,9 @@ namespace RoF
return(r); return(r);
} }
const ClientVersion Strategy::GetClientVersion() const const EQEmu::versions::ClientVersion Strategy::ClientVersion() const
{ {
return ClientVersion::RoF; return EQEmu::versions::ClientVersion::RoF;
} }
#include "ss_define.h" #include "ss_define.h"

2
common/patches/rof.h
View File

@ -23,7 +23,7 @@ namespace RoF {
protected: protected:
virtual std::string Describe() const; virtual std::string Describe() const;
virtual const ClientVersion GetClientVersion() const; virtual const EQEmu::versions::ClientVersion ClientVersion() const;
//magic macro to declare our opcode processors //magic macro to declare our opcode processors
#include "ss_declare.h" #include "ss_declare.h"

4
common/patches/rof2.cpp
View File

@ -117,9 +117,9 @@ namespace RoF2
return(r); return(r);
} }
const ClientVersion Strategy::GetClientVersion() const const EQEmu::versions::ClientVersion Strategy::ClientVersion() const
{ {
return ClientVersion::RoF2; return EQEmu::versions::ClientVersion::RoF2;
} }
#include "ss_define.h" #include "ss_define.h"

2
common/patches/rof2.h
View File

@ -23,7 +23,7 @@ namespace RoF2 {
protected: protected:
virtual std::string Describe() const; virtual std::string Describe() const;
virtual const ClientVersion GetClientVersion() const; virtual const EQEmu::versions::ClientVersion ClientVersion() const;
//magic macro to declare our opcode processors //magic macro to declare our opcode processors
#include "ss_declare.h" #include "ss_declare.h"

4
common/patches/sod.cpp
View File

@ -113,9 +113,9 @@ namespace SoD
return(r); return(r);
} }
const ClientVersion Strategy::GetClientVersion() const const EQEmu::versions::ClientVersion Strategy::ClientVersion() const
{ {
return ClientVersion::SoD; return EQEmu::versions::ClientVersion::SoD;
} }
#include "ss_define.h" #include "ss_define.h"

2
common/patches/sod.h
View File

@ -23,7 +23,7 @@ namespace SoD {
protected: protected:
virtual std::string Describe() const; virtual std::string Describe() const;
virtual const ClientVersion GetClientVersion() const; virtual const EQEmu::versions::ClientVersion ClientVersion() const;
//magic macro to declare our opcode processors //magic macro to declare our opcode processors
#include "ss_declare.h" #include "ss_declare.h"

4
common/patches/sof.cpp
View File

@ -113,9 +113,9 @@ namespace SoF
return(r); return(r);
} }
const ClientVersion Strategy::GetClientVersion() const const EQEmu::versions::ClientVersion Strategy::ClientVersion() const
{ {
return ClientVersion::SoF; return EQEmu::versions::ClientVersion::SoF;
} }
#include "ss_define.h" #include "ss_define.h"

2
common/patches/sof.h
View File

@ -23,7 +23,7 @@ namespace SoF {
protected: protected:
virtual std::string Describe() const; virtual std::string Describe() const;
virtual const ClientVersion GetClientVersion() const; virtual const EQEmu::versions::ClientVersion ClientVersion() const;
//magic macro to declare our opcode processors //magic macro to declare our opcode processors
#include "ss_declare.h" #include "ss_declare.h"

4
common/patches/titanium.cpp
View File

@ -111,9 +111,9 @@ namespace Titanium
return(r); return(r);
} }
const ClientVersion Strategy::GetClientVersion() const const EQEmu::versions::ClientVersion Strategy::ClientVersion() const
{ {
return ClientVersion::Titanium; return EQEmu::versions::ClientVersion::Titanium;
} }
#include "ss_define.h" #include "ss_define.h"

2
common/patches/titanium.h
View File

@ -23,7 +23,7 @@ namespace Titanium {
protected: protected:
virtual std::string Describe() const; virtual std::string Describe() const;
virtual const ClientVersion GetClientVersion() const; virtual const EQEmu::versions::ClientVersion ClientVersion() const;
//magic macro to declare our opcode processors //magic macro to declare our opcode processors
#include "ss_declare.h" #include "ss_declare.h"

4
common/patches/uf.cpp
View File

@ -113,9 +113,9 @@ namespace UF
return(r); return(r);
} }
const ClientVersion Strategy::GetClientVersion() const const EQEmu::versions::ClientVersion Strategy::ClientVersion() const
{ {
return ClientVersion::UF; return EQEmu::versions::ClientVersion::UF;
} }
#include "ss_define.h" #include "ss_define.h"

2
common/patches/uf.h
View File

@ -23,7 +23,7 @@ namespace UF {
protected: protected:
virtual std::string Describe() const; virtual std::string Describe() const;
virtual const ClientVersion GetClientVersion() const; virtual const EQEmu::versions::ClientVersion ClientVersion() const;
//magic macro to declare our opcode processors //magic macro to declare our opcode processors
#include "ss_declare.h" #include "ss_declare.h"

4
common/struct_strategy.h
View File

@ -4,7 +4,7 @@
class EQApplicationPacket; class EQApplicationPacket;
class EQStream; class EQStream;
#include "emu_opcodes.h" #include "emu_opcodes.h"
#include "clientversions.h" #include "client_version.h" // inv2 watch
#include <string> #include <string>
#include <memory> #include <memory>
@ -25,7 +25,7 @@ public:
void Decode(EQApplicationPacket *p) const; void Decode(EQApplicationPacket *p) const;
virtual std::string Describe() const = 0; virtual std::string Describe() const = 0;
virtual const ClientVersion GetClientVersion() const = 0; virtual const EQEmu::versions::ClientVersion ClientVersion() const = 0;
protected: protected:
//some common coders: //some common coders:

38
world/client.cpp
View File

@ -32,7 +32,7 @@
#include "../common/skills.h" #include "../common/skills.h"
#include "../common/extprofile.h" #include "../common/extprofile.h"
#include "../common/string_util.h" #include "../common/string_util.h"
#include "../common/clientversions.h" #include "../common/client_version.h" // inv2 watch
#include "../common/random.h" #include "../common/random.h"
#include "../common/shareddb.h" #include "../common/shareddb.h"
@ -106,8 +106,8 @@ Client::Client(EQStreamInterface* ieqs)
pwaitingforbootup = 0; pwaitingforbootup = 0;
StartInTutorial = false; StartInTutorial = false;
m_ClientVersion = eqs->GetClientVersion(); m_ClientVersion = eqs->ClientVersion();
m_ClientVersionBit = ClientBitFromVersion(m_ClientVersion); m_ClientVersionBit = EQEmu::versions::ConvertClientVersionToClientVersionBit(m_ClientVersion);
numclients++; numclients++;
} }
@ -171,7 +171,7 @@ void Client::SendExpansionInfo() {
auto outapp = new EQApplicationPacket(OP_ExpansionInfo, sizeof(ExpansionInfo_Struct)); auto outapp = new EQApplicationPacket(OP_ExpansionInfo, sizeof(ExpansionInfo_Struct));
ExpansionInfo_Struct *eis = (ExpansionInfo_Struct*)outapp->pBuffer; ExpansionInfo_Struct *eis = (ExpansionInfo_Struct*)outapp->pBuffer;
if(RuleB(World, UseClientBasedExpansionSettings)) { if(RuleB(World, UseClientBasedExpansionSettings)) {
eis->Expansions = ExpansionFromClientVersion(eqs->GetClientVersion()); eis->Expansions = EQEmu::versions::ConvertClientVersionToExpansion(eqs->ClientVersion());
//eis->Expansions = ExpansionFromClientVersion(this->GetCLE. //eis->Expansions = ExpansionFromClientVersion(this->GetCLE.
} else { } else {
eis->Expansions = (RuleI(World, ExpansionSettings)); eis->Expansions = (RuleI(World, ExpansionSettings));
@ -186,7 +186,7 @@ void Client::SendCharInfo() {
cle->SetOnline(CLE_Status_CharSelect); cle->SetOnline(CLE_Status_CharSelect);
} }
if (m_ClientVersionBit & BIT_RoFAndLater) { if (m_ClientVersionBit & EQEmu::versions::bit_RoFAndLater) {
SendMaxCharCreate(); SendMaxCharCreate();
SendMembership(); SendMembership();
SendMembershipSettings(); SendMembershipSettings();
@ -212,8 +212,8 @@ void Client::SendMaxCharCreate() {
MaxCharacters_Struct* mc = (MaxCharacters_Struct*)outapp->pBuffer; MaxCharacters_Struct* mc = (MaxCharacters_Struct*)outapp->pBuffer;
mc->max_chars = EQEmu::limits::CharacterCreationLimit(m_ClientVersion); mc->max_chars = EQEmu::limits::CharacterCreationLimit(m_ClientVersion);
if (mc->max_chars > EQEmu::constants::CHARACTER_CREATION_LIMIT) if (mc->max_chars > EQEmu::constants::CharacterCreationLimit)
mc->max_chars = EQEmu::constants::CHARACTER_CREATION_LIMIT; mc->max_chars = EQEmu::constants::CharacterCreationLimit;
QueuePacket(outapp); QueuePacket(outapp);
safe_delete(outapp); safe_delete(outapp);
@ -698,7 +698,7 @@ bool Client::HandleCharacterCreatePacket(const EQApplicationPacket *app) {
} }
else else
{ {
if (m_ClientVersionBit & BIT_TitaniumAndEarlier) if (m_ClientVersionBit & EQEmu::versions::bit_TitaniumAndEarlier)
StartInTutorial = true; StartInTutorial = true;
SendCharInfo(); SendCharInfo();
} }
@ -746,9 +746,9 @@ 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::limits::CharacterCreationLimit(eqs->GetClientVersion()); size_t character_limit = EQEmu::limits::CharacterCreationLimit(eqs->ClientVersion());
if (character_limit > EQEmu::constants::CHARACTER_CREATION_LIMIT) { character_limit = EQEmu::constants::CHARACTER_CREATION_LIMIT; } if (character_limit > EQEmu::constants::CharacterCreationLimit) { character_limit = EQEmu::constants::CharacterCreationLimit; }
if (eqs->GetClientVersion() == ClientVersion::Titanium) { character_limit = 8; } if (eqs->ClientVersion() == EQEmu::versions::ClientVersion::Titanium) { character_limit = 8; }
std::string tgh_query = StringFormat( std::string tgh_query = StringFormat(
"SELECT " "SELECT "
@ -879,9 +879,9 @@ bool Client::HandleEnterWorldPacket(const EQApplicationPacket *app) {
char ConnectionType; char ConnectionType;
if (m_ClientVersionBit & BIT_UFAndLater) if (m_ClientVersionBit & EQEmu::versions::bit_UFAndLater)
ConnectionType = 'U'; ConnectionType = 'U';
else if (m_ClientVersionBit & BIT_SoFAndLater) else if (m_ClientVersionBit & EQEmu::versions::bit_SoFAndLater)
ConnectionType = 'S'; ConnectionType = 'S';
else else
ConnectionType = 'C'; ConnectionType = 'C';
@ -905,7 +905,7 @@ bool Client::HandleEnterWorldPacket(const EQApplicationPacket *app) {
outapp2 = new EQApplicationPacket(OP_SetChatServer2); outapp2 = new EQApplicationPacket(OP_SetChatServer2);
if (m_ClientVersionBit & BIT_TitaniumAndEarlier) if (m_ClientVersionBit & EQEmu::versions::bit_TitaniumAndEarlier)
ConnectionType = 'M'; ConnectionType = 'M';
sprintf(buffer,"%s,%i,%s.%s,%c%08X", sprintf(buffer,"%s,%i,%s.%s,%c%08X",
@ -939,7 +939,7 @@ bool Client::HandleDeleteCharacterPacket(const EQApplicationPacket *app) {
bool Client::HandleZoneChangePacket(const EQApplicationPacket *app) { bool Client::HandleZoneChangePacket(const EQApplicationPacket *app) {
// HoT sends this to world while zoning and wants it echoed back. // HoT sends this to world while zoning and wants it echoed back.
if (m_ClientVersionBit & BIT_RoFAndLater) if (m_ClientVersionBit & EQEmu::versions::bit_RoFAndLater)
{ {
QueuePacket(app); QueuePacket(app);
} }
@ -1412,7 +1412,7 @@ bool Client::OPCharCreate(char *name, CharCreate_Struct *cc)
Log.Out(Logs::Detail, Logs::World_Server, "Beard: %d Beardcolor: %d", cc->beard, cc->beardcolor); Log.Out(Logs::Detail, Logs::World_Server, "Beard: %d Beardcolor: %d", cc->beard, cc->beardcolor);
/* Validate the char creation struct */ /* Validate the char creation struct */
if (m_ClientVersionBit & BIT_SoFAndLater) { if (m_ClientVersionBit & EQEmu::versions::bit_SoFAndLater) {
if (!CheckCharCreateInfoSoF(cc)) { if (!CheckCharCreateInfoSoF(cc)) {
Log.Out(Logs::Detail, Logs::World_Server,"CheckCharCreateInfo did not validate the request (bad race/class/stats)"); Log.Out(Logs::Detail, Logs::World_Server,"CheckCharCreateInfo did not validate the request (bad race/class/stats)");
return false; return false;
@ -1483,7 +1483,7 @@ bool Client::OPCharCreate(char *name, CharCreate_Struct *cc)
pp.pvp = database.GetServerType() == 1 ? 1 : 0; pp.pvp = database.GetServerType() == 1 ? 1 : 0;
/* If it is an SoF Client and the SoF Start Zone rule is set, send new chars there */ /* If it is an SoF Client and the SoF Start Zone rule is set, send new chars there */
if (m_ClientVersionBit & BIT_SoFAndLater) { if (m_ClientVersionBit & EQEmu::versions::bit_SoFAndLater) {
Log.Out(Logs::Detail, Logs::World_Server,"Found 'SoFStartZoneID' rule setting: %i", RuleI(World, SoFStartZoneID)); Log.Out(Logs::Detail, Logs::World_Server,"Found 'SoFStartZoneID' rule setting: %i", RuleI(World, SoFStartZoneID));
if (RuleI(World, SoFStartZoneID) > 0) { if (RuleI(World, SoFStartZoneID) > 0) {
pp.zone_id = RuleI(World, SoFStartZoneID); pp.zone_id = RuleI(World, SoFStartZoneID);
@ -1499,7 +1499,7 @@ bool Client::OPCharCreate(char *name, CharCreate_Struct *cc)
} }
} }
/* use normal starting zone logic to either get defaults, or if startzone was set, load that from the db table.*/ /* use normal starting zone logic to either get defaults, or if startzone was set, load that from the db table.*/
bool ValidStartZone = database.GetStartZone(&pp, cc, m_ClientVersionBit & BIT_TitaniumAndEarlier); bool ValidStartZone = database.GetStartZone(&pp, cc, m_ClientVersionBit & EQEmu::versions::bit_TitaniumAndEarlier);
if (!ValidStartZone){ if (!ValidStartZone){
return false; return false;
@ -1833,7 +1833,7 @@ void Client::SetClassStartingSkills(PlayerProfile_Struct *pp)
} }
} }
if (cle->GetClientVersion() < static_cast<uint8>(ClientVersion::RoF2) && pp->class_ == BERSERKER) { if (cle->GetClientVersion() < static_cast<uint8>(EQEmu::versions::ClientVersion::RoF2) && pp->class_ == BERSERKER) {
pp->skills[Skill1HPiercing] = pp->skills[Skill2HPiercing]; pp->skills[Skill1HPiercing] = pp->skills[Skill2HPiercing];
pp->skills[Skill2HPiercing] = 0; pp->skills[Skill2HPiercing] = 0;
} }

2
world/client.h
View File

@ -84,7 +84,7 @@ private:
uint32 pwaitingforbootup; uint32 pwaitingforbootup;
bool StartInTutorial; bool StartInTutorial;
ClientVersion m_ClientVersion; EQEmu::versions::ClientVersion m_ClientVersion;
uint32 m_ClientVersionBit; uint32 m_ClientVersionBit;
bool OPCharCreate(char *name, CharCreate_Struct *cc); bool OPCharCreate(char *name, CharCreate_Struct *cc);

8
world/worlddb.cpp
View File

@ -36,15 +36,15 @@ extern std::vector<RaceClassCombos> character_create_race_class_combos;
void WorldDatabase::GetCharSelectInfo(uint32 accountID, EQApplicationPacket **outApp, uint32 clientVersionBit) void WorldDatabase::GetCharSelectInfo(uint32 accountID, EQApplicationPacket **outApp, uint32 clientVersionBit)
{ {
/* Set Character Creation Limit */ /* Set Character Creation Limit */
ClientVersion client_version = ClientVersionFromBit(clientVersionBit); EQEmu::versions::ClientVersion client_version = EQEmu::versions::ConvertClientVersionBitToClientVersion(clientVersionBit);
size_t character_limit = EQEmu::limits::CharacterCreationLimit(client_version); size_t character_limit = EQEmu::limits::CharacterCreationLimit(client_version);
// Validate against absolute server max // Validate against absolute server max
if (character_limit > EQEmu::constants::CHARACTER_CREATION_LIMIT) if (character_limit > EQEmu::constants::CharacterCreationLimit)
character_limit = EQEmu::constants::CHARACTER_CREATION_LIMIT; character_limit = EQEmu::constants::CharacterCreationLimit;
// Force Titanium clients to use '8' // Force Titanium clients to use '8'
if (client_version == ClientVersion::Titanium) if (client_version == EQEmu::versions::ClientVersion::Titanium)
character_limit = 8; character_limit = 8;
/* Get Character Info */ /* Get Character Info */

4
zone/aa.cpp
View File

@ -471,7 +471,7 @@ void Client::ResetAA() {
database.DeleteCharacterLeadershipAAs(CharacterID()); database.DeleteCharacterLeadershipAAs(CharacterID());
// undefined for these clients // undefined for these clients
if (GetClientVersionBit() & BIT_TitaniumAndEarlier) if (ClientVersionBit() & EQEmu::versions::bit_TitaniumAndEarlier)
Kick(); Kick();
} }
@ -1411,7 +1411,7 @@ bool Mob::CanUseAlternateAdvancementRank(AA::Rank *rank) {
//the one titanium hack i will allow //the one titanium hack i will allow
//just to make sure we dont crash the client with newer aas //just to make sure we dont crash the client with newer aas
//we'll exclude any expendable ones //we'll exclude any expendable ones
if(IsClient() && CastToClient()->GetClientVersionBit() & BIT_TitaniumAndEarlier) { if(IsClient() && CastToClient()->ClientVersionBit() & EQEmu::versions::bit_TitaniumAndEarlier) {
if(ability->charges > 0) { if(ability->charges > 0) {
return false; return false;
} }

12
zone/attack.cpp
View File

@ -93,7 +93,7 @@ bool Mob::AttackAnimation(SkillUseTypes &skillinuse, int Hand, const ItemInst* w
} }
case ItemType2HPiercing: // 2H Piercing case ItemType2HPiercing: // 2H Piercing
{ {
if (IsClient() && CastToClient()->GetClientVersion() < ClientVersion::RoF2) if (IsClient() && CastToClient()->ClientVersion() < EQEmu::versions::ClientVersion::RoF2)
skillinuse = Skill1HPiercing; skillinuse = Skill1HPiercing;
else else
skillinuse = Skill2HPiercing; skillinuse = Skill2HPiercing;
@ -1486,7 +1486,7 @@ bool Client::Death(Mob* killerMob, int32 damage, uint16 spell, SkillUseTypes att
//this generates a lot of 'updates' to the client that the client does not need //this generates a lot of 'updates' to the client that the client does not need
BuffFadeNonPersistDeath(); BuffFadeNonPersistDeath();
if (RuleB(Character, UnmemSpellsOnDeath)) { if (RuleB(Character, UnmemSpellsOnDeath)) {
if((GetClientVersionBit() & BIT_SoFAndLater) && RuleB(Character, RespawnFromHover)) if((ClientVersionBit() & EQEmu::versions::bit_SoFAndLater) && RuleB(Character, RespawnFromHover))
UnmemSpellAll(true); UnmemSpellAll(true);
else else
UnmemSpellAll(false); UnmemSpellAll(false);
@ -1549,7 +1549,7 @@ bool Client::Death(Mob* killerMob, int32 damage, uint16 spell, SkillUseTypes att
from these and overwrite what we set in pp anyway from these and overwrite what we set in pp anyway
*/ */
if(LeftCorpse && (GetClientVersionBit() & BIT_SoFAndLater) && RuleB(Character, RespawnFromHover)) if(LeftCorpse && (ClientVersionBit() & EQEmu::versions::bit_SoFAndLater) && RuleB(Character, RespawnFromHover))
{ {
ClearDraggedCorpses(); ClearDraggedCorpses();
RespawnFromHoverTimer.Start(RuleI(Character, RespawnFromHoverTimer) * 1000); RespawnFromHoverTimer.Start(RuleI(Character, RespawnFromHoverTimer) * 1000);
@ -3425,14 +3425,14 @@ void Mob::HealDamage(uint32 amount, Mob *caster, uint16 spell_id)
if (IsBuffSpell(spell_id)) { // hots if (IsBuffSpell(spell_id)) { // hots
// message to caster // message to caster
if (caster->IsClient() && caster == this) { if (caster->IsClient() && caster == this) {
if (caster->CastToClient()->GetClientVersionBit() & BIT_SoFAndLater) if (caster->CastToClient()->ClientVersionBit() & EQEmu::versions::bit_SoFAndLater)
FilteredMessage_StringID(caster, MT_NonMelee, FilterHealOverTime, FilteredMessage_StringID(caster, MT_NonMelee, FilterHealOverTime,
HOT_HEAL_SELF, itoa(acthealed), spells[spell_id].name); HOT_HEAL_SELF, itoa(acthealed), spells[spell_id].name);
else else
FilteredMessage_StringID(caster, MT_NonMelee, FilterHealOverTime, FilteredMessage_StringID(caster, MT_NonMelee, FilterHealOverTime,
YOU_HEALED, GetCleanName(), itoa(acthealed)); YOU_HEALED, GetCleanName(), itoa(acthealed));
} else if (caster->IsClient() && caster != this) { } else if (caster->IsClient() && caster != this) {
if (caster->CastToClient()->GetClientVersionBit() & BIT_SoFAndLater) if (caster->CastToClient()->ClientVersionBit() & EQEmu::versions::bit_SoFAndLater)
caster->FilteredMessage_StringID(caster, MT_NonMelee, FilterHealOverTime, caster->FilteredMessage_StringID(caster, MT_NonMelee, FilterHealOverTime,
HOT_HEAL_OTHER, GetCleanName(), itoa(acthealed), HOT_HEAL_OTHER, GetCleanName(), itoa(acthealed),
spells[spell_id].name); spells[spell_id].name);
@ -3442,7 +3442,7 @@ void Mob::HealDamage(uint32 amount, Mob *caster, uint16 spell_id)
} }
// message to target // message to target
if (IsClient() && caster != this) { if (IsClient() && caster != this) {
if (CastToClient()->GetClientVersionBit() & BIT_SoFAndLater) if (CastToClient()->ClientVersionBit() & EQEmu::versions::bit_SoFAndLater)
FilteredMessage_StringID(this, MT_NonMelee, FilterHealOverTime, FilteredMessage_StringID(this, MT_NonMelee, FilterHealOverTime,
HOT_HEALED_OTHER, caster->GetCleanName(), HOT_HEALED_OTHER, caster->GetCleanName(),
itoa(acthealed), spells[spell_id].name); itoa(acthealed), spells[spell_id].name);

6
zone/bonuses.cpp
View File

@ -163,7 +163,7 @@ void Client::CalcItemBonuses(StatBonuses* newbon) {
} }
//Power Source Slot //Power Source Slot
if (GetClientVersion() >= ClientVersion::SoF) if (ClientVersion() >= EQEmu::versions::ClientVersion::SoF)
{ {
const ItemInst* inst = m_inv[SlotPowerSource]; const ItemInst* inst = m_inv[SlotPowerSource];
if(inst) if(inst)
@ -3293,7 +3293,7 @@ void Client::CalcItemScale() {
changed = true; changed = true;
//Power Source Slot //Power Source Slot
if (GetClientVersion() >= ClientVersion::SoF) if (ClientVersion() >= EQEmu::versions::ClientVersion::SoF)
{ {
if(CalcItemScale(SlotPowerSource, SlotPowerSource)) if(CalcItemScale(SlotPowerSource, SlotPowerSource))
changed = true; changed = true;
@ -3387,7 +3387,7 @@ void Client::DoItemEnterZone() {
changed = true; changed = true;
//Power Source Slot //Power Source Slot
if (GetClientVersion() >= ClientVersion::SoF) if (ClientVersion() >= EQEmu::versions::ClientVersion::SoF)
{ {
if(DoItemEnterZone(SlotPowerSource, SlotPowerSource)) if(DoItemEnterZone(SlotPowerSource, SlotPowerSource))
changed = true; changed = true;

10
zone/bot.cpp
View File

@ -1255,7 +1255,7 @@ int32 Bot::GenerateBaseHitPoints() {
uint32 lm = GetClassLevelFactor(); uint32 lm = GetClassLevelFactor();
int32 Post255; int32 Post255;
int32 NormalSTA = GetSTA(); int32 NormalSTA = GetSTA();
if(GetOwner() && GetOwner()->CastToClient() && GetOwner()->CastToClient()->GetClientVersion() >= ClientVersion::SoD && RuleB(Character, SoDClientUseSoDHPManaEnd)) { if (GetOwner() && GetOwner()->CastToClient() && GetOwner()->CastToClient()->ClientVersion() >= EQEmu::versions::ClientVersion::SoD && RuleB(Character, SoDClientUseSoDHPManaEnd)) {
float SoDPost255; float SoDPost255;
if(((NormalSTA - 255) / 2) > 0) if(((NormalSTA - 255) / 2) > 0)
SoDPost255 = ((NormalSTA - 255) / 2); SoDPost255 = ((NormalSTA - 255) / 2);
@ -6127,7 +6127,7 @@ int32 Bot::GenerateBaseManaPoints() {
switch(GetCasterClass()) { switch(GetCasterClass()) {
case 'I': case 'I':
WisInt = INT; WisInt = INT;
if(GetOwner() && GetOwner()->CastToClient() && GetOwner()->CastToClient()->GetClientVersion() >= ClientVersion::SoD && RuleB(Character, SoDClientUseSoDHPManaEnd)) { if (GetOwner() && GetOwner()->CastToClient() && GetOwner()->CastToClient()->ClientVersion() >= EQEmu::versions::ClientVersion::SoD && RuleB(Character, SoDClientUseSoDHPManaEnd)) {
if(WisInt > 100) { if(WisInt > 100) {
ConvertedWisInt = (((WisInt - 100) * 5 / 2) + 100); ConvertedWisInt = (((WisInt - 100) * 5 / 2) + 100);
if(WisInt > 201) if(WisInt > 201)
@ -6162,7 +6162,7 @@ int32 Bot::GenerateBaseManaPoints() {
break; break;
case 'W': case 'W':
WisInt = WIS; WisInt = WIS;
if(GetOwner() && GetOwner()->CastToClient() && GetOwner()->CastToClient()->GetClientVersion() >= ClientVersion::SoD && RuleB(Character, SoDClientUseSoDHPManaEnd)) { if (GetOwner() && GetOwner()->CastToClient() && GetOwner()->CastToClient()->ClientVersion() >= EQEmu::versions::ClientVersion::SoD && RuleB(Character, SoDClientUseSoDHPManaEnd)) {
if(WisInt > 100) { if(WisInt > 100) {
ConvertedWisInt = (((WisInt - 100) * 5 / 2) + 100); ConvertedWisInt = (((WisInt - 100) * 5 / 2) + 100);
if(WisInt > 201) if(WisInt > 201)
@ -6346,7 +6346,7 @@ int32 Bot::GetMaxStat() {
int32 base = 0; int32 base = 0;
if (level < 61) if (level < 61)
base = 255; base = 255;
else if (GetOwner() && GetOwner()->CastToClient() && GetOwner()->CastToClient()->GetClientVersion() >= ClientVersion::SoF) else if (GetOwner() && GetOwner()->CastToClient() && GetOwner()->CastToClient()->ClientVersion() >= EQEmu::versions::ClientVersion::SoF)
base = (255 + 5 * (level - 60)); base = (255 + 5 * (level - 60));
else if (level < 71) else if (level < 71)
base = (255 + 5 * (level - 60)); base = (255 + 5 * (level - 60));
@ -6841,7 +6841,7 @@ int32 Bot::CalcBaseEndurance() {
int32 ConvertedStats = 0; int32 ConvertedStats = 0;
int32 sta_end = 0; int32 sta_end = 0;
int Stats = 0; int Stats = 0;
if(GetOwner() && GetOwner()->CastToClient() && GetOwner()->CastToClient()->GetClientVersion() >= ClientVersion::SoD && RuleB(Character, SoDClientUseSoDHPManaEnd)) { if (GetOwner() && GetOwner()->CastToClient() && GetOwner()->CastToClient()->ClientVersion() >= EQEmu::versions::ClientVersion::SoD && RuleB(Character, SoDClientUseSoDHPManaEnd)) {
int HeroicStats = 0; int HeroicStats = 0;
Stats = ((GetSTR() + GetSTA() + GetDEX() + GetAGI()) / 4); Stats = ((GetSTR() + GetSTA() + GetDEX() + GetAGI()) / 4);
HeroicStats = ((GetHeroicSTR() + GetHeroicSTA() + GetHeroicDEX() + GetHeroicAGI()) / 4); HeroicStats = ((GetHeroicSTR() + GetHeroicSTA() + GetHeroicDEX() + GetHeroicAGI()) / 4);

2
zone/bot_command.cpp
View File

@ -4709,7 +4709,7 @@ void bot_subcommand_bot_inspect_message(Client *c, const Seperator *sep)
if (helper_is_help_or_usage(sep->arg[1])) { if (helper_is_help_or_usage(sep->arg[1])) {
c->Message(m_usage, "usage: %s [set | clear] ([actionable: target | byname | ownergroup | botgroup | targetgroup | namesgroup | healrotation | spawned] ([actionable_name]))", sep->arg[0]); c->Message(m_usage, "usage: %s [set | clear] ([actionable: target | byname | ownergroup | botgroup | targetgroup | namesgroup | healrotation | spawned] ([actionable_name]))", sep->arg[0]);
c->Message(m_note, "Notes:"); c->Message(m_note, "Notes:");
if (c->GetClientVersion() >= ClientVersion::SoF) { if (c->ClientVersion() >= EQEmu::versions::ClientVersion::SoF) {
c->Message(m_message, "- Self-inspect and type your bot's inspect message"); c->Message(m_message, "- Self-inspect and type your bot's inspect message");
c->Message(m_message, "- Close the self-inspect window to update the server"); c->Message(m_message, "- Close the self-inspect window to update the server");
c->Message(m_message, "- Type '%s set' to set the bot's inspect message", sep->arg[0]); c->Message(m_message, "- Type '%s set' to set the bot's inspect message", sep->arg[0]);

48
zone/client.cpp
View File

@ -257,7 +257,7 @@ Client::Client(EQStreamInterface* ieqs)
GlobalChatLimiterTimer = new Timer(RuleI(Chat, IntervalDurationMS)); GlobalChatLimiterTimer = new Timer(RuleI(Chat, IntervalDurationMS));
AttemptedMessages = 0; AttemptedMessages = 0;
TotalKarma = 0; TotalKarma = 0;
m_ClientVersion = ClientVersion::Unknown; m_ClientVersion = EQEmu::versions::ClientVersion::Unknown;
m_ClientVersionBit = 0; m_ClientVersionBit = 0;
AggroCount = 0; AggroCount = 0;
RestRegenHP = 0; RestRegenHP = 0;
@ -1533,7 +1533,7 @@ void Client::UpdateWho(uint8 remove) {
else if (m_pp.anon >= 2) else if (m_pp.anon >= 2)
scl->anon = 2; scl->anon = 2;
scl->ClientVersion = static_cast<unsigned int>(GetClientVersion()); scl->ClientVersion = static_cast<unsigned int>(ClientVersion());
scl->tellsoff = tellsoff; scl->tellsoff = tellsoff;
scl->guild_id = guild_id; scl->guild_id = guild_id;
scl->LFG = LFG; scl->LFG = LFG;
@ -1789,7 +1789,7 @@ void Client::SendManaUpdatePacket() {
if (!Connected() || IsCasting()) if (!Connected() || IsCasting())
return; return;
if (GetClientVersion() >= ClientVersion::SoD) { if (ClientVersion() >= EQEmu::versions::ClientVersion::SoD) {
SendManaUpdate(); SendManaUpdate();
SendEnduranceUpdate(); SendEnduranceUpdate();
} }
@ -1824,7 +1824,7 @@ void Client::SendManaUpdatePacket() {
for(int i = 0; i < MAX_GROUP_MEMBERS; ++i) for(int i = 0; i < MAX_GROUP_MEMBERS; ++i)
if(g->members[i] && g->members[i]->IsClient() && (g->members[i] != this) && (g->members[i]->CastToClient()->GetClientVersion() >= ClientVersion::SoD)) if (g->members[i] && g->members[i]->IsClient() && (g->members[i] != this) && (g->members[i]->CastToClient()->ClientVersion() >= EQEmu::versions::ClientVersion::SoD))
{ {
g->members[i]->CastToClient()->QueuePacket(outapp); g->members[i]->CastToClient()->QueuePacket(outapp);
g->members[i]->CastToClient()->QueuePacket(outapp2); g->members[i]->CastToClient()->QueuePacket(outapp2);
@ -2007,7 +2007,7 @@ void Client::ReadBook(BookRequest_Struct *book) {
BookText_Struct *out = (BookText_Struct *) outapp->pBuffer; BookText_Struct *out = (BookText_Struct *) outapp->pBuffer;
out->window = book->window; out->window = book->window;
if(GetClientVersion() >= ClientVersion::SoF) if (ClientVersion() >= EQEmu::versions::ClientVersion::SoF)
{ {
const ItemInst *inst = m_inv[book->invslot]; const ItemInst *inst = m_inv[book->invslot];
if(inst) if(inst)
@ -2364,7 +2364,7 @@ bool Client::HasSkill(SkillUseTypes skill_id) const {
} }
bool Client::CanHaveSkill(SkillUseTypes skill_id) const { bool Client::CanHaveSkill(SkillUseTypes skill_id) const {
if (GetClientVersion() < ClientVersion::RoF2 && class_ == BERSERKER && skill_id == Skill1HPiercing) if (ClientVersion() < EQEmu::versions::ClientVersion::RoF2 && class_ == BERSERKER && skill_id == Skill1HPiercing)
skill_id = Skill2HPiercing; skill_id = Skill2HPiercing;
return(database.GetSkillCap(GetClass(), skill_id, RuleI(Character, MaxLevel)) > 0); return(database.GetSkillCap(GetClass(), skill_id, RuleI(Character, MaxLevel)) > 0);
@ -2372,7 +2372,7 @@ bool Client::CanHaveSkill(SkillUseTypes skill_id) const {
} }
uint16 Client::MaxSkill(SkillUseTypes skillid, uint16 class_, uint16 level) const { uint16 Client::MaxSkill(SkillUseTypes skillid, uint16 class_, uint16 level) const {
if (GetClientVersion() < ClientVersion::RoF2 && class_ == BERSERKER && skillid == Skill1HPiercing) if (ClientVersion() < EQEmu::versions::ClientVersion::RoF2 && class_ == BERSERKER && skillid == Skill1HPiercing)
skillid = Skill2HPiercing; skillid = Skill2HPiercing;
return(database.GetSkillCap(class_, skillid, level)); return(database.GetSkillCap(class_, skillid, level));
@ -2380,7 +2380,7 @@ uint16 Client::MaxSkill(SkillUseTypes skillid, uint16 class_, uint16 level) cons
uint8 Client::SkillTrainLevel(SkillUseTypes skillid, uint16 class_) uint8 Client::SkillTrainLevel(SkillUseTypes skillid, uint16 class_)
{ {
if (GetClientVersion() < ClientVersion::RoF2 && class_ == BERSERKER && skillid == Skill1HPiercing) if (ClientVersion() < EQEmu::versions::ClientVersion::RoF2 && class_ == BERSERKER && skillid == Skill1HPiercing)
skillid = Skill2HPiercing; skillid = Skill2HPiercing;
return(database.GetTrainLevel(class_, skillid, RuleI(Character, MaxLevel))); return(database.GetTrainLevel(class_, skillid, RuleI(Character, MaxLevel)));
@ -2817,7 +2817,7 @@ void Client::ServerFilter(SetServerFilter_Struct* filter){
Filter0(FilterMissedMe); Filter0(FilterMissedMe);
Filter1(FilterDamageShields); Filter1(FilterDamageShields);
if (GetClientVersionBit() & BIT_SoDAndLater) { if (ClientVersionBit() & EQEmu::versions::bit_SoDAndLater) {
if (filter->filters[FilterDOT] == 0) if (filter->filters[FilterDOT] == 0)
ClientFilters[FilterDOT] = FilterShow; ClientFilters[FilterDOT] = FilterShow;
else if (filter->filters[FilterDOT] == 1) else if (filter->filters[FilterDOT] == 1)
@ -2838,7 +2838,7 @@ void Client::ServerFilter(SetServerFilter_Struct* filter){
Filter1(FilterFocusEffects); Filter1(FilterFocusEffects);
Filter1(FilterPetSpells); Filter1(FilterPetSpells);
if (GetClientVersionBit() & BIT_SoDAndLater) { if (ClientVersionBit() & EQEmu::versions::bit_SoDAndLater) {
if (filter->filters[FilterHealOverTime] == 0) if (filter->filters[FilterHealOverTime] == 0)
ClientFilters[FilterHealOverTime] = FilterShow; ClientFilters[FilterHealOverTime] = FilterShow;
// This is called 'Show Mine Only' in the clients, but functions the same as show // This is called 'Show Mine Only' in the clients, but functions the same as show
@ -4123,7 +4123,7 @@ bool Client::GroupFollow(Client* inviter) {
group->UpdateGroupAAs(); group->UpdateGroupAAs();
//Invite the inviter into the group first.....dont ask //Invite the inviter into the group first.....dont ask
if (inviter->GetClientVersion() < ClientVersion::SoD) if (inviter->ClientVersion() < EQEmu::versions::ClientVersion::SoD)
{ {
EQApplicationPacket* outapp = new EQApplicationPacket(OP_GroupUpdate, sizeof(GroupJoin_Struct)); EQApplicationPacket* outapp = new EQApplicationPacket(OP_GroupUpdate, sizeof(GroupJoin_Struct));
GroupJoin_Struct* outgj = (GroupJoin_Struct*)outapp->pBuffer; GroupJoin_Struct* outgj = (GroupJoin_Struct*)outapp->pBuffer;
@ -4169,13 +4169,13 @@ bool Client::GroupFollow(Client* inviter) {
return false; return false;
} }
if (GetClientVersion() >= ClientVersion::SoD) if (ClientVersion() >= EQEmu::versions::ClientVersion::SoD)
{ {
SendGroupJoinAcknowledge(); SendGroupJoinAcknowledge();
} }
// Temporary hack for SoD, as things seem to work quite differently // Temporary hack for SoD, as things seem to work quite differently
if (inviter->IsClient() && inviter->GetClientVersion() >= ClientVersion::SoD) if (inviter->IsClient() && inviter->ClientVersion() >= EQEmu::versions::ClientVersion::SoD)
{ {
database.RefreshGroupFromDB(inviter); database.RefreshGroupFromDB(inviter);
} }
@ -4242,7 +4242,7 @@ uint16 Client::GetPrimarySkillValue()
} }
case ItemType2HPiercing: // 2H Piercing case ItemType2HPiercing: // 2H Piercing
{ {
if (IsClient() && CastToClient()->GetClientVersion() < ClientVersion::RoF2) if (IsClient() && CastToClient()->ClientVersion() < EQEmu::versions::ClientVersion::RoF2)
skill = Skill1HPiercing; skill = Skill1HPiercing;
else else
skill = Skill2HPiercing; skill = Skill2HPiercing;
@ -4412,7 +4412,7 @@ void Client::IncrementAggroCount() {
if (AggroCount == 1) if (AggroCount == 1)
SavedRaidRestTimer = rest_timer.GetRemainingTime(); SavedRaidRestTimer = rest_timer.GetRemainingTime();
if(GetClientVersion() >= ClientVersion::SoF) { if (ClientVersion() >= EQEmu::versions::ClientVersion::SoF) {
EQApplicationPacket *outapp = new EQApplicationPacket(OP_RestState, 1); EQApplicationPacket *outapp = new EQApplicationPacket(OP_RestState, 1);
char *Buffer = (char *)outapp->pBuffer; char *Buffer = (char *)outapp->pBuffer;
@ -4457,7 +4457,7 @@ void Client::DecrementAggroCount() {
rest_timer.Start(time_until_rest); rest_timer.Start(time_until_rest);
if(GetClientVersion() >= ClientVersion::SoF) { if (ClientVersion() >= EQEmu::versions::ClientVersion::SoF) {
EQApplicationPacket *outapp = new EQApplicationPacket(OP_RestState, 5); EQApplicationPacket *outapp = new EQApplicationPacket(OP_RestState, 5);
char *Buffer = (char *)outapp->pBuffer; char *Buffer = (char *)outapp->pBuffer;
@ -4978,12 +4978,12 @@ void Client::ShowSkillsWindow()
std::string WindowText; std::string WindowText;
std::map<SkillUseTypes, std::string> Skills = EQEmu::GetSkillUseTypesMap(); std::map<SkillUseTypes, std::string> Skills = EQEmu::GetSkillUseTypesMap();
if (GetClientVersion() < ClientVersion::RoF2) if (ClientVersion() < EQEmu::versions::ClientVersion::RoF2)
Skills[Skill1HPiercing] = "Piercing"; Skills[Skill1HPiercing] = "Piercing";
// print out all available skills // print out all available skills
for (auto skills_iter : Skills) { for (auto skills_iter : Skills) {
if (skills_iter.first == Skill2HPiercing && GetClientVersion() < ClientVersion::RoF2) if (skills_iter.first == Skill2HPiercing && ClientVersion() < EQEmu::versions::ClientVersion::RoF2)
continue; continue;
if (!GetSkill(skills_iter.first) && !MaxSkill(skills_iter.first)) if (!GetSkill(skills_iter.first) && !MaxSkill(skills_iter.first))
continue; continue;
@ -6115,7 +6115,7 @@ void Client::SendZonePoints()
while(iterator.MoreElements()) while(iterator.MoreElements())
{ {
ZonePoint* data = iterator.GetData(); ZonePoint* data = iterator.GetData();
if(GetClientVersionBit() & data->client_version_mask) if(ClientVersionBit() & data->client_version_mask)
{ {
count++; count++;
} }
@ -6132,7 +6132,7 @@ void Client::SendZonePoints()
while(iterator.MoreElements()) while(iterator.MoreElements())
{ {
ZonePoint* data = iterator.GetData(); ZonePoint* data = iterator.GetData();
if(GetClientVersionBit() & data->client_version_mask) if(ClientVersionBit() & data->client_version_mask)
{ {
zp->zpe[i].iterator = data->number; zp->zpe[i].iterator = data->number;
zp->zpe[i].x = data->target_x; zp->zpe[i].x = data->target_x;
@ -6852,7 +6852,7 @@ void Client::SendStatsWindow(Client* client, bool use_window)
if(use_window) { if(use_window) {
if(final_stats.size() < 4096) if(final_stats.size() < 4096)
{ {
uint32 Buttons = (client->GetClientVersion() < ClientVersion::SoD) ? 0 : 1; uint32 Buttons = (client->ClientVersion() < EQEmu::versions::ClientVersion::SoD) ? 0 : 1;
client->SendWindow(0, POPUPID_UPDATE_SHOWSTATSWINDOW, Buttons, "Cancel", "Update", 0, 1, this, "", "%s", final_stats.c_str()); client->SendWindow(0, POPUPID_UPDATE_SHOWSTATSWINDOW, Buttons, "Cancel", "Update", 0, 1, this, "", "%s", final_stats.c_str());
goto Extra_Info; goto Extra_Info;
} }
@ -6888,7 +6888,7 @@ void Client::SendStatsWindow(Client* client, bool use_window)
} }
void Client::SendAltCurrencies() { void Client::SendAltCurrencies() {
if(GetClientVersion() >= ClientVersion::SoF) { if (ClientVersion() >= EQEmu::versions::ClientVersion::SoF) {
uint32 count = zone->AlternateCurrencies.size(); uint32 count = zone->AlternateCurrencies.size();
if(count == 0) { if(count == 0) {
return; return;
@ -7439,7 +7439,7 @@ void Client::SendMercPersonalInfo()
if(mercData) if(mercData)
{ {
if (GetClientVersion() >= ClientVersion::RoF) if (ClientVersion() >= EQEmu::versions::ClientVersion::RoF)
{ {
if (mercCount > 0) if (mercCount > 0)
{ {
@ -7550,7 +7550,7 @@ void Client::SendClearMercInfo()
void Client::DuplicateLoreMessage(uint32 ItemID) void Client::DuplicateLoreMessage(uint32 ItemID)
{ {
if (!(m_ClientVersionBit & BIT_RoFAndLater)) if (!(m_ClientVersionBit & EQEmu::versions::bit_RoFAndLater))
{ {
Message_StringID(0, PICK_LORE); Message_StringID(0, PICK_LORE);
return; return;

15
zone/client.h
View File

@ -33,7 +33,8 @@ struct Item_Struct;
#include "../common/ptimer.h" #include "../common/ptimer.h"
#include "../common/emu_opcodes.h" #include "../common/emu_opcodes.h"
#include "../common/eq_packet_structs.h" #include "../common/eq_packet_structs.h"
#include "../common/eq_constants.h" //#include "../common/eq_constants.h"
#include "../common/emu_constants.h" // inv2 watch
#include "../common/eq_stream_intf.h" #include "../common/eq_stream_intf.h"
#include "../common/eq_packet.h" #include "../common/eq_packet.h"
#include "../common/linked_list.h" #include "../common/linked_list.h"
@ -43,7 +44,7 @@ struct Item_Struct;
#include "../common/item.h" #include "../common/item.h"
#include "../common/guilds.h" #include "../common/guilds.h"
#include "../common/item_struct.h" #include "../common/item_struct.h"
#include "../common/clientversions.h" //#include "../common/clientversions.h"
#include "common.h" #include "common.h"
#include "merc.h" #include "merc.h"
@ -976,9 +977,9 @@ public:
inline int ActiveTasksInSet(int TaskSet) { return (taskstate ? taskstate->ActiveTasksInSet(TaskSet) :0); } inline int ActiveTasksInSet(int TaskSet) { return (taskstate ? taskstate->ActiveTasksInSet(TaskSet) :0); }
inline int CompletedTasksInSet(int TaskSet) { return (taskstate ? taskstate->CompletedTasksInSet(TaskSet) :0); } inline int CompletedTasksInSet(int TaskSet) { return (taskstate ? taskstate->CompletedTasksInSet(TaskSet) :0); }
inline const ClientVersion GetClientVersion() const { return m_ClientVersion; } inline const EQEmu::versions::ClientVersion ClientVersion() const { return m_ClientVersion; }
inline const uint32 GetClientVersionBit() const { return m_ClientVersionBit; } inline const uint32 ClientVersionBit() const { return m_ClientVersionBit; }
inline void SetClientVersion(ClientVersion in) { m_ClientVersion = in; } inline void SetClientVersion(EQEmu::versions::ClientVersion client_version) { m_ClientVersion = client_version; }
/** Adventure Stuff **/ /** Adventure Stuff **/
void SendAdventureError(const char *error); void SendAdventureError(const char *error);
@ -1096,7 +1097,7 @@ public:
void HandleLFGuildResponse(ServerPacket *pack); void HandleLFGuildResponse(ServerPacket *pack);
void SendLFGuildStatus(); void SendLFGuildStatus();
void SendGuildLFGuildStatus(); void SendGuildLFGuildStatus();
inline bool XTargettingAvailable() const { return ((m_ClientVersionBit & BIT_UFAndLater) && RuleB(Character, EnableXTargetting)); } inline bool XTargettingAvailable() const { return ((m_ClientVersionBit & EQEmu::versions::bit_UFAndLater) && RuleB(Character, EnableXTargetting)); }
inline uint8 GetMaxXTargets() const { return MaxXTargets; } inline uint8 GetMaxXTargets() const { return MaxXTargets; }
void SetMaxXTargets(uint8 NewMax); void SetMaxXTargets(uint8 NewMax);
bool IsXTarget(const Mob *m) const; bool IsXTarget(const Mob *m) const;
@ -1489,7 +1490,7 @@ private:
Timer *GlobalChatLimiterTimer; //60 seconds Timer *GlobalChatLimiterTimer; //60 seconds
uint32 AttemptedMessages; uint32 AttemptedMessages;
ClientVersion m_ClientVersion; EQEmu::versions::ClientVersion m_ClientVersion;
uint32 m_ClientVersionBit; uint32 m_ClientVersionBit;
int XPRate; int XPRate;

12
zone/client_mods.cpp
View File

@ -42,7 +42,7 @@ int32 Client::GetMaxStat() const
if (level < 61) { if (level < 61) {
base = 255; base = 255;
} }
else if (GetClientVersion() >= ClientVersion::SoF) { else if (ClientVersion() >= EQEmu::versions::ClientVersion::SoF) {
base = 255 + 5 * (level - 60); base = 255 + 5 * (level - 60);
} }
else if (level < 71) { else if (level < 71) {
@ -409,7 +409,7 @@ uint32 Mob::GetClassLevelFactor()
int32 Client::CalcBaseHP() int32 Client::CalcBaseHP()
{ {
if (GetClientVersion() >= ClientVersion::SoF && RuleB(Character, SoDClientUseSoDHPManaEnd)) { if (ClientVersion() >= EQEmu::versions::ClientVersion::SoF && RuleB(Character, SoDClientUseSoDHPManaEnd)) {
int stats = GetSTA(); int stats = GetSTA();
if (stats > 255) { if (stats > 255) {
stats = (stats - 255) / 2; stats = (stats - 255) / 2;
@ -1162,7 +1162,7 @@ int32 Client::CalcBaseMana()
switch (GetCasterClass()) { switch (GetCasterClass()) {
case 'I': case 'I':
WisInt = GetINT(); WisInt = GetINT();
if (GetClientVersion() >= ClientVersion::SoF && RuleB(Character, SoDClientUseSoDHPManaEnd)) { if (ClientVersion() >= EQEmu::versions::ClientVersion::SoF && RuleB(Character, SoDClientUseSoDHPManaEnd)) {
if (WisInt > 100) { if (WisInt > 100) {
ConvertedWisInt = (((WisInt - 100) * 5 / 2) + 100); ConvertedWisInt = (((WisInt - 100) * 5 / 2) + 100);
if (WisInt > 201) { if (WisInt > 201) {
@ -1195,7 +1195,7 @@ int32 Client::CalcBaseMana()
break; break;
case 'W': case 'W':
WisInt = GetWIS(); WisInt = GetWIS();
if (GetClientVersion() >= ClientVersion::SoF && RuleB(Character, SoDClientUseSoDHPManaEnd)) { if (ClientVersion() >= EQEmu::versions::ClientVersion::SoF && RuleB(Character, SoDClientUseSoDHPManaEnd)) {
if (WisInt > 100) { if (WisInt > 100) {
ConvertedWisInt = (((WisInt - 100) * 5 / 2) + 100); ConvertedWisInt = (((WisInt - 100) * 5 / 2) + 100);
if (WisInt > 201) { if (WisInt > 201) {
@ -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::limits::CoinHasWeight(GetClientVersion())) { if (EQEmu::limits::CoinHasWeight(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;
@ -2140,7 +2140,7 @@ void Client::CalcMaxEndurance()
int32 Client::CalcBaseEndurance() int32 Client::CalcBaseEndurance()
{ {
int32 base_end = 0; int32 base_end = 0;
if (GetClientVersion() >= ClientVersion::SoF && RuleB(Character, SoDClientUseSoDHPManaEnd)) { if (ClientVersion() >= EQEmu::versions::ClientVersion::SoF && RuleB(Character, SoDClientUseSoDHPManaEnd)) {
double heroic_stats = (GetHeroicSTR() + GetHeroicSTA() + GetHeroicDEX() + GetHeroicAGI()) / 4.0f; double heroic_stats = (GetHeroicSTR() + GetHeroicSTA() + GetHeroicDEX() + GetHeroicAGI()) / 4.0f;
double stats = (GetSTR() + GetSTA() + GetDEX() + GetAGI()) / 4.0f; double stats = (GetSTR() + GetSTA() + GetDEX() + GetAGI()) / 4.0f;
if (stats > 201.0f) { if (stats > 201.0f) {

60
zone/client_packet.cpp
View File

@ -510,7 +510,7 @@ void Client::CompleteConnect()
if (IsInAGuild()){ if (IsInAGuild()){
uint8 rank = GuildRank(); uint8 rank = GuildRank();
if (GetClientVersion() >= ClientVersion::RoF) if (ClientVersion() >= EQEmu::versions::ClientVersion::RoF)
{ {
switch (rank) { switch (rank) {
case 0: { rank = 5; break; } // GUILD_MEMBER 0 case 0: { rank = 5; break; } // GUILD_MEMBER 0
@ -831,7 +831,7 @@ void Client::CompleteConnect()
if (zone->GetZoneID() == RuleI(World, GuildBankZoneID) && GuildBanks) if (zone->GetZoneID() == RuleI(World, GuildBankZoneID) && GuildBanks)
GuildBanks->SendGuildBank(this); GuildBanks->SendGuildBank(this);
if (GetClientVersion() >= ClientVersion::SoD) if (ClientVersion() >= EQEmu::versions::ClientVersion::SoD)
entity_list.SendFindableNPCList(this); entity_list.SendFindableNPCList(this);
if (IsInAGuild()) { if (IsInAGuild()) {
@ -846,7 +846,7 @@ void Client::CompleteConnect()
worldserver.SendPacket(pack); worldserver.SendPacket(pack);
delete pack; delete pack;
if (IsClient() && CastToClient()->GetClientVersionBit() & BIT_UFAndLater) { if (IsClient() && CastToClient()->ClientVersionBit() & EQEmu::versions::bit_UFAndLater) {
EQApplicationPacket *outapp = MakeBuffsPacket(false); EQApplicationPacket *outapp = MakeBuffsPacket(false);
CastToClient()->FastQueuePacket(&outapp); CastToClient()->FastQueuePacket(&outapp);
} }
@ -1044,7 +1044,7 @@ void Client::Handle_Connect_OP_ReqClientSpawn(const EQApplicationPacket *app)
outapp = new EQApplicationPacket(OP_SendExpZonein, 0); outapp = new EQApplicationPacket(OP_SendExpZonein, 0);
FastQueuePacket(&outapp); FastQueuePacket(&outapp);
if (GetClientVersion() >= ClientVersion::RoF) if (ClientVersion() >= EQEmu::versions::ClientVersion::RoF)
{ {
outapp = new EQApplicationPacket(OP_ClientReady, 0); outapp = new EQApplicationPacket(OP_ClientReady, 0);
FastQueuePacket(&outapp); FastQueuePacket(&outapp);
@ -1103,7 +1103,7 @@ void Client::Handle_Connect_OP_SendExpZonein(const EQApplicationPacket *app)
safe_delete(outapp); safe_delete(outapp);
// SoF+ Gets Zone-In packets after sending OP_WorldObjectsSent // SoF+ Gets Zone-In packets after sending OP_WorldObjectsSent
if (GetClientVersion() < ClientVersion::SoF) if (ClientVersion() < EQEmu::versions::ClientVersion::SoF)
{ {
SendZoneInPackets(); SendZoneInPackets();
} }
@ -1199,8 +1199,8 @@ void Client::Handle_Connect_OP_ZoneEntry(const EQApplicationPacket *app)
conn_state = ReceivedZoneEntry; conn_state = ReceivedZoneEntry;
SetClientVersion(Connection()->GetClientVersion()); SetClientVersion(Connection()->ClientVersion());
m_ClientVersionBit = ClientBitFromVersion(Connection()->GetClientVersion()); m_ClientVersionBit = EQEmu::versions::ConvertClientVersionToClientVersionBit(Connection()->ClientVersion());
bool siv = m_inv.SetInventoryVersion(m_ClientVersion); bool siv = m_inv.SetInventoryVersion(m_ClientVersion);
Log.Out(Logs::General, Logs::None, "%s inventory version to %s(%i)", (siv ? "Succeeded in setting" : "Failed to set"), ClientVersionName(m_ClientVersion), m_ClientVersion); Log.Out(Logs::General, Logs::None, "%s inventory version to %s(%i)", (siv ? "Succeeded in setting" : "Failed to set"), ClientVersionName(m_ClientVersion), m_ClientVersion);
@ -1387,7 +1387,7 @@ void Client::Handle_Connect_OP_ZoneEntry(const EQApplicationPacket *app)
m_pp.guild_id = GuildID(); m_pp.guild_id = GuildID();
uint8 rank = guild_mgr.GetDisplayedRank(GuildID(), GuildRank(), CharacterID()); uint8 rank = guild_mgr.GetDisplayedRank(GuildID(), GuildRank(), CharacterID());
// FIXME: RoF guild rank // FIXME: RoF guild rank
if (GetClientVersion() >= ClientVersion::RoF) { if (ClientVersion() >= EQEmu::versions::ClientVersion::RoF) {
switch (rank) { switch (rank) {
case 0: case 0:
rank = 5; rank = 5;
@ -1441,7 +1441,7 @@ void Client::Handle_Connect_OP_ZoneEntry(const EQApplicationPacket *app)
if (m_pp.ldon_points_available < 0 || m_pp.ldon_points_available > 2000000000){ m_pp.ldon_points_available = 0; } if (m_pp.ldon_points_available < 0 || m_pp.ldon_points_available > 2000000000){ m_pp.ldon_points_available = 0; }
if(RuleB(World, UseClientBasedExpansionSettings)) { if(RuleB(World, UseClientBasedExpansionSettings)) {
m_pp.expansions = ExpansionFromClientVersion(GetClientVersion()); m_pp.expansions = EQEmu::versions::ConvertClientVersionToExpansion(ClientVersion());
} }
else { else {
m_pp.expansions = RuleI(World, ExpansionSettings); m_pp.expansions = RuleI(World, ExpansionSettings);
@ -1696,13 +1696,13 @@ void Client::Handle_Connect_OP_ZoneEntry(const EQApplicationPacket *app)
/* Task Packets */ /* Task Packets */
LoadClientTaskState(); LoadClientTaskState();
if (GetClientVersion() >= ClientVersion::RoF) { if (ClientVersion() >= EQEmu::versions::ClientVersion::RoF) {
outapp = new EQApplicationPacket(OP_ReqNewZone, 0); outapp = new EQApplicationPacket(OP_ReqNewZone, 0);
Handle_Connect_OP_ReqNewZone(outapp); Handle_Connect_OP_ReqNewZone(outapp);
safe_delete(outapp); safe_delete(outapp);
} }
if (m_ClientVersionBit & BIT_UFAndLater) { if (m_ClientVersionBit & EQEmu::versions::bit_UFAndLater) {
outapp = new EQApplicationPacket(OP_XTargetResponse, 8); outapp = new EQApplicationPacket(OP_XTargetResponse, 8);
outapp->WriteUInt32(GetMaxXTargets()); outapp->WriteUInt32(GetMaxXTargets());
outapp->WriteUInt32(0); outapp->WriteUInt32(0);
@ -2926,7 +2926,7 @@ void Client::Handle_OP_AugmentItem(const EQApplicationPacket *app)
AugmentItem_Struct* in_augment = (AugmentItem_Struct*)app->pBuffer; AugmentItem_Struct* in_augment = (AugmentItem_Struct*)app->pBuffer;
bool deleteItems = false; bool deleteItems = false;
if (GetClientVersion() >= ClientVersion::RoF) if (ClientVersion() >= EQEmu::versions::ClientVersion::RoF)
{ {
ItemInst *itemOneToPush = nullptr, *itemTwoToPush = nullptr; ItemInst *itemOneToPush = nullptr, *itemTwoToPush = nullptr;
@ -4252,7 +4252,7 @@ void Client::Handle_OP_ClickObjectAction(const EQApplicationPacket *app)
QueuePacket(&end_trade2); QueuePacket(&end_trade2);
// RoF sends a 0 sized packet for closing objects // RoF sends a 0 sized packet for closing objects
if (GetTradeskillObject() && GetClientVersion() >= ClientVersion::RoF) if (GetTradeskillObject() && ClientVersion() >= EQEmu::versions::ClientVersion::RoF)
GetTradeskillObject()->CastToObject()->Close(); GetTradeskillObject()->CastToObject()->Close();
return; return;
@ -5141,7 +5141,7 @@ void Client::Handle_OP_DeleteItem(const EQApplicationPacket *app)
int16 AlcoholTolerance = GetSkill(SkillAlcoholTolerance); int16 AlcoholTolerance = GetSkill(SkillAlcoholTolerance);
int16 IntoxicationIncrease; int16 IntoxicationIncrease;
if (GetClientVersion() < ClientVersion::SoD) if (ClientVersion() < EQEmu::versions::ClientVersion::SoD)
IntoxicationIncrease = (200 - AlcoholTolerance) * 30 / 200 + 10; IntoxicationIncrease = (200 - AlcoholTolerance) * 30 / 200 + 10;
else else
IntoxicationIncrease = (270 - AlcoholTolerance) * 0.111111108 + 10; IntoxicationIncrease = (270 - AlcoholTolerance) * 0.111111108 + 10;
@ -5453,7 +5453,7 @@ void Client::Handle_OP_EndLootRequest(const EQApplicationPacket *app)
Entity* entity = entity_list.GetID(*((uint16*)app->pBuffer)); Entity* entity = entity_list.GetID(*((uint16*)app->pBuffer));
if (entity == 0) { if (entity == 0) {
Message(13, "Error: OP_EndLootRequest: Corpse not found (ent = 0)"); Message(13, "Error: OP_EndLootRequest: Corpse not found (ent = 0)");
if (GetClientVersion() >= ClientVersion::SoD) if (ClientVersion() >= EQEmu::versions::ClientVersion::SoD)
Corpse::SendEndLootErrorPacket(this); Corpse::SendEndLootErrorPacket(this);
else else
Corpse::SendLootReqErrorPacket(this); Corpse::SendLootReqErrorPacket(this);
@ -7333,11 +7333,11 @@ void Client::Handle_OP_GuildInvite(const EQApplicationPacket *app)
gc->guildeqid = GuildID(); gc->guildeqid = GuildID();
// Convert Membership Level between RoF and previous clients. // Convert Membership Level between RoF and previous clients.
if (client->GetClientVersion() < ClientVersion::RoF && GetClientVersion() >= ClientVersion::RoF) if (client->ClientVersion() < EQEmu::versions::ClientVersion::RoF && ClientVersion() >= EQEmu::versions::ClientVersion::RoF)
{ {
gc->officer = 0; gc->officer = 0;
} }
if (client->GetClientVersion() >= ClientVersion::RoF && GetClientVersion() < ClientVersion::RoF) if (client->ClientVersion() >= EQEmu::versions::ClientVersion::RoF && ClientVersion() < EQEmu::versions::ClientVersion::RoF)
{ {
gc->officer = 8; gc->officer = 8;
} }
@ -7378,7 +7378,7 @@ void Client::Handle_OP_GuildInviteAccept(const EQApplicationPacket *app)
uint32 guildrank = gj->response; uint32 guildrank = gj->response;
if (GetClientVersion() >= ClientVersion::RoF) if (ClientVersion() >= EQEmu::versions::ClientVersion::RoF)
{ {
if (gj->response > 9) if (gj->response > 9)
{ {
@ -7413,11 +7413,11 @@ void Client::Handle_OP_GuildInviteAccept(const EQApplicationPacket *app)
{ {
Client* client = inviter->CastToClient(); Client* client = inviter->CastToClient();
// Convert Membership Level between RoF and previous clients. // Convert Membership Level between RoF and previous clients.
if (client->GetClientVersion() < ClientVersion::RoF && GetClientVersion() >= ClientVersion::RoF) if (client->ClientVersion() < EQEmu::versions::ClientVersion::RoF && ClientVersion() >= EQEmu::versions::ClientVersion::RoF)
{ {
guildrank = 0; guildrank = 0;
} }
if (client->GetClientVersion() >= ClientVersion::RoF && GetClientVersion() < ClientVersion::RoF) if (client->ClientVersion() >= EQEmu::versions::ClientVersion::RoF && ClientVersion() < EQEmu::versions::ClientVersion::RoF)
{ {
guildrank = 8; guildrank = 8;
} }
@ -7454,7 +7454,7 @@ void Client::Handle_OP_GuildInviteAccept(const EQApplicationPacket *app)
guildrank = gj->response; guildrank = gj->response;
if (GetClientVersion() >= ClientVersion::RoF) if (ClientVersion() >= EQEmu::versions::ClientVersion::RoF)
{ {
if (gj->response == 8) if (gj->response == 8)
{ {
@ -8060,7 +8060,7 @@ void Client::Handle_OP_InspectRequest(const EQApplicationPacket *app)
Mob* tmp = entity_list.GetMob(ins->TargetID); Mob* tmp = entity_list.GetMob(ins->TargetID);
if (tmp != 0 && tmp->IsClient()) { if (tmp != 0 && tmp->IsClient()) {
if (tmp->CastToClient()->GetClientVersion() < ClientVersion::SoF) { tmp->CastToClient()->QueuePacket(app); } // Send request to target if (tmp->CastToClient()->ClientVersion() < EQEmu::versions::ClientVersion::SoF) { tmp->CastToClient()->QueuePacket(app); } // Send request to target
// Inspecting an SoF or later client will make the server handle the request // Inspecting an SoF or later client will make the server handle the request
else { ProcessInspectRequest(tmp->CastToClient(), this); } else { ProcessInspectRequest(tmp->CastToClient(), this); }
} }
@ -8563,7 +8563,7 @@ void Client::Handle_OP_ItemVerifyRequest(const EQApplicationPacket *app)
} }
else else
{ {
if (GetClientVersion() >= ClientVersion::SoD && !inst->IsEquipable(GetBaseRace(), GetClass())) if (ClientVersion() >= EQEmu::versions::ClientVersion::SoD && !inst->IsEquipable(GetBaseRace(), GetClass()))
{ {
if (item->ItemType != ItemTypeFood && item->ItemType != ItemTypeDrink && item->ItemType != ItemTypeAlcohol) if (item->ItemType != ItemTypeFood && item->ItemType != ItemTypeDrink && item->ItemType != ItemTypeAlcohol)
{ {
@ -9391,14 +9391,14 @@ void Client::Handle_OP_MercenaryDataRequest(const EQApplicationPacket *app)
return; return;
} }
mercTypeCount = tar->GetNumMercTypes(static_cast<unsigned int>(GetClientVersion())); mercTypeCount = tar->GetNumMercTypes(static_cast<unsigned int>(ClientVersion()));
mercCount = tar->GetNumMercs(static_cast<unsigned int>(GetClientVersion())); mercCount = tar->GetNumMercs(static_cast<unsigned int>(ClientVersion()));
if (mercCount > MAX_MERC) if (mercCount > MAX_MERC)
return; return;
std::list<MercType> mercTypeList = tar->GetMercTypesList(static_cast<unsigned int>(GetClientVersion())); std::list<MercType> mercTypeList = tar->GetMercTypesList(static_cast<unsigned int>(ClientVersion()));
std::list<MercData> mercDataList = tar->GetMercsList(static_cast<unsigned int>(GetClientVersion())); std::list<MercData> mercDataList = tar->GetMercsList(static_cast<unsigned int>(ClientVersion()));
int i = 0; int i = 0;
int StanceCount = 0; int StanceCount = 0;
@ -11320,7 +11320,7 @@ void Client::Handle_OP_ReadBook(const EQApplicationPacket *app)
} }
BookRequest_Struct* book = (BookRequest_Struct*)app->pBuffer; BookRequest_Struct* book = (BookRequest_Struct*)app->pBuffer;
ReadBook(book); ReadBook(book);
if (GetClientVersion() >= ClientVersion::SoF) if (ClientVersion() >= EQEmu::versions::ClientVersion::SoF)
{ {
EQApplicationPacket EndOfBook(OP_FinishWindow, 0); EQApplicationPacket EndOfBook(OP_FinishWindow, 0);
QueuePacket(&EndOfBook); QueuePacket(&EndOfBook);
@ -12669,7 +12669,7 @@ void Client::Handle_OP_SpawnAppearance(const EQApplicationPacket *app)
{ {
if (!HasSkill(SkillHide) && GetSkill(SkillHide) == 0) if (!HasSkill(SkillHide) && GetSkill(SkillHide) == 0)
{ {
if (GetClientVersion() < ClientVersion::SoF) if (ClientVersion() < EQEmu::versions::ClientVersion::SoF)
{ {
char *hack_str = nullptr; char *hack_str = nullptr;
MakeAnyLenString(&hack_str, "Player sent OP_SpawnAppearance with AT_Invis: %i", sa->parameter); MakeAnyLenString(&hack_str, "Player sent OP_SpawnAppearance with AT_Invis: %i", sa->parameter);
@ -13519,7 +13519,7 @@ void Client::Handle_OP_Trader(const EQApplicationPacket *app)
this->Trader_StartTrader(); this->Trader_StartTrader();
// This refreshes the Trader window to display the End Trader button // This refreshes the Trader window to display the End Trader button
if (GetClientVersion() >= ClientVersion::RoF) if (ClientVersion() >= EQEmu::versions::ClientVersion::RoF)
{ {
EQApplicationPacket* outapp = new EQApplicationPacket(OP_Trader, sizeof(TraderStatus_Struct)); EQApplicationPacket* outapp = new EQApplicationPacket(OP_Trader, sizeof(TraderStatus_Struct));
TraderStatus_Struct* tss = (TraderStatus_Struct*)outapp->pBuffer; TraderStatus_Struct* tss = (TraderStatus_Struct*)outapp->pBuffer;

12
zone/client_process.cpp
View File

@ -126,7 +126,7 @@ bool Client::Process() {
HandleRespawnFromHover(0); HandleRespawnFromHover(0);
} }
if(IsTracking() && (GetClientVersion() >= ClientVersion::SoD) && TrackingTimer.Check()) if (IsTracking() && (ClientVersion() >= EQEmu::versions::ClientVersion::SoD) && TrackingTimer.Check())
DoTracking(); DoTracking();
// SendHPUpdate calls hpupdate_timer.Start so it can delay this timer, so lets not reset with the check // SendHPUpdate calls hpupdate_timer.Start so it can delay this timer, so lets not reset with the check
@ -800,7 +800,7 @@ void Client::BulkSendInventoryItems() {
} }
// Power Source // Power Source
if(GetClientVersion() >= ClientVersion::SoF) { if (ClientVersion() >= EQEmu::versions::ClientVersion::SoF) {
const ItemInst* inst = m_inv[SlotPowerSource]; const ItemInst* inst = m_inv[SlotPowerSource];
if(inst) { if(inst) {
std::string packet = inst->Serialize(SlotPowerSource); std::string packet = inst->Serialize(SlotPowerSource);
@ -890,7 +890,7 @@ void Client::BulkSendInventoryItems()
void Client::BulkSendMerchantInventory(int merchant_id, int npcid) { void Client::BulkSendMerchantInventory(int merchant_id, int npcid) {
const Item_Struct* handyitem = nullptr; const Item_Struct* handyitem = nullptr;
uint32 numItemSlots = 80; //The max number of items passed in the transaction. uint32 numItemSlots = 80; //The max number of items passed in the transaction.
if (m_ClientVersionBit & BIT_RoFAndLater) { // RoF+ can send 200 items if (m_ClientVersionBit & EQEmu::versions::bit_RoFAndLater) { // RoF+ can send 200 items
numItemSlots = 200; numItemSlots = 200;
} }
const Item_Struct *item; const Item_Struct *item;
@ -1554,7 +1554,7 @@ void Client::OPGMTraining(const EQApplicationPacket *app)
} }
} }
if (GetClientVersion() < ClientVersion::RoF2 && GetClass() == BERSERKER) { if (ClientVersion() < EQEmu::versions::ClientVersion::RoF2 && GetClass() == BERSERKER) {
gmtrain->skills[Skill1HPiercing] = gmtrain->skills[Skill2HPiercing]; gmtrain->skills[Skill1HPiercing] = gmtrain->skills[Skill2HPiercing];
gmtrain->skills[Skill2HPiercing] = 0; gmtrain->skills[Skill2HPiercing] = 0;
} }
@ -1734,7 +1734,7 @@ void Client::OPGMTrainSkill(const EQApplicationPacket *app)
} }
} }
if(GetClientVersion() >= ClientVersion::SoF) { if (ClientVersion() >= EQEmu::versions::ClientVersion::SoF) {
// The following packet decreases the skill points left in the Training Window and // The following packet decreases the skill points left in the Training Window and
// produces the 'You have increased your skill / learned the basics of' message. // produces the 'You have increased your skill / learned the basics of' message.
// //
@ -2174,7 +2174,7 @@ void Client::ClearHover()
entity_list.QueueClients(this, outapp, false); entity_list.QueueClients(this, outapp, false);
safe_delete(outapp); safe_delete(outapp);
if(IsClient() && CastToClient()->GetClientVersionBit() & BIT_UFAndLater) if (IsClient() && CastToClient()->ClientVersionBit() & EQEmu::versions::bit_UFAndLater)
{ {
EQApplicationPacket *outapp = MakeBuffsPacket(false); EQApplicationPacket *outapp = MakeBuffsPacket(false);
CastToClient()->FastQueuePacket(&outapp); CastToClient()->FastQueuePacket(&outapp);

2
zone/command.cpp
View File

@ -2562,7 +2562,7 @@ void command_peekinv(Client *c, const Seperator *sep)
indexMain, ((item_data == nullptr) ? 0 : item_data->ID), item_link.c_str(), ((inst_main == nullptr) ? 0 : inst_main->GetCharges())); indexMain, ((item_data == nullptr) ? 0 : item_data->ID), item_link.c_str(), ((inst_main == nullptr) ? 0 : inst_main->GetCharges()));
} }
if ((scopeWhere & peekWorn) && (targetClient->GetClientVersion() >= ClientVersion::SoF)) { if ((scopeWhere & peekWorn) && (targetClient->ClientVersion() >= EQEmu::versions::ClientVersion::SoF)) {
inst_main = targetClient->GetInv().GetItem(SlotPowerSource); inst_main = targetClient->GetInv().GetItem(SlotPowerSource);
item_data = (inst_main == nullptr) ? nullptr : inst_main->GetItem(); item_data = (inst_main == nullptr) ? nullptr : inst_main->GetItem();
linker.SetItemInst(inst_main); linker.SetItemInst(inst_main);

10
zone/corpse.cpp
View File

@ -313,7 +313,7 @@ Corpse::Corpse(Client* client, int32 in_rezexp) : Mob (
// cash // cash
// Let's not move the cash when 'RespawnFromHover = true' && 'client->GetClientVersion() < EQClientSoF' since the client doesn't. // Let's not move the cash when 'RespawnFromHover = true' && 'client->GetClientVersion() < EQClientSoF' since the client doesn't.
// (change to first client that supports 'death hover' mode, if not SoF.) // (change to first client that supports 'death hover' mode, if not SoF.)
if (!RuleB(Character, RespawnFromHover) || client->GetClientVersion() < ClientVersion::SoF) { if (!RuleB(Character, RespawnFromHover) || client->ClientVersion() < EQEmu::versions::ClientVersion::SoF) {
SetCash(pp->copper, pp->silver, pp->gold, pp->platinum); SetCash(pp->copper, pp->silver, pp->gold, pp->platinum);
pp->copper = 0; pp->copper = 0;
pp->silver = 0; pp->silver = 0;
@ -329,7 +329,7 @@ Corpse::Corpse(Client* client, int32 in_rezexp) : Mob (
std::list<uint32> removed_list; std::list<uint32> removed_list;
for(i = SLOT_BEGIN; i < EQEmu::constants::TYPE_POSSESSIONS_SIZE; ++i) { for(i = SLOT_BEGIN; i < EQEmu::constants::TYPE_POSSESSIONS_SIZE; ++i) {
if(i == SlotAmmo && client->GetClientVersion() >= ClientVersion::SoF) { if (i == SlotAmmo && client->ClientVersion() >= EQEmu::versions::ClientVersion::SoF) {
item = client->GetInv().GetItem(SlotPowerSource); item = client->GetInv().GetItem(SlotPowerSource);
if (item != nullptr) { if (item != nullptr) {
if (!client->IsBecomeNPC() || (client->IsBecomeNPC() && !item->GetItem()->NoRent)) if (!client->IsBecomeNPC() || (client->IsBecomeNPC() && !item->GetItem()->NoRent))
@ -1000,7 +1000,7 @@ void Corpse::MakeLootRequestPackets(Client* client, const EQApplicationPacket* a
cur = itemlist.begin(); cur = itemlist.begin();
end = itemlist.end(); end = itemlist.end();
int corpselootlimit = EQEmu::limits::InventoryMapSize(TypeCorpse, client->GetClientVersion()); int corpselootlimit = EQEmu::limits::InventoryTypeSize(EQEmu::versions::ConvertClientVersionToInventoryVersion(client->ClientVersion()), TypeCorpse);
for(; cur != end; ++cur) { for(; cur != end; ++cur) {
ServerLootItem_Struct* item_data = *cur; ServerLootItem_Struct* item_data = *cur;
@ -1060,7 +1060,7 @@ void Corpse::MakeLootRequestPackets(Client* client, const EQApplicationPacket* a
// This is required for the 'Loot All' feature to work for SoD clients. I expect it is to tell the client that the // This is required for the 'Loot All' feature to work for SoD clients. I expect it is to tell the client that the
// server has now sent all the items on the corpse. // server has now sent all the items on the corpse.
if(client->GetClientVersion() >= ClientVersion::SoD) { SendLootReqErrorPacket(client, 6); } if (client->ClientVersion() >= EQEmu::versions::ClientVersion::SoD) { SendLootReqErrorPacket(client, 6); }
} }
void Corpse::LootItem(Client* client, const EQApplicationPacket* app) { void Corpse::LootItem(Client* client, const EQApplicationPacket* app) {
@ -1294,7 +1294,7 @@ void Corpse::QueryLoot(Client* to) {
cur = itemlist.begin(); cur = itemlist.begin();
end = itemlist.end(); end = itemlist.end();
int corpselootlimit = EQEmu::limits::InventoryMapSize(TypeCorpse, to->GetClientVersion()); int corpselootlimit = EQEmu::limits::InventoryTypeSize(EQEmu::versions::ConvertClientVersionToInventoryVersion(to->ClientVersion()), TypeCorpse);
for(; cur != end; ++cur) { for(; cur != end; ++cur) {
ServerLootItem_Struct* sitem = *cur; ServerLootItem_Struct* sitem = *cur;

6
zone/entity.cpp
View File

@ -867,7 +867,7 @@ bool EntityList::MakeDoorSpawnPacket(EQApplicationPacket *app, Client *client)
if (door_list.empty()) if (door_list.empty())
return false; return false;
uint32 mask_test = client->GetClientVersionBit(); uint32 mask_test = client->ClientVersionBit();
int count = 0; int count = 0;
auto it = door_list.begin(); auto it = door_list.begin();
@ -1474,7 +1474,7 @@ void EntityList::QueueClientsByTarget(Mob *sender, const EQApplicationPacket *ap
} }
} }
if (Send && (c->GetClientVersionBit() & ClientVersionBits)) if (Send && (c->ClientVersionBit() & ClientVersionBits))
c->QueuePacket(app, ackreq); c->QueuePacket(app, ackreq);
} }
} }
@ -4406,7 +4406,7 @@ void EntityList::UpdateFindableNPCState(NPC *n, bool Remove)
auto it = client_list.begin(); auto it = client_list.begin();
while (it != client_list.end()) { while (it != client_list.end()) {
Client *c = it->second; Client *c = it->second;
if (c && (c->GetClientVersion() >= ClientVersion::SoD)) if (c && (c->ClientVersion() >= EQEmu::versions::ClientVersion::SoD))
c->QueuePacket(outapp); c->QueuePacket(outapp);
++it; ++it;

16
zone/groups.cpp
View File

@ -395,7 +395,7 @@ void Group::SendHPPacketsTo(Mob *member)
{ {
members[i]->CreateHPPacket(&hpapp); members[i]->CreateHPPacket(&hpapp);
member->CastToClient()->QueuePacket(&hpapp, false); member->CastToClient()->QueuePacket(&hpapp, false);
if(member->CastToClient()->GetClientVersion() >= ClientVersion::SoD) if (member->CastToClient()->ClientVersion() >= EQEmu::versions::ClientVersion::SoD)
{ {
outapp.SetOpcode(OP_MobManaUpdate); outapp.SetOpcode(OP_MobManaUpdate);
MobManaUpdate_Struct *mmus = (MobManaUpdate_Struct *)outapp.pBuffer; MobManaUpdate_Struct *mmus = (MobManaUpdate_Struct *)outapp.pBuffer;
@ -426,7 +426,7 @@ void Group::SendHPPacketsFrom(Mob *member)
if(members[i] && members[i] != member && members[i]->IsClient()) if(members[i] && members[i] != member && members[i]->IsClient())
{ {
members[i]->CastToClient()->QueuePacket(&hp_app); members[i]->CastToClient()->QueuePacket(&hp_app);
if(members[i]->CastToClient()->GetClientVersion() >= ClientVersion::SoD) if (members[i]->CastToClient()->ClientVersion() >= EQEmu::versions::ClientVersion::SoD)
{ {
outapp.SetOpcode(OP_MobManaUpdate); outapp.SetOpcode(OP_MobManaUpdate);
MobManaUpdate_Struct *mmus = (MobManaUpdate_Struct *)outapp.pBuffer; MobManaUpdate_Struct *mmus = (MobManaUpdate_Struct *)outapp.pBuffer;
@ -566,7 +566,7 @@ bool Group::DelMemberOOZ(const char *Name) {
if(GroupCount() < 3) if(GroupCount() < 3)
{ {
UnDelegateMarkNPC(NPCMarkerName.c_str()); UnDelegateMarkNPC(NPCMarkerName.c_str());
if(GetLeader() && GetLeader()->IsClient() && GetLeader()->CastToClient()->GetClientVersion() < ClientVersion::SoD) { if (GetLeader() && GetLeader()->IsClient() && GetLeader()->CastToClient()->ClientVersion() < EQEmu::versions::ClientVersion::SoD) {
UnDelegateMainAssist(MainAssistName.c_str()); UnDelegateMainAssist(MainAssistName.c_str());
} }
ClearAllNPCMarks(); ClearAllNPCMarks();
@ -724,7 +724,7 @@ bool Group::DelMember(Mob* oldmember, bool ignoresender)
if(GroupCount() < 3) if(GroupCount() < 3)
{ {
UnDelegateMarkNPC(NPCMarkerName.c_str()); UnDelegateMarkNPC(NPCMarkerName.c_str());
if(GetLeader() && GetLeader()->IsClient() && GetLeader()->CastToClient()->GetClientVersion() < ClientVersion::SoD) { if (GetLeader() && GetLeader()->IsClient() && GetLeader()->CastToClient()->ClientVersion() < EQEmu::versions::ClientVersion::SoD) {
UnDelegateMainAssist(MainAssistName.c_str()); UnDelegateMainAssist(MainAssistName.c_str());
} }
ClearAllNPCMarks(); ClearAllNPCMarks();
@ -1604,7 +1604,7 @@ void Group::NotifyMainTank(Client *c, uint8 toggle)
if(!MainTankName.size()) if(!MainTankName.size())
return; return;
if(c->GetClientVersion() < ClientVersion::SoD) if (c->ClientVersion() < EQEmu::versions::ClientVersion::SoD)
{ {
if(toggle) if(toggle)
c->Message(0, "%s is now Main Tank.", MainTankName.c_str()); c->Message(0, "%s is now Main Tank.", MainTankName.c_str());
@ -1644,7 +1644,7 @@ void Group::NotifyMainAssist(Client *c, uint8 toggle)
if(!MainAssistName.size()) if(!MainAssistName.size())
return; return;
if(c->GetClientVersion() < ClientVersion::SoD) if (c->ClientVersion() < EQEmu::versions::ClientVersion::SoD)
{ {
EQApplicationPacket *outapp = new EQApplicationPacket(OP_DelegateAbility, sizeof(DelegateAbility_Struct)); EQApplicationPacket *outapp = new EQApplicationPacket(OP_DelegateAbility, sizeof(DelegateAbility_Struct));
@ -1699,7 +1699,7 @@ void Group::NotifyPuller(Client *c, uint8 toggle)
if(!PullerName.size()) if(!PullerName.size())
return; return;
if(c->GetClientVersion() < ClientVersion::SoD) if (c->ClientVersion() < EQEmu::versions::ClientVersion::SoD)
{ {
if(toggle) if(toggle)
c->Message(0, "%s is now Puller.", PullerName.c_str()); c->Message(0, "%s is now Puller.", PullerName.c_str());
@ -2265,7 +2265,7 @@ void Group::ChangeLeader(Mob* newleader)
for (uint32 i = 0; i < MAX_GROUP_MEMBERS; i++) { for (uint32 i = 0; i < MAX_GROUP_MEMBERS; i++) {
if (members[i] && members[i]->IsClient()) if (members[i] && members[i]->IsClient())
{ {
if(members[i]->CastToClient()->GetClientVersion() >= ClientVersion::SoD) if (members[i]->CastToClient()->ClientVersion() >= EQEmu::versions::ClientVersion::SoD)
members[i]->CastToClient()->SendGroupLeaderChangePacket(newleader->GetName()); members[i]->CastToClient()->SendGroupLeaderChangePacket(newleader->GetName());
members[i]->CastToClient()->QueuePacket(outapp); members[i]->CastToClient()->QueuePacket(outapp);

10
zone/guild.cpp
View File

@ -63,7 +63,7 @@ void Client::SendGuildMOTD(bool GetGuildMOTDReply) {
void Client::SendGuildURL() void Client::SendGuildURL()
{ {
if(GetClientVersion() < ClientVersion::SoF) if (ClientVersion() < EQEmu::versions::ClientVersion::SoF)
return; return;
if(IsInAGuild()) if(IsInAGuild())
@ -84,7 +84,7 @@ void Client::SendGuildURL()
void Client::SendGuildChannel() void Client::SendGuildChannel()
{ {
if(GetClientVersion() < ClientVersion::SoF) if (ClientVersion() < EQEmu::versions::ClientVersion::SoF)
return; return;
if(IsInAGuild()) if(IsInAGuild())
@ -106,7 +106,7 @@ void Client::SendGuildChannel()
void Client::SendGuildRanks() void Client::SendGuildRanks()
{ {
if(GetClientVersion() < ClientVersion::RoF) if (ClientVersion() < EQEmu::versions::ClientVersion::RoF)
return; return;
int permissions = 30 + 1; //Static number of permissions in all EQ clients as of May 2014 int permissions = 30 + 1; //Static number of permissions in all EQ clients as of May 2014
@ -149,7 +149,7 @@ void Client::SendGuildSpawnAppearance() {
uint8 rank = guild_mgr.GetDisplayedRank(GuildID(), GuildRank(), CharacterID()); uint8 rank = guild_mgr.GetDisplayedRank(GuildID(), GuildRank(), CharacterID());
Log.Out(Logs::Detail, Logs::Guilds, "Sending spawn appearance for guild %d at rank %d", GuildID(), rank); Log.Out(Logs::Detail, Logs::Guilds, "Sending spawn appearance for guild %d at rank %d", GuildID(), rank);
SendAppearancePacket(AT_GuildID, GuildID()); SendAppearancePacket(AT_GuildID, GuildID());
if(GetClientVersion() >= ClientVersion::RoF) if (ClientVersion() >= EQEmu::versions::ClientVersion::RoF)
{ {
switch (rank) { switch (rank) {
case 0: { rank = 5; break; } // GUILD_MEMBER 0 case 0: { rank = 5; break; } // GUILD_MEMBER 0
@ -249,7 +249,7 @@ void Client::RefreshGuildInfo()
if((guild_id != OldGuildID) && GuildBanks) if((guild_id != OldGuildID) && GuildBanks)
{ {
// Unsure about this for RoF+ ... But they don't have that action anymore so fuck it // Unsure about this for RoF+ ... But they don't have that action anymore so fuck it
if (GetClientVersion() < ClientVersion::RoF) if (ClientVersion() < EQEmu::versions::ClientVersion::RoF)
ClearGuildBank(); ClearGuildBank();
if(guild_id != GUILD_NONE) if(guild_id != GUILD_NONE)

4
zone/guild_mgr.cpp
View File

@ -322,7 +322,7 @@ void ZoneGuildManager::ProcessWorldPacket(ServerPacket *pack) {
else if(c != nullptr && s->guild_id != GUILD_NONE) { else if(c != nullptr && s->guild_id != GUILD_NONE) {
//char is in zone, and has changed into a new guild, send MOTD. //char is in zone, and has changed into a new guild, send MOTD.
c->SendGuildMOTD(); c->SendGuildMOTD();
if(c->GetClientVersion() >= ClientVersion::RoF) if (c->ClientVersion() >= EQEmu::versions::ClientVersion::RoF)
{ {
c->SendGuildRanks(); c->SendGuildRanks();
} }
@ -691,7 +691,7 @@ void GuildBankManager::SendGuildBank(Client *c)
auto &guild_bank = *Iterator; auto &guild_bank = *Iterator;
// RoF+ uses a bulk list packet -- This is also how the Action 0 of older clients basically works // RoF+ uses a bulk list packet -- This is also how the Action 0 of older clients basically works
if (c->GetClientVersionBit() & BIT_RoFAndLater) { if (c->ClientVersionBit() & EQEmu::versions::bit_RoFAndLater) {
auto outapp = new EQApplicationPacket(OP_GuildBankItemList, sizeof(GuildBankItemListEntry_Struct) * 240); auto outapp = new EQApplicationPacket(OP_GuildBankItemList, sizeof(GuildBankItemListEntry_Struct) * 240);
for (int i = 0; i < GUILD_BANK_DEPOSIT_AREA_SIZE; ++i) { for (int i = 0; i < GUILD_BANK_DEPOSIT_AREA_SIZE; ++i) {
const Item_Struct *Item = database.GetItem(guild_bank->Items.DepositArea[i].ItemID); const Item_Struct *Item = database.GetItem(guild_bank->Items.DepositArea[i].ItemID);

14
zone/inventory.cpp
View File

@ -56,7 +56,7 @@ uint32 Client::NukeItem(uint32 itemnum, uint8 where_to_check) {
x++; x++;
} }
if (GetClientVersion() >= ClientVersion::SoF) if (ClientVersion() >= EQEmu::versions::ClientVersion::SoF)
DeleteItemInInventory(SlotPowerSource, 0, true); DeleteItemInInventory(SlotPowerSource, 0, true);
else else
DeleteItemInInventory(SlotPowerSource, 0, false); // Prevents Titanium crash DeleteItemInInventory(SlotPowerSource, 0, false); // Prevents Titanium crash
@ -685,7 +685,7 @@ void Client::SendCursorBuffer()
// Temporary work-around for the RoF+ Client Buffer // Temporary work-around for the RoF+ Client Buffer
// Instead of dealing with client moving items in cursor buffer, // Instead of dealing with client moving items in cursor buffer,
// we can just send the next item in the cursor buffer to the cursor. // we can just send the next item in the cursor buffer to the cursor.
if (GetClientVersion() < ClientVersion::RoF) { return; } if (ClientVersion() < EQEmu::versions::ClientVersion::RoF) { return; }
if (GetInv().CursorEmpty()) { return; } if (GetInv().CursorEmpty()) { return; }
auto test_inst = GetInv().GetCursorItem(); auto test_inst = GetInv().GetCursorItem();
@ -898,7 +898,7 @@ void Client::PutLootInInventory(int16 slot_id, const ItemInst &inst, ServerLootI
// Subordinate items in cursor buffer must be sent via ItemPacketSummonItem or we just overwrite the visible cursor and desync the client // Subordinate items in cursor buffer must be sent via ItemPacketSummonItem or we just overwrite the visible cursor and desync the client
if (slot_id == SlotCursor && !cursor_empty) { if (slot_id == SlotCursor && !cursor_empty) {
// RoF+ currently has a specialized cursor handler // RoF+ currently has a specialized cursor handler
if (GetClientVersion() < ClientVersion::RoF) if (ClientVersion() < EQEmu::versions::ClientVersion::RoF)
SendItemPacket(slot_id, &inst, ItemPacketSummonItem); SendItemPacket(slot_id, &inst, ItemPacketSummonItem);
} }
else { else {
@ -991,7 +991,7 @@ bool Client::AutoPutLootInInventory(ItemInst& inst, bool try_worn, bool try_curs
for (int16 i = EQEmu::constants::EQUIPMENT_BEGIN; i < SlotPowerSource; i++) { // originally (i < 22) for (int16 i = EQEmu::constants::EQUIPMENT_BEGIN; i < SlotPowerSource; i++) { // originally (i < 22)
if (i == EQEmu::constants::GENERAL_BEGIN) { if (i == EQEmu::constants::GENERAL_BEGIN) {
// added power source check for SoF+ clients // added power source check for SoF+ clients
if (this->GetClientVersion() >= ClientVersion::SoF) if (this->ClientVersion() >= EQEmu::versions::ClientVersion::SoF)
i = SlotPowerSource; i = SlotPowerSource;
else else
break; break;
@ -1375,7 +1375,7 @@ bool Client::SwapItem(MoveItem_Struct* move_in) {
if (move_in->from_slot == move_in->to_slot) { // Item summon, no further processing needed if (move_in->from_slot == move_in->to_slot) { // Item summon, no further processing needed
if(RuleB(QueryServ, PlayerLogMoves)) { QSSwapItemAuditor(move_in); } // QS Audit if(RuleB(QueryServ, PlayerLogMoves)) { QSSwapItemAuditor(move_in); } // QS Audit
if (GetClientVersion() >= ClientVersion::RoF) { return true; } // Can't do RoF+ if (ClientVersion() >= EQEmu::versions::ClientVersion::RoF) { return true; } // Can't do RoF+
if (move_in->to_slot == SlotCursor) { if (move_in->to_slot == SlotCursor) {
auto test_inst = m_inv.GetItem(SlotCursor); auto test_inst = m_inv.GetItem(SlotCursor);
@ -2358,7 +2358,7 @@ void Client::RemoveNoRent(bool client_update)
auto inst = m_inv[SlotPowerSource]; auto inst = m_inv[SlotPowerSource];
if (inst && !inst->GetItem()->NoRent) { if (inst && !inst->GetItem()->NoRent) {
Log.Out(Logs::Detail, Logs::Inventory, "NoRent Timer Lapse: Deleting %s from slot %i", inst->GetItem()->Name, SlotPowerSource); Log.Out(Logs::Detail, Logs::Inventory, "NoRent Timer Lapse: Deleting %s from slot %i", inst->GetItem()->Name, SlotPowerSource);
DeleteItemInInventory(SlotPowerSource, 0, (GetClientVersion() >= ClientVersion::SoF) ? client_update : false); // Ti slot non-existent DeleteItemInInventory(SlotPowerSource, 0, (ClientVersion() >= EQEmu::versions::ClientVersion::SoF) ? client_update : false); // Ti slot non-existent
} }
} }
@ -2576,7 +2576,7 @@ void Client::MoveSlotNotAllowed(bool client_update)
bool is_arrow = (inst->GetItem()->ItemType == ItemTypeArrow) ? true : false; bool is_arrow = (inst->GetItem()->ItemType == ItemTypeArrow) ? true : false;
int16 free_slot_id = m_inv.FindFreeSlot(inst->IsType(ItemClassContainer), true, inst->GetItem()->Size, is_arrow); int16 free_slot_id = m_inv.FindFreeSlot(inst->IsType(ItemClassContainer), true, inst->GetItem()->Size, is_arrow);
Log.Out(Logs::Detail, Logs::Inventory, "Slot Assignment Error: Moving %s from slot %i to %i", inst->GetItem()->Name, SlotPowerSource, free_slot_id); Log.Out(Logs::Detail, Logs::Inventory, "Slot Assignment Error: Moving %s from slot %i to %i", inst->GetItem()->Name, SlotPowerSource, free_slot_id);
PutItemInInventory(free_slot_id, *inst, (GetClientVersion() >= ClientVersion::SoF) ? client_update : false); PutItemInInventory(free_slot_id, *inst, (ClientVersion() >= EQEmu::versions::ClientVersion::SoF) ? client_update : false);
database.SaveInventory(character_id, nullptr, SlotPowerSource); database.SaveInventory(character_id, nullptr, SlotPowerSource);
safe_delete(inst); safe_delete(inst);
} }

4
zone/lua_client.cpp
View File

@ -854,12 +854,12 @@ void Lua_Client::SetAATitle(const char *title) {
int Lua_Client::GetClientVersion() { int Lua_Client::GetClientVersion() {
Lua_Safe_Call_Int(); Lua_Safe_Call_Int();
return static_cast<unsigned int>(self->GetClientVersion()); return static_cast<unsigned int>(self->ClientVersion());
} }
uint32 Lua_Client::GetClientVersionBit() { uint32 Lua_Client::GetClientVersionBit() {
Lua_Safe_Call_Int(); Lua_Safe_Call_Int();
return self->GetClientVersionBit(); return self->ClientVersionBit();
} }
void Lua_Client::SetTitleSuffix(const char *text) { void Lua_Client::SetTitleSuffix(const char *text) {

16
zone/lua_general.cpp
View File

@ -1829,14 +1829,14 @@ luabind::scope lua_register_client_version() {
return luabind::class_<ClientVersions>("ClientVersion") return luabind::class_<ClientVersions>("ClientVersion")
.enum_("constants") .enum_("constants")
[ [
luabind::value("Unknown", static_cast<int>(ClientVersion::Unknown)), luabind::value("Unknown", static_cast<int>(EQEmu::versions::ClientVersion::Unknown)),
luabind::value("Titanium", static_cast<int>(ClientVersion::Titanium)), luabind::value("Titanium", static_cast<int>(EQEmu::versions::ClientVersion::Titanium)),
luabind::value("SoF", static_cast<int>(ClientVersion::SoF)), luabind::value("SoF", static_cast<int>(EQEmu::versions::ClientVersion::SoF)),
luabind::value("SoD", static_cast<int>(ClientVersion::SoD)), luabind::value("SoD", static_cast<int>(EQEmu::versions::ClientVersion::SoD)),
luabind::value("Underfoot", static_cast<int>(ClientVersion::UF)), // deprecated luabind::value("Underfoot", static_cast<int>(EQEmu::versions::ClientVersion::UF)), // deprecated
luabind::value("UF", static_cast<int>(ClientVersion::UF)), luabind::value("UF", static_cast<int>(EQEmu::versions::ClientVersion::UF)),
luabind::value("RoF", static_cast<int>(ClientVersion::RoF)), luabind::value("RoF", static_cast<int>(EQEmu::versions::ClientVersion::RoF)),
luabind::value("RoF2", static_cast<int>(ClientVersion::RoF2)) luabind::value("RoF2", static_cast<int>(EQEmu::versions::ClientVersion::RoF2))
]; ];
} }

44
zone/merc.cpp
View File

@ -50,7 +50,7 @@ Merc::Merc(const NPCType* d, float x, float y, float z, float heading)
_baseFR = d->FR; _baseFR = d->FR;
_basePR = d->PR; _basePR = d->PR;
_baseCorrup = d->Corrup; _baseCorrup = d->Corrup;
_OwnerClientVersion = static_cast<unsigned int>(ClientVersion::Titanium); _OwnerClientVersion = static_cast<unsigned int>(EQEmu::versions::ClientVersion::Titanium);
RestRegenHP = 0; RestRegenHP = 0;
RestRegenMana = 0; RestRegenMana = 0;
RestRegenEndurance = 0; RestRegenEndurance = 0;
@ -1018,7 +1018,7 @@ int32 Merc::CalcBaseEndurance()
int32 sta_end = 0; int32 sta_end = 0;
int Stats = 0; int Stats = 0;
if(GetClientVersion() >= static_cast<unsigned int>(ClientVersion::SoD) && RuleB(Character, SoDClientUseSoDHPManaEnd)) { if (GetClientVersion() >= static_cast<unsigned int>(EQEmu::versions::ClientVersion::SoD) && RuleB(Character, SoDClientUseSoDHPManaEnd)) {
int HeroicStats = 0; int HeroicStats = 0;
Stats = ((GetSTR() + GetSTA() + GetDEX() + GetAGI()) / 4); Stats = ((GetSTR() + GetSTA() + GetDEX() + GetAGI()) / 4);
@ -5127,109 +5127,109 @@ void Client::SendMercResponsePackets(uint32 ResponseType)
SendMercMerchantResponsePacket(6); SendMercMerchantResponsePacket(6);
break; break;
case 7: //You must dismiss your suspended mercenary before purchasing a new one! case 7: //You must dismiss your suspended mercenary before purchasing a new one!
if (GetClientVersion() < ClientVersion::RoF) if (ClientVersion() < EQEmu::versions::ClientVersion::RoF)
SendMercMerchantResponsePacket(7); SendMercMerchantResponsePacket(7);
else else
//You have the maximum number of mercenaries. You must dismiss one before purchasing a new one! //You have the maximum number of mercenaries. You must dismiss one before purchasing a new one!
SendMercMerchantResponsePacket(6); SendMercMerchantResponsePacket(6);
break; break;
case 8: //You can not purchase a mercenary because your group is full! case 8: //You can not purchase a mercenary because your group is full!
if (GetClientVersion() < ClientVersion::RoF) if (ClientVersion() < EQEmu::versions::ClientVersion::RoF)
SendMercMerchantResponsePacket(8); SendMercMerchantResponsePacket(8);
else else
SendMercMerchantResponsePacket(7); SendMercMerchantResponsePacket(7);
break; break;
case 9: //You can not purchase a mercenary because you are in combat! case 9: //You can not purchase a mercenary because you are in combat!
if (GetClientVersion() < ClientVersion::RoF) if (ClientVersion() < EQEmu::versions::ClientVersion::RoF)
//Mercenary failed to spawn! //Mercenary failed to spawn!
SendMercMerchantResponsePacket(3); SendMercMerchantResponsePacket(3);
else else
SendMercMerchantResponsePacket(8); SendMercMerchantResponsePacket(8);
break; break;
case 10: //You have recently dismissed a mercenary and must wait a few more seconds before you can purchase a new one! case 10: //You have recently dismissed a mercenary and must wait a few more seconds before you can purchase a new one!
if (GetClientVersion() < ClientVersion::RoF) if (ClientVersion() < EQEmu::versions::ClientVersion::RoF)
//Mercenary failed to spawn! //Mercenary failed to spawn!
SendMercMerchantResponsePacket(3); SendMercMerchantResponsePacket(3);
else else
SendMercMerchantResponsePacket(9); SendMercMerchantResponsePacket(9);
break; break;
case 11: //An error occurred created your mercenary! case 11: //An error occurred created your mercenary!
if (GetClientVersion() < ClientVersion::RoF) if (ClientVersion() < EQEmu::versions::ClientVersion::RoF)
SendMercMerchantResponsePacket(9); SendMercMerchantResponsePacket(9);
else else
SendMercMerchantResponsePacket(10); SendMercMerchantResponsePacket(10);
break; break;
case 12: //Upkeep Charge Message case 12: //Upkeep Charge Message
if (GetClientVersion() < ClientVersion::RoF) if (ClientVersion() < EQEmu::versions::ClientVersion::RoF)
SendMercMerchantResponsePacket(10); SendMercMerchantResponsePacket(10);
else else
SendMercMerchantResponsePacket(11); SendMercMerchantResponsePacket(11);
break; break;
case 13: // ??? case 13: // ???
if (GetClientVersion() < ClientVersion::RoF) if (ClientVersion() < EQEmu::versions::ClientVersion::RoF)
SendMercMerchantResponsePacket(11); SendMercMerchantResponsePacket(11);
else else
SendMercMerchantResponsePacket(12); SendMercMerchantResponsePacket(12);
break; break;
case 14: //You ran out of funds to pay for your mercenary! case 14: //You ran out of funds to pay for your mercenary!
if (GetClientVersion() < ClientVersion::RoF) if (ClientVersion() < EQEmu::versions::ClientVersion::RoF)
SendMercMerchantResponsePacket(12); SendMercMerchantResponsePacket(12);
else else
SendMercMerchantResponsePacket(13); SendMercMerchantResponsePacket(13);
break; break;
case 15: // ??? case 15: // ???
if (GetClientVersion() < ClientVersion::RoF) if (ClientVersion() < EQEmu::versions::ClientVersion::RoF)
SendMercMerchantResponsePacket(13); SendMercMerchantResponsePacket(13);
else else
SendMercMerchantResponsePacket(14); SendMercMerchantResponsePacket(14);
break; break;
case 16: //Your mercenary is about to be suspended due to insufficient funds! case 16: //Your mercenary is about to be suspended due to insufficient funds!
if (GetClientVersion() < ClientVersion::RoF) if (ClientVersion() < EQEmu::versions::ClientVersion::RoF)
SendMercMerchantResponsePacket(14); SendMercMerchantResponsePacket(14);
else else
SendMercMerchantResponsePacket(15); SendMercMerchantResponsePacket(15);
break; break;
case 17: //There is no mercenary liaison nearby! case 17: //There is no mercenary liaison nearby!
if (GetClientVersion() < ClientVersion::RoF) if (ClientVersion() < EQEmu::versions::ClientVersion::RoF)
SendMercMerchantResponsePacket(15); SendMercMerchantResponsePacket(15);
else else
SendMercMerchantResponsePacket(16); SendMercMerchantResponsePacket(16);
break; break;
case 18: //You are too far from the liaison! case 18: //You are too far from the liaison!
if (GetClientVersion() < ClientVersion::RoF) if (ClientVersion() < EQEmu::versions::ClientVersion::RoF)
SendMercMerchantResponsePacket(16); SendMercMerchantResponsePacket(16);
else else
SendMercMerchantResponsePacket(17); SendMercMerchantResponsePacket(17);
break; break;
case 19: //You do not meet the requirements for that mercenary! case 19: //You do not meet the requirements for that mercenary!
if (GetClientVersion() < ClientVersion::RoF) if (ClientVersion() < EQEmu::versions::ClientVersion::RoF)
SendMercMerchantResponsePacket(17); SendMercMerchantResponsePacket(17);
else else
SendMercMerchantResponsePacket(18); SendMercMerchantResponsePacket(18);
break; break;
case 20: //You are unable to interact with the liaison! case 20: //You are unable to interact with the liaison!
if (GetClientVersion() < ClientVersion::RoF) if (ClientVersion() < EQEmu::versions::ClientVersion::RoF)
//You are too far from the liaison! //You are too far from the liaison!
SendMercMerchantResponsePacket(16); SendMercMerchantResponsePacket(16);
else else
SendMercMerchantResponsePacket(19); SendMercMerchantResponsePacket(19);
break; break;
case 21: //You do not have a high enough membership level to purchase this mercenary! case 21: //You do not have a high enough membership level to purchase this mercenary!
if (GetClientVersion() < ClientVersion::RoF) if (ClientVersion() < EQEmu::versions::ClientVersion::RoF)
//You do not meet the requirements for that mercenary! //You do not meet the requirements for that mercenary!
SendMercMerchantResponsePacket(17); SendMercMerchantResponsePacket(17);
else else
SendMercMerchantResponsePacket(20); SendMercMerchantResponsePacket(20);
break; break;
case 22: //Your purchase has failed because this mercenary requires a Gold membership! case 22: //Your purchase has failed because this mercenary requires a Gold membership!
if (GetClientVersion() < ClientVersion::RoF) if (ClientVersion() < EQEmu::versions::ClientVersion::RoF)
//You do not meet the requirements for that mercenary! //You do not meet the requirements for that mercenary!
SendMercMerchantResponsePacket(17); SendMercMerchantResponsePacket(17);
else else
SendMercMerchantResponsePacket(21); SendMercMerchantResponsePacket(21);
break; break;
case 23: //Your purchase has failed because this mercenary requires at least a Silver membership! case 23: //Your purchase has failed because this mercenary requires at least a Silver membership!
if (GetClientVersion() < ClientVersion::RoF) if (ClientVersion() < EQEmu::versions::ClientVersion::RoF)
//You do not meet the requirements for that mercenary! //You do not meet the requirements for that mercenary!
SendMercMerchantResponsePacket(17); SendMercMerchantResponsePacket(17);
else else
@ -5380,7 +5380,7 @@ bool Client::CheckCanSpawnMerc(uint32 template_id) {
} }
// Check client version // Check client version
if(static_cast<unsigned int>(GetClientVersion()) < mercTemplate->ClientVersion) if(static_cast<unsigned int>(ClientVersion()) < mercTemplate->ClientVersion)
{ {
SendMercResponsePackets(3); SendMercResponsePackets(3);
return false; return false;
@ -6036,7 +6036,7 @@ void Client::SetMerc(Merc* newmerc) {
//Client* oldowner = entity_list.GetClientByID(newmerc->GetOwnerID()); //Client* oldowner = entity_list.GetClientByID(newmerc->GetOwnerID());
newmerc->SetOwnerID(this->GetID()); newmerc->SetOwnerID(this->GetID());
newmerc->SetMercCharacterID(this->CharacterID()); newmerc->SetMercCharacterID(this->CharacterID());
newmerc->SetClientVersion((uint8)this->GetClientVersion()); newmerc->SetClientVersion((uint8)this->ClientVersion());
GetMercInfo().mercid = newmerc->GetMercID(); GetMercInfo().mercid = newmerc->GetMercID();
GetMercInfo().MercTemplateID = newmerc->GetMercTemplateID(); GetMercInfo().MercTemplateID = newmerc->GetMercTemplateID();
GetMercInfo().myTemplate = zone->GetMercTemplate(GetMercInfo().MercTemplateID); GetMercInfo().myTemplate = zone->GetMercTemplate(GetMercInfo().MercTemplateID);
@ -6060,7 +6060,7 @@ void Client::UpdateMercLevel() {
void Client::SendMercMerchantResponsePacket(int32 response_type) { void Client::SendMercMerchantResponsePacket(int32 response_type) {
// This response packet brings up the Mercenary Manager window // This response packet brings up the Mercenary Manager window
if(GetClientVersion() >= ClientVersion::SoD) if (ClientVersion() >= EQEmu::versions::ClientVersion::SoD)
{ {
EQApplicationPacket *outapp = new EQApplicationPacket(OP_MercenaryHire, sizeof(MercenaryMerchantResponse_Struct)); EQApplicationPacket *outapp = new EQApplicationPacket(OP_MercenaryHire, sizeof(MercenaryMerchantResponse_Struct));
MercenaryMerchantResponse_Struct* mmr = (MercenaryMerchantResponse_Struct*)outapp->pBuffer; MercenaryMerchantResponse_Struct* mmr = (MercenaryMerchantResponse_Struct*)outapp->pBuffer;

4
zone/mob.cpp
View File

@ -1284,7 +1284,7 @@ void Mob::SendHPUpdate(bool skip_self)
CreateHPPacket(&hp_app); CreateHPPacket(&hp_app);
// send to people who have us targeted // send to people who have us targeted
entity_list.QueueClientsByTarget(this, &hp_app, false, 0, false, true, BIT_AllClients); entity_list.QueueClientsByTarget(this, &hp_app, false, 0, false, true, EQEmu::versions::bit_AllClients);
entity_list.QueueClientsByXTarget(this, &hp_app, false); entity_list.QueueClientsByXTarget(this, &hp_app, false);
entity_list.QueueToGroupsForNPCHealthAA(this, &hp_app); entity_list.QueueToGroupsForNPCHealthAA(this, &hp_app);
@ -5031,7 +5031,7 @@ uint16 Mob::GetSkillByItemType(int ItemType)
case ItemType2HBlunt: case ItemType2HBlunt:
return Skill2HBlunt; return Skill2HBlunt;
case ItemType2HPiercing: case ItemType2HPiercing:
if (IsClient() && CastToClient()->GetClientVersion() < ClientVersion::RoF2) if (IsClient() && CastToClient()->ClientVersion() < EQEmu::versions::ClientVersion::RoF2)
return Skill1HPiercing; return Skill1HPiercing;
else else
return Skill2HPiercing; return Skill2HPiercing;

2
zone/npc.cpp
View File

@ -24,7 +24,7 @@
#include "../common/seperator.h" #include "../common/seperator.h"
#include "../common/spdat.h" #include "../common/spdat.h"
#include "../common/string_util.h" #include "../common/string_util.h"
#include "../common/clientversions.h" #include "../common/client_version.h" // inv2 watch
#include "../common/features.h" #include "../common/features.h"
#include "../common/item.h" #include "../common/item.h"
#include "../common/item_struct.h" #include "../common/item_struct.h"

4
zone/object.cpp
View File

@ -117,7 +117,7 @@ Object::Object(Client* client, const ItemInst* inst)
m_data.heading = client->GetHeading(); m_data.heading = client->GetHeading();
m_data.x = client->GetX(); m_data.x = client->GetX();
m_data.y = client->GetY(); m_data.y = client->GetY();
if (client->GetClientVersion() >= ClientVersion::RoF2) if (client->ClientVersion() >= EQEmu::versions::ClientVersion::RoF2)
{ {
// RoF2 places items at player's Z, which is 0.625 of their height. // RoF2 places items at player's Z, which is 0.625 of their height.
m_data.z = client->GetZ() - (client->GetSize() * 0.625f); m_data.z = client->GetZ() - (client->GetSize() * 0.625f);
@ -548,7 +548,7 @@ bool Object::HandleClick(Client* sender, const ClickObject_Struct* click_object)
else { else {
coa->open = 0x00; coa->open = 0x00;
if (sender->GetClientVersion() >= ClientVersion::RoF) { if (sender->ClientVersion() >= EQEmu::versions::ClientVersion::RoF) {
coa->drop_id = 0xFFFFFFFF; coa->drop_id = 0xFFFFFFFF;
sender->Message(0, "Someone else is using that. Try again later."); sender->Message(0, "Someone else is using that. Try again later.");
} }

4
zone/perl_client.cpp
View File

@ -3974,7 +3974,7 @@ XS(XS_Client_GetClientVersion)
if(THIS == nullptr) if(THIS == nullptr)
Perl_croak(aTHX_ "THIS is nullptr, avoiding crash."); Perl_croak(aTHX_ "THIS is nullptr, avoiding crash.");
RETVAL = static_cast<unsigned int>(THIS->GetClientVersion()); RETVAL = static_cast<unsigned int>(THIS->ClientVersion());
XSprePUSH; PUSHu((UV)RETVAL); XSprePUSH; PUSHu((UV)RETVAL);
} }
XSRETURN(1); XSRETURN(1);
@ -4000,7 +4000,7 @@ XS(XS_Client_GetClientVersionBit)
if(THIS == nullptr) if(THIS == nullptr)
Perl_croak(aTHX_ "THIS is nullptr, avoiding crash."); Perl_croak(aTHX_ "THIS is nullptr, avoiding crash.");
RETVAL = THIS->GetClientVersionBit(); RETVAL = THIS->ClientVersionBit();
XSprePUSH; PUSHu((UV)RETVAL); XSprePUSH; PUSHu((UV)RETVAL);
} }
XSRETURN(1); XSRETURN(1);

2
zone/pets.cpp
View File

@ -475,7 +475,7 @@ void Pet::SetTarget(Mob *mob)
return; return;
auto owner = GetOwner(); auto owner = GetOwner();
if (owner && owner->IsClient() && owner->CastToClient()->GetClientVersionBit() & BIT_UFAndLater) { if (owner && owner->IsClient() && owner->CastToClient()->ClientVersionBit() & EQEmu::versions::bit_UFAndLater) {
auto app = new EQApplicationPacket(OP_PetHoTT, sizeof(ClientTarget_Struct)); auto app = new EQApplicationPacket(OP_PetHoTT, sizeof(ClientTarget_Struct));
auto ct = (ClientTarget_Struct *)app->pBuffer; auto ct = (ClientTarget_Struct *)app->pBuffer;
ct->new_target = mob ? mob->GetID() : 0; ct->new_target = mob ? mob->GetID() : 0;

4
zone/raids.cpp
View File

@ -1529,7 +1529,7 @@ void Raid::SendHPPacketsTo(Client *c)
{ {
members[x].member->CreateHPPacket(&hpapp); members[x].member->CreateHPPacket(&hpapp);
c->QueuePacket(&hpapp, false); c->QueuePacket(&hpapp, false);
if(c->GetClientVersion() >= ClientVersion::SoD) if (c->ClientVersion() >= EQEmu::versions::ClientVersion::SoD)
{ {
outapp.SetOpcode(OP_MobManaUpdate); outapp.SetOpcode(OP_MobManaUpdate);
MobManaUpdate_Struct *mmus = (MobManaUpdate_Struct *)outapp.pBuffer; MobManaUpdate_Struct *mmus = (MobManaUpdate_Struct *)outapp.pBuffer;
@ -1565,7 +1565,7 @@ void Raid::SendHPPacketsFrom(Mob *m)
if(!m->IsClient() || ((members[x].member != m->CastToClient()) && (members[x].GroupNumber == gid))) if(!m->IsClient() || ((members[x].member != m->CastToClient()) && (members[x].GroupNumber == gid)))
{ {
members[x].member->QueuePacket(&hpapp, false); members[x].member->QueuePacket(&hpapp, false);
if(members[x].member->GetClientVersion() >= ClientVersion::SoD) if (members[x].member->ClientVersion() >= EQEmu::versions::ClientVersion::SoD)
{ {
outapp.SetOpcode(OP_MobManaUpdate); outapp.SetOpcode(OP_MobManaUpdate);
MobManaUpdate_Struct *mmus = (MobManaUpdate_Struct *)outapp.pBuffer; MobManaUpdate_Struct *mmus = (MobManaUpdate_Struct *)outapp.pBuffer;

2
zone/special_attacks.cpp
View File

@ -182,7 +182,7 @@ void Client::OPCombatAbility(const EQApplicationPacket *app) {
pTimerType timer = pTimerCombatAbility; pTimerType timer = pTimerCombatAbility;
// RoF2+ Tiger Claw is unlinked from other monk skills, if they ever do that for other classes there will need // RoF2+ Tiger Claw is unlinked from other monk skills, if they ever do that for other classes there will need
// to be more checks here // to be more checks here
if (GetClientVersion() >= ClientVersion::RoF2 && ca_atk->m_skill == SkillTigerClaw) if (ClientVersion() >= EQEmu::versions::ClientVersion::RoF2 && ca_atk->m_skill == SkillTigerClaw)
timer = pTimerCombatAbility2; timer = pTimerCombatAbility2;
/* Check to see if actually have skill */ /* Check to see if actually have skill */

20
zone/spell_effects.cpp
View File

@ -135,7 +135,7 @@ bool Mob::SpellEffect(Mob* caster, uint16 spell_id, float partial, int level_ove
if (spells[spell_id].EndurUpkeep > 0) if (spells[spell_id].EndurUpkeep > 0)
SetEndurUpkeep(true); SetEndurUpkeep(true);
if(IsClient() && CastToClient()->GetClientVersionBit() & BIT_UFAndLater) if (IsClient() && CastToClient()->ClientVersionBit() & EQEmu::versions::bit_UFAndLater)
{ {
EQApplicationPacket *outapp = MakeBuffsPacket(false); EQApplicationPacket *outapp = MakeBuffsPacket(false);
CastToClient()->FastQueuePacket(&outapp); CastToClient()->FastQueuePacket(&outapp);
@ -818,7 +818,7 @@ bool Mob::SpellEffect(Mob* caster, uint16 spell_id, float partial, int level_ove
{ {
CastToClient()->SetSenseExemption(true); CastToClient()->SetSenseExemption(true);
if(CastToClient()->GetClientVersionBit() & BIT_SoDAndLater) if (CastToClient()->ClientVersionBit() & EQEmu::versions::bit_SoDAndLater)
{ {
bodyType bt = BT_Undead; bodyType bt = BT_Undead;
@ -1627,7 +1627,7 @@ bool Mob::SpellEffect(Mob* caster, uint16 spell_id, float partial, int level_ove
#endif #endif
// This is handled by the client prior to SoD. // This is handled by the client prior to SoD.
// //
if(IsClient() && (CastToClient()->GetClientVersionBit() & BIT_SoDAndLater)) if (IsClient() && (CastToClient()->ClientVersionBit() & EQEmu::versions::bit_SoDAndLater))
CastToClient()->LocateCorpse(); CastToClient()->LocateCorpse();
break; break;
@ -3374,7 +3374,7 @@ void Mob::BuffProcess()
Log.Out(Logs::Detail, Logs::Spells, "Buff %d in slot %d has %d tics remaining.", buffs[buffs_i].spellid, buffs_i, buffs[buffs_i].ticsremaining); Log.Out(Logs::Detail, Logs::Spells, "Buff %d in slot %d has %d tics remaining.", buffs[buffs_i].spellid, buffs_i, buffs[buffs_i].ticsremaining);
} }
} }
else if(IsClient() && !(CastToClient()->GetClientVersionBit() & BIT_SoFAndLater)) else if (IsClient() && !(CastToClient()->ClientVersionBit() & EQEmu::versions::bit_SoFAndLater))
{ {
buffs[buffs_i].UpdateClient = true; buffs[buffs_i].UpdateClient = true;
} }
@ -3386,7 +3386,7 @@ void Mob::BuffProcess()
{ {
CastToClient()->SendBuffDurationPacket(buffs[buffs_i]); CastToClient()->SendBuffDurationPacket(buffs[buffs_i]);
// Hack to get UF to play nicer, RoF seems fine without it // Hack to get UF to play nicer, RoF seems fine without it
if (CastToClient()->GetClientVersion() == ClientVersion::UF && buffs[buffs_i].numhits > 0) if (CastToClient()->ClientVersion() == EQEmu::versions::ClientVersion::UF && buffs[buffs_i].numhits > 0)
CastToClient()->SendBuffNumHitPacket(buffs[buffs_i], buffs_i); CastToClient()->SendBuffNumHitPacket(buffs[buffs_i], buffs_i);
buffs[buffs_i].UpdateClient = false; buffs[buffs_i].UpdateClient = false;
} }
@ -3649,7 +3649,7 @@ void Mob::DoBuffTic(const Buffs_Struct &buff, int slot, Mob *caster)
case SE_LocateCorpse: { case SE_LocateCorpse: {
// This is handled by the client prior to SoD. // This is handled by the client prior to SoD.
if (IsClient() && (CastToClient()->GetClientVersionBit() & BIT_SoDAndLater)) if (IsClient() && (CastToClient()->ClientVersionBit() & EQEmu::versions::bit_SoDAndLater))
CastToClient()->LocateCorpse(); CastToClient()->LocateCorpse();
} }
case SE_TotalHP: { case SE_TotalHP: {
@ -4113,7 +4113,7 @@ void Mob::BuffFadeBySlot(int slot, bool iRecalcBonuses)
{ {
EQApplicationPacket *outapp = MakeBuffsPacket(); EQApplicationPacket *outapp = MakeBuffsPacket();
entity_list.QueueClientsByTarget(this, outapp, false, nullptr, true, false, BIT_SoDAndLater); entity_list.QueueClientsByTarget(this, outapp, false, nullptr, true, false, EQEmu::versions::bit_SoDAndLater);
if(IsClient() && GetTarget() == this) { if(IsClient() && GetTarget() == this) {
CastToClient()->QueuePacket(outapp); CastToClient()->QueuePacket(outapp);
} }
@ -4123,11 +4123,11 @@ void Mob::BuffFadeBySlot(int slot, bool iRecalcBonuses)
if (IsNPC()) { if (IsNPC()) {
EQApplicationPacket *outapp = MakeBuffsPacket(); EQApplicationPacket *outapp = MakeBuffsPacket();
entity_list.QueueClientsByTarget(this, outapp, false, nullptr, true, false, BIT_SoDAndLater, true); entity_list.QueueClientsByTarget(this, outapp, false, nullptr, true, false, EQEmu::versions::bit_SoDAndLater, true);
safe_delete(outapp); safe_delete(outapp);
} }
if(IsClient() && CastToClient()->GetClientVersionBit() & BIT_UFAndLater) if (IsClient() && CastToClient()->ClientVersionBit() & EQEmu::versions::bit_UFAndLater)
{ {
EQApplicationPacket *outapp = MakeBuffsPacket(false); EQApplicationPacket *outapp = MakeBuffsPacket(false);
CastToClient()->FastQueuePacket(&outapp); CastToClient()->FastQueuePacket(&outapp);
@ -6574,7 +6574,7 @@ bool Mob::TrySpellProjectile(Mob* spell_target, uint16 spell_id, float speed){
if (spells[spell_id].resisttype == RESIST_FIRE) { if (spells[spell_id].resisttype == RESIST_FIRE) {
if (IsClient()){ if (IsClient()){
if (CastToClient()->GetClientVersionBit() <= 4) //Titanium needs alternate graphic. if (CastToClient()->ClientVersionBit() <= 4) //Titanium needs alternate graphic.
ProjectileAnimation(spell_target,(RuleI(Spells, FRProjectileItem_Titanium)), false, speed); ProjectileAnimation(spell_target,(RuleI(Spells, FRProjectileItem_Titanium)), false, speed);
else else
ProjectileAnimation(spell_target,(RuleI(Spells, FRProjectileItem_SOF)), false, speed); ProjectileAnimation(spell_target,(RuleI(Spells, FRProjectileItem_SOF)), false, speed);

16
zone/spells.cpp
View File

@ -259,7 +259,7 @@ bool Mob::CastSpell(uint16 spell_id, uint16 target_id, uint16 slot,
bitmask = bitmask << (CastToClient()->GetClass() - 1); bitmask = bitmask << (CastToClient()->GetClass() - 1);
if( itm && itm->GetItem()->Classes != 65535 ) { if( itm && itm->GetItem()->Classes != 65535 ) {
if ((itm->GetItem()->Click.Type == ET_EquipClick) && !(itm->GetItem()->Classes & bitmask)) { if ((itm->GetItem()->Click.Type == ET_EquipClick) && !(itm->GetItem()->Classes & bitmask)) {
if (CastToClient()->GetClientVersion() < ClientVersion::SoF) { if (CastToClient()->ClientVersion() < EQEmu::versions::ClientVersion::SoF) {
// They are casting a spell from an item that requires equipping but shouldn't let them equip it // They are casting a spell from an item that requires equipping but shouldn't let them equip it
Log.Out(Logs::General, Logs::Error, "HACKER: %s (account: %s) attempted to click an equip-only effect on item %s (id: %d) which they shouldn't be able to equip!", Log.Out(Logs::General, Logs::Error, "HACKER: %s (account: %s) attempted to click an equip-only effect on item %s (id: %d) which they shouldn't be able to equip!",
CastToClient()->GetCleanName(), CastToClient()->AccountName(), itm->GetItem()->Name, itm->GetItem()->ID); CastToClient()->GetCleanName(), CastToClient()->AccountName(), itm->GetItem()->Name, itm->GetItem()->ID);
@ -271,14 +271,14 @@ bool Mob::CastSpell(uint16 spell_id, uint16 target_id, uint16 slot,
return(false); return(false);
} }
if ((itm->GetItem()->Click.Type == ET_ClickEffect2) && !(itm->GetItem()->Classes & bitmask)) { if ((itm->GetItem()->Click.Type == ET_ClickEffect2) && !(itm->GetItem()->Classes & bitmask)) {
if (CastToClient()->GetClientVersion() < ClientVersion::SoF) { if (CastToClient()->ClientVersion() < EQEmu::versions::ClientVersion::SoF) {
// They are casting a spell from an item that they don't meet the race/class requirements to cast // They are casting a spell from an item that they don't meet the race/class requirements to cast
Log.Out(Logs::General, Logs::Error, "HACKER: %s (account: %s) attempted to click a race/class restricted effect on item %s (id: %d) which they shouldn't be able to click!", Log.Out(Logs::General, Logs::Error, "HACKER: %s (account: %s) attempted to click a race/class restricted effect on item %s (id: %d) which they shouldn't be able to click!",
CastToClient()->GetCleanName(), CastToClient()->AccountName(), itm->GetItem()->Name, itm->GetItem()->ID); CastToClient()->GetCleanName(), CastToClient()->AccountName(), itm->GetItem()->Name, itm->GetItem()->ID);
database.SetHackerFlag(CastToClient()->AccountName(), CastToClient()->GetCleanName(), "Clicking race/class restricted item with an invalid class"); database.SetHackerFlag(CastToClient()->AccountName(), CastToClient()->GetCleanName(), "Clicking race/class restricted item with an invalid class");
} }
else { else {
if (CastToClient()->GetClientVersion() >= ClientVersion::RoF) if (CastToClient()->ClientVersion() >= EQEmu::versions::ClientVersion::RoF)
{ {
// Line 181 in eqstr_us.txt was changed in RoF+ // Line 181 in eqstr_us.txt was changed in RoF+
Message(15, "Your race, class, or deity cannot use this item."); Message(15, "Your race, class, or deity cannot use this item.");
@ -292,7 +292,7 @@ bool Mob::CastSpell(uint16 spell_id, uint16 target_id, uint16 slot,
} }
} }
if( itm && (itm->GetItem()->Click.Type == ET_EquipClick) && !(item_slot <= SlotAmmo || item_slot == SlotPowerSource) ){ if( itm && (itm->GetItem()->Click.Type == ET_EquipClick) && !(item_slot <= SlotAmmo || item_slot == SlotPowerSource) ){
if (CastToClient()->GetClientVersion() < ClientVersion::SoF) { if (CastToClient()->ClientVersion() < EQEmu::versions::ClientVersion::SoF) {
// They are attempting to cast a must equip clicky without having it equipped // They are attempting to cast a must equip clicky without having it equipped
Log.Out(Logs::General, Logs::Error, "HACKER: %s (account: %s) attempted to click an equip-only effect on item %s (id: %d) without equiping it!", CastToClient()->GetCleanName(), CastToClient()->AccountName(), itm->GetItem()->Name, itm->GetItem()->ID); Log.Out(Logs::General, Logs::Error, "HACKER: %s (account: %s) attempted to click an equip-only effect on item %s (id: %d) without equiping it!", CastToClient()->GetCleanName(), CastToClient()->AccountName(), itm->GetItem()->Name, itm->GetItem()->ID);
database.SetHackerFlag(CastToClient()->AccountName(), CastToClient()->GetCleanName(), "Clicking equip-only item without equiping it"); database.SetHackerFlag(CastToClient()->AccountName(), CastToClient()->GetCleanName(), "Clicking equip-only item without equiping it");
@ -3246,7 +3246,7 @@ int Mob::AddBuff(Mob *caster, uint16 spell_id, int duration, int32 level_overrid
{ {
EQApplicationPacket *outapp = MakeBuffsPacket(); EQApplicationPacket *outapp = MakeBuffsPacket();
entity_list.QueueClientsByTarget(this, outapp, false, nullptr, true, false, BIT_SoDAndLater); entity_list.QueueClientsByTarget(this, outapp, false, nullptr, true, false, EQEmu::versions::bit_SoDAndLater);
if(IsClient() && GetTarget() == this) if(IsClient() && GetTarget() == this)
CastToClient()->QueuePacket(outapp); CastToClient()->QueuePacket(outapp);
@ -3256,7 +3256,7 @@ int Mob::AddBuff(Mob *caster, uint16 spell_id, int duration, int32 level_overrid
if (IsNPC()) { if (IsNPC()) {
EQApplicationPacket *outapp = MakeBuffsPacket(); EQApplicationPacket *outapp = MakeBuffsPacket();
entity_list.QueueClientsByTarget(this, outapp, false, nullptr, true, false, BIT_SoDAndLater, true); entity_list.QueueClientsByTarget(this, outapp, false, nullptr, true, false, EQEmu::versions::bit_SoDAndLater, true);
safe_delete(outapp); safe_delete(outapp);
} }
@ -5403,7 +5403,7 @@ void Client::SendBuffDurationPacket(Buffs_Struct &buff)
void Client::SendBuffNumHitPacket(Buffs_Struct &buff, int slot) void Client::SendBuffNumHitPacket(Buffs_Struct &buff, int slot)
{ {
// UF+ use this packet // UF+ use this packet
if (GetClientVersion() < ClientVersion::UF) if (ClientVersion() < EQEmu::versions::ClientVersion::UF)
return; return;
EQApplicationPacket *outapp; EQApplicationPacket *outapp;
outapp = new EQApplicationPacket(OP_BuffCreate, sizeof(BuffIcon_Struct) + sizeof(BuffIconEntry_Struct)); outapp = new EQApplicationPacket(OP_BuffCreate, sizeof(BuffIcon_Struct) + sizeof(BuffIconEntry_Struct));
@ -5457,7 +5457,7 @@ void Mob::SendBuffsToClient(Client *c)
if(!c) if(!c)
return; return;
if(c->GetClientVersionBit() & BIT_SoDAndLater) if (c->ClientVersionBit() & EQEmu::versions::bit_SoDAndLater)
{ {
EQApplicationPacket *outapp = MakeBuffsPacket(); EQApplicationPacket *outapp = MakeBuffsPacket();
c->FastQueuePacket(&outapp); c->FastQueuePacket(&outapp);

6
zone/tasks.cpp
View File

@ -990,7 +990,7 @@ void TaskManager::TaskSetSelector(Client *c, ClientTaskState *state, Mob *mob, i
void TaskManager::SendTaskSelector(Client *c, Mob *mob, int TaskCount, int *TaskList) { void TaskManager::SendTaskSelector(Client *c, Mob *mob, int TaskCount, int *TaskList) {
if (c->GetClientVersion() >= ClientVersion::RoF) if (c->ClientVersion() >= EQEmu::versions::ClientVersion::RoF)
{ {
SendTaskSelectorNew(c, mob, TaskCount, TaskList); SendTaskSelectorNew(c, mob, TaskCount, TaskList);
return; return;
@ -2485,7 +2485,7 @@ void TaskManager::SendTaskActivityShort(Client *c, int TaskID, int ActivityID, i
TaskActivityShort_Struct* tass; TaskActivityShort_Struct* tass;
if(c->GetClientVersionBit() & BIT_RoFAndLater) if (c->ClientVersionBit() & EQEmu::versions::bit_RoFAndLater)
{ {
EQApplicationPacket* outapp = new EQApplicationPacket(OP_TaskActivity, 25); EQApplicationPacket* outapp = new EQApplicationPacket(OP_TaskActivity, 25);
outapp->WriteUInt32(ClientTaskIndex); outapp->WriteUInt32(ClientTaskIndex);
@ -2521,7 +2521,7 @@ void TaskManager::SendTaskActivityShort(Client *c, int TaskID, int ActivityID, i
void TaskManager::SendTaskActivityLong(Client *c, int TaskID, int ActivityID, int ClientTaskIndex, bool Optional, bool TaskComplete) { void TaskManager::SendTaskActivityLong(Client *c, int TaskID, int ActivityID, int ClientTaskIndex, bool Optional, bool TaskComplete) {
if (c->GetClientVersion() >= ClientVersion::RoF) if (c->ClientVersion() >= EQEmu::versions::ClientVersion::RoF)
{ {
SendTaskActivityNew(c, TaskID, ActivityID, ClientTaskIndex, Optional, TaskComplete); SendTaskActivityNew(c, TaskID, ActivityID, ClientTaskIndex, Optional, TaskComplete);
return; return;

24
zone/trading.cpp
View File

@ -1098,7 +1098,7 @@ void Client::Trader_EndTrader() {
for(int i = 0; i < 80; i++) { for(int i = 0; i < 80; i++) {
if(gis->Items[i] != 0) { if(gis->Items[i] != 0) {
if (Customer->GetClientVersion() >= ClientVersion::RoF) if (Customer->ClientVersion() >= EQEmu::versions::ClientVersion::RoF)
{ {
// RoF+ use Item IDs for now // RoF+ use Item IDs for now
tdis->ItemID = gis->Items[i]; tdis->ItemID = gis->Items[i];
@ -1351,7 +1351,7 @@ void Client::NukeTraderItem(uint16 Slot,int16 Charges,uint16 Quantity,Client* Cu
tdis->Unknown000 = 0; tdis->Unknown000 = 0;
tdis->TraderID = Customer->GetID(); tdis->TraderID = Customer->GetID();
if (Customer->GetClientVersion() >= ClientVersion::RoF) if (Customer->ClientVersion() >= EQEmu::versions::ClientVersion::RoF)
{ {
// RoF+ use Item IDs for now // RoF+ use Item IDs for now
tdis->ItemID = itemid; tdis->ItemID = itemid;
@ -1487,7 +1487,7 @@ void Client::ReturnTraderReq(const EQApplicationPacket* app, int16 TraderItemCha
EQApplicationPacket* outapp = nullptr; EQApplicationPacket* outapp = nullptr;
if (GetClientVersion() >= ClientVersion::RoF) if (ClientVersion() >= EQEmu::versions::ClientVersion::RoF)
{ {
outapp = new EQApplicationPacket(OP_TraderShop, sizeof(TraderBuy_Struct)); outapp = new EQApplicationPacket(OP_TraderShop, sizeof(TraderBuy_Struct));
} }
@ -1499,7 +1499,7 @@ void Client::ReturnTraderReq(const EQApplicationPacket* app, int16 TraderItemCha
TraderBuy_Struct* outtbs = (TraderBuy_Struct*)outapp->pBuffer; TraderBuy_Struct* outtbs = (TraderBuy_Struct*)outapp->pBuffer;
memcpy(outtbs, tbs, app->size); memcpy(outtbs, tbs, app->size);
if (GetClientVersion() >= ClientVersion::RoF) if (ClientVersion() >= EQEmu::versions::ClientVersion::RoF)
{ {
// Convert Serial Number back to Item ID for RoF+ // Convert Serial Number back to Item ID for RoF+
outtbs->ItemID = itemid; outtbs->ItemID = itemid;
@ -1567,7 +1567,7 @@ void Client::BuyTraderItem(TraderBuy_Struct* tbs, Client* Trader, const EQApplic
const ItemInst* BuyItem = nullptr; const ItemInst* BuyItem = nullptr;
uint32 ItemID = 0; uint32 ItemID = 0;
if (GetClientVersion() >= ClientVersion::RoF) if (ClientVersion() >= EQEmu::versions::ClientVersion::RoF)
{ {
// Convert Item ID to Serial Number for RoF+ // Convert Item ID to Serial Number for RoF+
ItemID = tbs->ItemID; ItemID = tbs->ItemID;
@ -1629,7 +1629,7 @@ void Client::BuyTraderItem(TraderBuy_Struct* tbs, Client* Trader, const EQApplic
// This cannot overflow assuming MAX_TRANSACTION_VALUE, checked above, is the default of 2000000000 // This cannot overflow assuming MAX_TRANSACTION_VALUE, checked above, is the default of 2000000000
uint32 TotalCost = tbs->Price * outtbs->Quantity; uint32 TotalCost = tbs->Price * outtbs->Quantity;
if(Trader->GetClientVersion() >= ClientVersion::RoF) if (Trader->ClientVersion() >= EQEmu::versions::ClientVersion::RoF)
{ {
// RoF+ uses individual item price where older clients use total price // RoF+ uses individual item price where older clients use total price
outtbs->Price = tbs->Price; outtbs->Price = tbs->Price;
@ -1680,7 +1680,7 @@ void Client::BuyTraderItem(TraderBuy_Struct* tbs, Client* Trader, const EQApplic
Trader->FindAndNukeTraderItem(tbs->ItemID, outtbs->Quantity, this, 0); Trader->FindAndNukeTraderItem(tbs->ItemID, outtbs->Quantity, this, 0);
if (ItemID > 0 && Trader->GetClientVersion() >= ClientVersion::RoF) if (ItemID > 0 && Trader->ClientVersion() >= EQEmu::versions::ClientVersion::RoF)
{ {
// Convert Serial Number back to ItemID for RoF+ // Convert Serial Number back to ItemID for RoF+
outtbs->ItemID = ItemID; outtbs->ItemID = ItemID;
@ -1698,7 +1698,7 @@ void Client::SendBazaarWelcome()
auto row = results.begin(); auto row = results.begin();
EQApplicationPacket* outapp = nullptr; EQApplicationPacket* outapp = nullptr;
if (GetClientVersion() >= ClientVersion::RoF) if (ClientVersion() >= EQEmu::versions::ClientVersion::RoF)
{ {
outapp = new EQApplicationPacket(OP_TraderShop, sizeof(BazaarWelcome_Struct)); outapp = new EQApplicationPacket(OP_TraderShop, sizeof(BazaarWelcome_Struct));
} }
@ -1716,7 +1716,7 @@ void Client::SendBazaarWelcome()
bws->Traders = atoi(row[0]); bws->Traders = atoi(row[0]);
bws->Items = atoi(row[1]); bws->Items = atoi(row[1]);
if (GetClientVersion() >= ClientVersion::RoF) if (ClientVersion() >= EQEmu::versions::ClientVersion::RoF)
{ {
bws->Unknown012 = GetID(); bws->Unknown012 = GetID();
} }
@ -2091,7 +2091,7 @@ static void UpdateTraderCustomerPriceChanged(uint32 CustomerID, TraderCharges_St
for(int i = 0; i < 80; i++) { for(int i = 0; i < 80; i++) {
if(gis->ItemID[i] == ItemID) { if(gis->ItemID[i] == ItemID) {
if (Customer->GetClientVersion() >= ClientVersion::RoF) if (Customer->ClientVersion() >= EQEmu::versions::ClientVersion::RoF)
{ {
// RoF+ use Item IDs for now // RoF+ use Item IDs for now
tdis->ItemID = gis->ItemID[i]; tdis->ItemID = gis->ItemID[i];
@ -2745,7 +2745,7 @@ void Client::SellToBuyer(const EQApplicationPacket *app) {
VARSTRUCT_ENCODE_TYPE(uint32, Buf, Quantity); VARSTRUCT_ENCODE_TYPE(uint32, Buf, Quantity);
VARSTRUCT_ENCODE_TYPE(uint32, Buf, Quantity * Price); VARSTRUCT_ENCODE_TYPE(uint32, Buf, Quantity * Price);
if(GetClientVersion() >= ClientVersion::SoD) if (ClientVersion() >= EQEmu::versions::ClientVersion::SoD)
{ {
VARSTRUCT_ENCODE_TYPE(uint32, Buf, 0); // Think this is the upper 32 bits of a 64 bit price VARSTRUCT_ENCODE_TYPE(uint32, Buf, 0); // Think this is the upper 32 bits of a 64 bit price
} }
@ -2769,7 +2769,7 @@ void Client::SellToBuyer(const EQApplicationPacket *app) {
VARSTRUCT_ENCODE_TYPE(uint32, Buf, Quantity); VARSTRUCT_ENCODE_TYPE(uint32, Buf, Quantity);
VARSTRUCT_ENCODE_TYPE(uint32, Buf, Quantity * Price); VARSTRUCT_ENCODE_TYPE(uint32, Buf, Quantity * Price);
if(Buyer->GetClientVersion() >= ClientVersion::SoD) if (Buyer->ClientVersion() >= EQEmu::versions::ClientVersion::SoD)
{ {
VARSTRUCT_ENCODE_TYPE(uint32, Buf, 0); // Think this is the upper 32 bits of a 64 bit price VARSTRUCT_ENCODE_TYPE(uint32, Buf, 0); // Think this is the upper 32 bits of a 64 bit price
} }

2
zone/worldserver.cpp
View File

@ -864,7 +864,7 @@ void WorldServer::Process() {
database.SetGroupLeaderName(group->GetID(), Inviter->GetName()); database.SetGroupLeaderName(group->GetID(), Inviter->GetName());
group->UpdateGroupAAs(); group->UpdateGroupAAs();
if(Inviter->CastToClient()->GetClientVersion() < ClientVersion::SoD) if (Inviter->CastToClient()->ClientVersion() < EQEmu::versions::ClientVersion::SoD)
{ {
EQApplicationPacket* outapp=new EQApplicationPacket(OP_GroupUpdate,sizeof(GroupJoin_Struct)); EQApplicationPacket* outapp=new EQApplicationPacket(OP_GroupUpdate,sizeof(GroupJoin_Struct));
GroupJoin_Struct* outgj=(GroupJoin_Struct*)outapp->pBuffer; GroupJoin_Struct* outgj=(GroupJoin_Struct*)outapp->pBuffer;

4
zone/zone.cpp
View File

@ -1566,7 +1566,7 @@ ZonePoint* Zone::GetClosestZonePoint(const glm::vec3& location, uint32 to, Clien
while(iterator.MoreElements()) while(iterator.MoreElements())
{ {
ZonePoint* zp = iterator.GetData(); ZonePoint* zp = iterator.GetData();
uint32 mask_test = client->GetClientVersionBit(); uint32 mask_test = client->ClientVersionBit();
if(!(zp->client_version_mask & mask_test)) if(!(zp->client_version_mask & mask_test))
{ {
iterator.Advance(); iterator.Advance();
@ -1620,7 +1620,7 @@ ZonePoint* Zone::GetClosestZonePointWithoutZone(float x, float y, float z, Clien
while(iterator.MoreElements()) while(iterator.MoreElements())
{ {
ZonePoint* zp = iterator.GetData(); ZonePoint* zp = iterator.GetData();
uint32 mask_test = client->GetClientVersionBit(); uint32 mask_test = client->ClientVersionBit();
if(!(zp->client_version_mask & mask_test)) if(!(zp->client_version_mask & mask_test))
{ {

2
zone/zonedb.cpp
View File

@ -2823,7 +2823,7 @@ void ZoneDatabase::RefreshGroupFromDB(Client *client){
client->QueuePacket(outapp); client->QueuePacket(outapp);
safe_delete(outapp); safe_delete(outapp);
if(client->GetClientVersion() >= ClientVersion::SoD) { if (client->ClientVersion() >= EQEmu::versions::ClientVersion::SoD) {
group->NotifyMainTank(client, 1); group->NotifyMainTank(client, 1);
group->NotifyPuller(client, 1); group->NotifyPuller(client, 1);
} }

4
zone/zoning.cpp
View File

@ -562,7 +562,7 @@ void Client::ZonePC(uint32 zoneID, uint32 instance_id, float x, float y, float z
if (entity == 0) if (entity == 0)
{ {
Message(13, "Error: OP_EndLootRequest: Corpse not found (ent = 0)"); Message(13, "Error: OP_EndLootRequest: Corpse not found (ent = 0)");
if (GetClientVersion() >= ClientVersion::SoD) if (ClientVersion() >= EQEmu::versions::ClientVersion::SoD)
Corpse::SendEndLootErrorPacket(this); Corpse::SendEndLootErrorPacket(this);
else else
Corpse::SendLootReqErrorPacket(this); Corpse::SendLootReqErrorPacket(this);
@ -588,7 +588,7 @@ void Client::ZonePC(uint32 zoneID, uint32 instance_id, float x, float y, float z
// If we are SoF and later and are respawning from hover, we want the real zone ID, else zero to use the old hack. // If we are SoF and later and are respawning from hover, we want the real zone ID, else zero to use the old hack.
// //
if(zone->GetZoneID() == zoneID) { if(zone->GetZoneID() == zoneID) {
if((GetClientVersionBit() & BIT_SoFAndLater) && (!RuleB(Character, RespawnFromHover) || !IsHoveringForRespawn())) if ((ClientVersionBit() & EQEmu::versions::bit_SoFAndLater) && (!RuleB(Character, RespawnFromHover) || !IsHoveringForRespawn()))
gmg->bind_zone_id = 0; gmg->bind_zone_id = 0;
else else
gmg->bind_zone_id = zoneID; gmg->bind_zone_id = zoneID;