mirror of
https://github.com/EQEmu/Server.git
synced 2026-04-02 08:12:25 +00:00
7ab909ee47
- License was intended to be GPLv3 per earlier commit of GPLv3 LICENSE FILE - This is confirmed by the inclusion of libraries that are incompatible with GPLv2 - This is also confirmed by KLS and the agreement of KLS's predecessors - Added GPLv3 license headers to the compilable source files - Removed Folly licensing in strings.h since the string functions do not match the Folly functions and are standard functions - this must have been left over from previous implementations - Removed individual contributor license headers since the project has been under the "developer" mantle for many years - Removed comments on files that were previously automatically generated since they've been manually modified multiple times and there are no automatic scripts referencing them (removed in 2023)
557 lines
13 KiB
C++
557 lines
13 KiB
C++
/* EQEmu: EQEmulator
|
|
|
|
Copyright (C) 2001-2026 EQEmu Development Team
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
#include "common/emu_versions.h"
|
|
#include "common/emu_constants.h"
|
|
|
|
|
|
bool EQ::versions::IsValidClientVersion(ClientVersion client_version)
|
|
{
|
|
if (client_version <= ClientVersion::Unknown || client_version > LastClientVersion)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
EQ::versions::ClientVersion EQ::versions::ValidateClientVersion(ClientVersion client_version)
|
|
{
|
|
if (client_version <= ClientVersion::Unknown || client_version > LastClientVersion)
|
|
return ClientVersion::Unknown;
|
|
|
|
return client_version;
|
|
}
|
|
|
|
const char* EQ::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 EQ::versions::ConvertClientVersionToClientVersionBit(ClientVersion client_version)
|
|
{
|
|
switch (client_version) {
|
|
case ClientVersion::Titanium:
|
|
return bitTitanium;
|
|
case ClientVersion::SoF:
|
|
return bitSoF;
|
|
case ClientVersion::SoD:
|
|
return bitSoD;
|
|
case ClientVersion::UF:
|
|
return bitUF;
|
|
case ClientVersion::RoF:
|
|
return bitRoF;
|
|
case ClientVersion::RoF2:
|
|
return bitRoF2;
|
|
default:
|
|
return bitUnknown;
|
|
}
|
|
}
|
|
|
|
EQ::versions::ClientVersion EQ::versions::ConvertClientVersionBitToClientVersion(uint32 client_version_bit)
|
|
{
|
|
switch (client_version_bit) {
|
|
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;
|
|
}
|
|
}
|
|
|
|
bool EQ::versions::IsValidMobVersion(MobVersion mob_version)
|
|
{
|
|
if (mob_version <= MobVersion::Unknown || mob_version > LastMobVersion)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool EQ::versions::IsValidPCMobVersion(MobVersion mob_version)
|
|
{
|
|
if (mob_version <= MobVersion::Unknown || mob_version > LastPCMobVersion)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool EQ::versions::IsValidNonPCMobVersion(MobVersion mob_version)
|
|
{
|
|
if (mob_version <= LastPCMobVersion || mob_version > LastNonPCMobVersion)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool EQ::versions::IsValidOfflinePCMobVersion(MobVersion mob_version)
|
|
{
|
|
if (mob_version <= LastNonPCMobVersion || mob_version > LastOfflinePCMobVersion)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
EQ::versions::MobVersion EQ::versions::ValidateMobVersion(MobVersion mob_version)
|
|
{
|
|
if (mob_version <= MobVersion::Unknown || mob_version > LastMobVersion)
|
|
return MobVersion::Unknown;
|
|
|
|
return mob_version;
|
|
}
|
|
|
|
EQ::versions::MobVersion EQ::versions::ValidatePCMobVersion(MobVersion mob_version)
|
|
{
|
|
if (mob_version <= MobVersion::Unknown || mob_version > LastPCMobVersion)
|
|
return MobVersion::Unknown;
|
|
|
|
return mob_version;
|
|
}
|
|
|
|
EQ::versions::MobVersion EQ::versions::ValidateNonPCMobVersion(MobVersion mob_version)
|
|
{
|
|
if (mob_version <= LastPCMobVersion || mob_version > LastNonPCMobVersion)
|
|
return MobVersion::Unknown;
|
|
|
|
return mob_version;
|
|
}
|
|
|
|
EQ::versions::MobVersion EQ::versions::ValidateOfflinePCMobVersion(MobVersion mob_version)
|
|
{
|
|
if (mob_version <= LastNonPCMobVersion || mob_version > LastOfflinePCMobVersion)
|
|
return MobVersion::Unknown;
|
|
|
|
return mob_version;
|
|
}
|
|
|
|
const char* EQ::versions::MobVersionName(MobVersion mob_version)
|
|
{
|
|
switch (mob_version) {
|
|
case MobVersion::Unknown:
|
|
return "Unknown Version";
|
|
case MobVersion::Client62:
|
|
return "Client 6.2";
|
|
case MobVersion::Titanium:
|
|
return "Titanium";
|
|
case MobVersion::SoF:
|
|
return "SoF";
|
|
case MobVersion::SoD:
|
|
return "SoD";
|
|
case MobVersion::UF:
|
|
return "UF";
|
|
case MobVersion::RoF:
|
|
return "RoF";
|
|
case MobVersion::RoF2:
|
|
return "RoF2";
|
|
case MobVersion::NPC:
|
|
return "NPC";
|
|
case MobVersion::NPCMerchant:
|
|
return "NPC Merchant";
|
|
case MobVersion::Merc:
|
|
return "Merc";
|
|
case MobVersion::Bot:
|
|
return "Bot";
|
|
case MobVersion::ClientPet:
|
|
return "Client Pet";
|
|
case MobVersion::NPCPet:
|
|
return "NPC Pet";
|
|
case MobVersion::MercPet:
|
|
return "Merc Pet";
|
|
case MobVersion::BotPet:
|
|
return "Bot Pet";
|
|
case MobVersion::OfflineTitanium:
|
|
return "Offline Titanium";
|
|
case MobVersion::OfflineSoF:
|
|
return "Offline SoF";
|
|
case MobVersion::OfflineSoD:
|
|
return "Offline SoD";
|
|
case MobVersion::OfflineUF:
|
|
return "Offline UF";
|
|
case MobVersion::OfflineRoF:
|
|
return "Offline RoF";
|
|
case MobVersion::OfflineRoF2:
|
|
return "Offline RoF2";
|
|
default:
|
|
return "Invalid Version";
|
|
};
|
|
}
|
|
|
|
EQ::versions::ClientVersion EQ::versions::ConvertMobVersionToClientVersion(MobVersion mob_version)
|
|
{
|
|
switch (mob_version) {
|
|
case MobVersion::Unknown:
|
|
case MobVersion::Client62:
|
|
return ClientVersion::Unknown;
|
|
case MobVersion::Titanium:
|
|
return ClientVersion::Titanium;
|
|
case MobVersion::SoF:
|
|
return ClientVersion::SoF;
|
|
case MobVersion::SoD:
|
|
return ClientVersion::SoD;
|
|
case MobVersion::UF:
|
|
return ClientVersion::UF;
|
|
case MobVersion::RoF:
|
|
return ClientVersion::RoF;
|
|
case MobVersion::RoF2:
|
|
return ClientVersion::RoF2;
|
|
default:
|
|
return ClientVersion::Unknown;
|
|
}
|
|
}
|
|
|
|
EQ::versions::MobVersion EQ::versions::ConvertClientVersionToMobVersion(ClientVersion client_version)
|
|
{
|
|
switch (client_version) {
|
|
case ClientVersion::Unknown:
|
|
case ClientVersion::Client62:
|
|
return MobVersion::Unknown;
|
|
case ClientVersion::Titanium:
|
|
return MobVersion::Titanium;
|
|
case ClientVersion::SoF:
|
|
return MobVersion::SoF;
|
|
case ClientVersion::SoD:
|
|
return MobVersion::SoD;
|
|
case ClientVersion::UF:
|
|
return MobVersion::UF;
|
|
case ClientVersion::RoF:
|
|
return MobVersion::RoF;
|
|
case ClientVersion::RoF2:
|
|
return MobVersion::RoF2;
|
|
default:
|
|
return MobVersion::Unknown;
|
|
}
|
|
}
|
|
|
|
EQ::versions::MobVersion EQ::versions::ConvertPCMobVersionToOfflinePCMobVersion(MobVersion mob_version)
|
|
{
|
|
switch (mob_version) {
|
|
case MobVersion::Titanium:
|
|
return MobVersion::OfflineTitanium;
|
|
case MobVersion::SoF:
|
|
return MobVersion::OfflineSoF;
|
|
case MobVersion::SoD:
|
|
return MobVersion::OfflineSoD;
|
|
case MobVersion::UF:
|
|
return MobVersion::OfflineUF;
|
|
case MobVersion::RoF:
|
|
return MobVersion::OfflineRoF;
|
|
case MobVersion::RoF2:
|
|
return MobVersion::OfflineRoF2;
|
|
default:
|
|
return MobVersion::Unknown;
|
|
}
|
|
}
|
|
|
|
EQ::versions::MobVersion EQ::versions::ConvertOfflinePCMobVersionToPCMobVersion(MobVersion mob_version)
|
|
{
|
|
switch (mob_version) {
|
|
case MobVersion::OfflineTitanium:
|
|
return MobVersion::Titanium;
|
|
case MobVersion::OfflineSoF:
|
|
return MobVersion::SoF;
|
|
case MobVersion::OfflineSoD:
|
|
return MobVersion::SoD;
|
|
case MobVersion::OfflineUF:
|
|
return MobVersion::UF;
|
|
case MobVersion::OfflineRoF:
|
|
return MobVersion::RoF;
|
|
case MobVersion::OfflineRoF2:
|
|
return MobVersion::RoF2;
|
|
default:
|
|
return MobVersion::Unknown;
|
|
}
|
|
}
|
|
|
|
EQ::versions::ClientVersion EQ::versions::ConvertOfflinePCMobVersionToClientVersion(MobVersion mob_version)
|
|
{
|
|
switch (mob_version) {
|
|
case MobVersion::OfflineTitanium:
|
|
return ClientVersion::Titanium;
|
|
case MobVersion::OfflineSoF:
|
|
return ClientVersion::SoF;
|
|
case MobVersion::OfflineSoD:
|
|
return ClientVersion::SoD;
|
|
case MobVersion::OfflineUF:
|
|
return ClientVersion::UF;
|
|
case MobVersion::OfflineRoF:
|
|
return ClientVersion::RoF;
|
|
case MobVersion::OfflineRoF2:
|
|
return ClientVersion::RoF2;
|
|
default:
|
|
return ClientVersion::Unknown;
|
|
}
|
|
}
|
|
|
|
EQ::versions::MobVersion EQ::versions::ConvertClientVersionToOfflinePCMobVersion(ClientVersion client_version)
|
|
{
|
|
switch (client_version) {
|
|
case ClientVersion::Titanium:
|
|
return MobVersion::OfflineTitanium;
|
|
case ClientVersion::SoF:
|
|
return MobVersion::OfflineSoF;
|
|
case ClientVersion::SoD:
|
|
return MobVersion::OfflineSoD;
|
|
case ClientVersion::UF:
|
|
return MobVersion::OfflineUF;
|
|
case ClientVersion::RoF:
|
|
return MobVersion::OfflineRoF;
|
|
case ClientVersion::RoF2:
|
|
return MobVersion::OfflineRoF2;
|
|
default:
|
|
return MobVersion::Unknown;
|
|
}
|
|
}
|
|
|
|
const char* EQ::expansions::ExpansionName(Expansion expansion)
|
|
{
|
|
switch (expansion) {
|
|
case Expansion::EverQuest:
|
|
return "EverQuest";
|
|
case Expansion::RoK:
|
|
return "The Ruins of Kunark";
|
|
case Expansion::SoV:
|
|
return "The Scars of Velious";
|
|
case Expansion::SoL:
|
|
return "The Shadows of Luclin";
|
|
case Expansion::PoP:
|
|
return "The Planes of Power";
|
|
case Expansion::LoY:
|
|
return "The Legacy of Ykesha";
|
|
case Expansion::LDoN:
|
|
return "Lost Dungeons of Norrath";
|
|
case Expansion::GoD:
|
|
return "Gates of Discord";
|
|
case Expansion::OoW:
|
|
return "Omens of War";
|
|
case Expansion::DoN:
|
|
return "Dragons of Norrath";
|
|
case Expansion::DoD:
|
|
return "Depths of Darkhollow";
|
|
case Expansion::PoR:
|
|
return "Prophecy of Ro";
|
|
case Expansion::TSS:
|
|
return "The Serpent's Spine";
|
|
case Expansion::TBS:
|
|
return "The Buried Sea";
|
|
case Expansion::SoF:
|
|
return "Secrets of Faydwer";
|
|
case Expansion::SoD:
|
|
return "Seeds of Destruction";
|
|
case Expansion::UF:
|
|
return "Underfoot";
|
|
case Expansion::HoT:
|
|
return "House of Thule";
|
|
case Expansion::VoA:
|
|
return "Veil of Alaris";
|
|
case Expansion::RoF:
|
|
return "Rain of Fear";
|
|
case Expansion::CotF:
|
|
return "Call of the Forsaken";
|
|
default:
|
|
return "Invalid Expansion";
|
|
}
|
|
}
|
|
|
|
const char* EQ::expansions::ExpansionName(uint32 expansion_bit)
|
|
{
|
|
return ExpansionName(ConvertExpansionBitToExpansion(expansion_bit));
|
|
}
|
|
|
|
uint32 EQ::expansions::ConvertExpansionToExpansionBit(Expansion expansion)
|
|
{
|
|
switch (expansion) {
|
|
case Expansion::RoK:
|
|
return bitRoK;
|
|
case Expansion::SoV:
|
|
return bitSoV;
|
|
case Expansion::SoL:
|
|
return bitSoL;
|
|
case Expansion::PoP:
|
|
return bitPoP;
|
|
case Expansion::LoY:
|
|
return bitLoY;
|
|
case Expansion::LDoN:
|
|
return bitLDoN;
|
|
case Expansion::GoD:
|
|
return bitGoD;
|
|
case Expansion::OoW:
|
|
return bitOoW;
|
|
case Expansion::DoN:
|
|
return bitDoN;
|
|
case Expansion::DoD:
|
|
return bitDoD;
|
|
case Expansion::PoR:
|
|
return bitPoR;
|
|
case Expansion::TSS:
|
|
return bitTSS;
|
|
case Expansion::TBS:
|
|
return bitTBS;
|
|
case Expansion::SoF:
|
|
return bitSoF;
|
|
case Expansion::SoD:
|
|
return bitSoD;
|
|
case Expansion::UF:
|
|
return bitUF;
|
|
case Expansion::HoT:
|
|
return bitHoT;
|
|
case Expansion::VoA:
|
|
return bitVoA;
|
|
case Expansion::RoF:
|
|
return bitRoF;
|
|
case Expansion::CotF:
|
|
return bitCotF;
|
|
default:
|
|
return bitEverQuest;
|
|
}
|
|
}
|
|
|
|
EQ::expansions::Expansion EQ::expansions::ConvertExpansionBitToExpansion(uint32 expansion_bit)
|
|
{
|
|
switch (expansion_bit) {
|
|
case bitRoK:
|
|
return Expansion::RoK;
|
|
case bitSoV:
|
|
return Expansion::SoV;
|
|
case bitSoL:
|
|
return Expansion::SoL;
|
|
case bitPoP:
|
|
return Expansion::PoP;
|
|
case bitLoY:
|
|
return Expansion::LoY;
|
|
case bitLDoN:
|
|
return Expansion::LDoN;
|
|
case bitGoD:
|
|
return Expansion::GoD;
|
|
case bitOoW:
|
|
return Expansion::OoW;
|
|
case bitDoN:
|
|
return Expansion::DoN;
|
|
case bitDoD:
|
|
return Expansion::DoD;
|
|
case bitPoR:
|
|
return Expansion::PoR;
|
|
case bitTSS:
|
|
return Expansion::TSS;
|
|
case bitTBS:
|
|
return Expansion::TBS;
|
|
case bitSoF:
|
|
return Expansion::SoF;
|
|
case bitSoD:
|
|
return Expansion::SoD;
|
|
case bitUF:
|
|
return Expansion::UF;
|
|
case bitHoT:
|
|
return Expansion::HoT;
|
|
case bitVoA:
|
|
return Expansion::VoA;
|
|
case bitRoF:
|
|
return Expansion::RoF;
|
|
case bitCotF:
|
|
return Expansion::CotF;
|
|
default:
|
|
return Expansion::EverQuest;
|
|
}
|
|
}
|
|
|
|
uint32 EQ::expansions::ConvertExpansionToExpansionsMask(Expansion expansion)
|
|
{
|
|
switch (expansion) {
|
|
case Expansion::RoK:
|
|
return maskRoK;
|
|
case Expansion::SoV:
|
|
return maskSoV;
|
|
case Expansion::SoL:
|
|
return maskSoL;
|
|
case Expansion::PoP:
|
|
return maskPoP;
|
|
case Expansion::LoY:
|
|
return maskLoY;
|
|
case Expansion::LDoN:
|
|
return maskLDoN;
|
|
case Expansion::GoD:
|
|
return maskGoD;
|
|
case Expansion::OoW:
|
|
return maskOoW;
|
|
case Expansion::DoN:
|
|
return maskDoN;
|
|
case Expansion::DoD:
|
|
return maskDoD;
|
|
case Expansion::PoR:
|
|
return maskPoR;
|
|
case Expansion::TSS:
|
|
return maskTSS;
|
|
case Expansion::TBS:
|
|
return maskTBS;
|
|
case Expansion::SoF:
|
|
return maskSoF;
|
|
case Expansion::SoD:
|
|
return maskSoD;
|
|
case Expansion::UF:
|
|
return maskUF;
|
|
case Expansion::HoT:
|
|
return maskHoT;
|
|
case Expansion::VoA:
|
|
return maskVoA;
|
|
case Expansion::RoF:
|
|
return maskRoF;
|
|
case Expansion::CotF:
|
|
return maskCotF;
|
|
default:
|
|
return maskEverQuest;
|
|
}
|
|
}
|
|
|
|
EQ::expansions::Expansion EQ::expansions::ConvertClientVersionToExpansion(versions::ClientVersion client_version)
|
|
{
|
|
return EQ::constants::StaticLookup(client_version)->Expansion;
|
|
}
|
|
|
|
uint32 EQ::expansions::ConvertClientVersionToExpansionBit(versions::ClientVersion client_version)
|
|
{
|
|
return EQ::constants::StaticLookup(client_version)->ExpansionBit;
|
|
}
|
|
|
|
uint32 EQ::expansions::ConvertClientVersionToExpansionsMask(versions::ClientVersion client_version)
|
|
{
|
|
return EQ::constants::StaticLookup(client_version)->ExpansionsMask;
|
|
}
|