diff --git a/common/emu_versions.cpp b/common/emu_versions.cpp index ea8ddba73..ebde39ddf 100644 --- a/common/emu_versions.cpp +++ b/common/emu_versions.cpp @@ -56,6 +56,8 @@ const char* EQ::versions::ClientVersionName(ClientVersion client_version) return "RoF"; case ClientVersion::RoF2: return "RoF2"; + case ClientVersion::Larion: + return "Larion"; default: return "Invalid Version"; }; @@ -76,6 +78,8 @@ uint32 EQ::versions::ConvertClientVersionToClientVersionBit(ClientVersion client return bitRoF; case ClientVersion::RoF2: return bitRoF2; + case ClientVersion::Larion: + return bitLarion; default: return bitUnknown; } @@ -96,6 +100,8 @@ EQ::versions::ClientVersion EQ::versions::ConvertClientVersionBitToClientVersion return ClientVersion::RoF; case ((uint32)1 << (static_cast(ClientVersion::RoF2) - 1)) : return ClientVersion::RoF2; + case ((uint32)1 << (static_cast(ClientVersion::Larion) - 1)): + return ClientVersion::Larion; default: return ClientVersion::Unknown; } @@ -184,6 +190,8 @@ const char* EQ::versions::MobVersionName(MobVersion mob_version) return "RoF"; case MobVersion::RoF2: return "RoF2"; + case MobVersion::Larion: + return "Larion"; case MobVersion::NPC: return "NPC"; case MobVersion::NPCMerchant: @@ -212,6 +220,8 @@ const char* EQ::versions::MobVersionName(MobVersion mob_version) return "Offline RoF"; case MobVersion::OfflineRoF2: return "Offline RoF2"; + case MobVersion::OfflineLarion: + return "Offline Larion"; default: return "Invalid Version"; }; @@ -235,6 +245,8 @@ EQ::versions::ClientVersion EQ::versions::ConvertMobVersionToClientVersion(MobVe return ClientVersion::RoF; case MobVersion::RoF2: return ClientVersion::RoF2; + case MobVersion::Larion: + return ClientVersion::Larion; default: return ClientVersion::Unknown; } @@ -258,6 +270,8 @@ EQ::versions::MobVersion EQ::versions::ConvertClientVersionToMobVersion(ClientVe return MobVersion::RoF; case ClientVersion::RoF2: return MobVersion::RoF2; + case ClientVersion::Larion: + return MobVersion::Larion; default: return MobVersion::Unknown; } @@ -278,6 +292,8 @@ EQ::versions::MobVersion EQ::versions::ConvertPCMobVersionToOfflinePCMobVersion( return MobVersion::OfflineRoF; case MobVersion::RoF2: return MobVersion::OfflineRoF2; + case MobVersion::Larion: + return MobVersion::OfflineLarion; default: return MobVersion::Unknown; } @@ -298,6 +314,8 @@ EQ::versions::MobVersion EQ::versions::ConvertOfflinePCMobVersionToPCMobVersion( return MobVersion::RoF; case MobVersion::OfflineRoF2: return MobVersion::RoF2; + case MobVersion::OfflineLarion: + return MobVersion::Larion; default: return MobVersion::Unknown; } @@ -318,6 +336,8 @@ EQ::versions::ClientVersion EQ::versions::ConvertOfflinePCMobVersionToClientVers return ClientVersion::RoF; case MobVersion::OfflineRoF2: return ClientVersion::RoF2; + case MobVersion::OfflineLarion: + return ClientVersion::Larion; default: return ClientVersion::Unknown; } @@ -338,6 +358,8 @@ EQ::versions::MobVersion EQ::versions::ConvertClientVersionToOfflinePCMobVersion return MobVersion::OfflineRoF; case ClientVersion::RoF2: return MobVersion::OfflineRoF2; + case ClientVersion::Larion: + return MobVersion::OfflineLarion; default: return MobVersion::Unknown; } @@ -388,6 +410,27 @@ const char* EQ::expansions::ExpansionName(Expansion expansion) return "Rain of Fear"; case Expansion::CotF: return "Call of the Forsaken"; + case Expansion::TDS: + return "The Darkened Sea"; + case Expansion::TBM: + return "The Broken Mirror"; + case Expansion::EoK: + return "Empires of Kunark"; + case Expansion::RoS: + return "Ring of Scale"; + case Expansion::TBL: + return "The Burning Lands"; + case Expansion::ToV: + return "Torment of Velious"; + case Expansion::CoV: + return "Claws of Veeshan"; + case Expansion::ToL: + return "Terror of Luclin"; + case Expansion::NoS: + return "Night of Shadows"; + case Expansion::LS: + return "Laurion's Song"; + default: return "Invalid Expansion"; } @@ -441,6 +484,26 @@ uint32 EQ::expansions::ConvertExpansionToExpansionBit(Expansion expansion) return bitRoF; case Expansion::CotF: return bitCotF; + case Expansion::TDS: + return bitTDS; + case Expansion::TBM: + return bitTBM; + case Expansion::EoK: + return bitEoK; + case Expansion::RoS: + return bitRoS; + case Expansion::TBL: + return bitTBL; + case Expansion::ToV: + return bitToV; + case Expansion::CoV: + return bitCoV; + case Expansion::ToL: + return bitToL; + case Expansion::NoS: + return bitNoS; + case Expansion::LS: + return bitLS; default: return bitEverQuest; } @@ -489,6 +552,26 @@ EQ::expansions::Expansion EQ::expansions::ConvertExpansionBitToExpansion(uint32 return Expansion::RoF; case bitCotF: return Expansion::CotF; + case bitTDS: + return Expansion::TDS; + case bitTBM: + return Expansion::TBM; + case bitEoK: + return Expansion::EoK; + case bitRoS: + return Expansion::RoS; + case bitTBL: + return Expansion::TBL; + case bitToV: + return Expansion::ToV; + case bitCoV: + return Expansion::CoV; + case bitToL: + return Expansion::ToL; + case bitNoS: + return Expansion::NoS; + case bitLS: + return Expansion::LS; default: return Expansion::EverQuest; } @@ -537,6 +620,26 @@ uint32 EQ::expansions::ConvertExpansionToExpansionsMask(Expansion expansion) return maskRoF; case Expansion::CotF: return maskCotF; + case Expansion::TDS: + return maskTDS; + case Expansion::TBM: + return maskTBM; + case Expansion::EoK: + return maskEoK; + case Expansion::RoS: + return maskRoS; + case Expansion::TBL: + return maskTBL; + case Expansion::ToV: + return maskToV; + case Expansion::CoV: + return maskCoV; + case Expansion::ToL: + return maskToL; + case Expansion::NoS: + return maskNoS; + case Expansion::LS: + return maskLS; default: return maskEverQuest; } diff --git a/common/emu_versions.h b/common/emu_versions.h index 16315cf3f..4c36ce39c 100644 --- a/common/emu_versions.h +++ b/common/emu_versions.h @@ -49,6 +49,7 @@ namespace EQ bitUF = 0x00000010, bitRoF = 0x00000020, bitRoF2 = 0x00000040, + bitLarion = 0x00000080, maskUnknown = 0x00000000, maskTitaniumAndEarlier = 0x00000003, maskSoFAndEarlier = 0x00000007, @@ -60,6 +61,7 @@ namespace EQ maskUFAndLater = 0xFFFFFFF0, maskRoFAndLater = 0xFFFFFFE0, maskRoF2AndLater = 0xFFFFFFC0, + maskLarionAndLater = 0xFFFFFF80, maskAllClients = 0xFFFFFFFF }; @@ -81,6 +83,7 @@ namespace EQ UF, RoF, RoF2, + Larion, NPC, NPCMerchant, Merc, @@ -94,13 +97,14 @@ namespace EQ OfflineSoD, OfflineUF, OfflineRoF, - OfflineRoF2 + OfflineRoF2, + OfflineLarion }; - const MobVersion LastMobVersion = MobVersion::OfflineRoF2; - const MobVersion LastPCMobVersion = MobVersion::RoF2; + const MobVersion LastMobVersion = MobVersion::OfflineLarion; + const MobVersion LastPCMobVersion = MobVersion::Larion; const MobVersion LastNonPCMobVersion = MobVersion::BotPet; - const MobVersion LastOfflinePCMobVersion = MobVersion::OfflineRoF2; + const MobVersion LastOfflinePCMobVersion = MobVersion::OfflineLarion; const size_t MobVersionCount = (static_cast(LastMobVersion) + 1); bool IsValidMobVersion(MobVersion mob_version); @@ -132,7 +136,8 @@ namespace EQ ucsSoDCombined = 'D', ucsUFCombined = 'E', ucsRoFCombined = 'F', - ucsRoF2Combined = 'G' + ucsRoF2Combined = 'G', + ucsLaurionCombined = 'G' }; } /*versions*/ @@ -159,7 +164,17 @@ namespace EQ HoT, VoA, RoF, - CotF + CotF, + TDS, + TBM, + EoK, + RoS, + TBL, + ToV, + CoV, + ToL, + NoS, + LS }; enum ExpansionBitmask : uint32 { @@ -184,6 +199,16 @@ namespace EQ bitVoA = 0x00020000, bitRoF = 0x00040000, bitCotF = 0x00080000, + bitTDS = 0x00100000, + bitTBM = 0x00200000, + bitEoK = 0x00400000, + bitRoS = 0x00800000, + bitTBL = 0x01000000, + bitToV = 0x02000000, + bitCoV = 0x04000000, + bitToL = 0x08000000, + bitNoS = 0x10000000, + bitLS = 0x20000000, maskEverQuest = 0x00000000, maskRoK = 0x00000001, maskSoV = 0x00000003, @@ -204,7 +229,17 @@ namespace EQ maskHoT = 0x0001FFFF, maskVoA = 0x0003FFFF, maskRoF = 0x0007FFFF, - maskCotF = 0x000FFFFF + maskCotF = 0x000FFFFF, + maskTDS = 0x001FFFFF, + maskTBM = 0x003FFFFF, + maskEoK = 0x007FFFFF, + maskRoS = 0x00FFFFFF, + maskTBL = 0x01FFFFFF, + maskToV = 0x03FFFFFF, + maskCoV = 0x07FFFFFF, + maskToL = 0x0FFFFFFF, + maskNoS = 0x1FFFFFFF, + maskLS = 0x3FFFFFFF, }; const char* ExpansionName(Expansion expansion); diff --git a/common/eq_limits.cpp b/common/eq_limits.cpp index 051857681..14486b4f0 100644 --- a/common/eq_limits.cpp +++ b/common/eq_limits.cpp @@ -370,6 +370,33 @@ static const EQ::inventory::LookupEntry inventory_static_lookup_entries[EQ::vers RoF2::inventory::ConcatenateInvTypeLimbo, RoF2::inventory::AllowOverLevelEquipment ), + /*[MobVersion::LS] =*/ + EQ::inventory::LookupEntry( + EQ::inventory::LookupEntry::InventoryTypeSize_Struct( + EQ::invtype::POSSESSIONS_SIZE, RoF2::invtype::BANK_SIZE, RoF2::invtype::SHARED_BANK_SIZE, + RoF2::invtype::TRADE_SIZE, RoF2::invtype::WORLD_SIZE, RoF2::invtype::LIMBO_SIZE, + RoF2::invtype::TRIBUTE_SIZE, RoF2::invtype::TROPHY_TRIBUTE_SIZE, RoF2::invtype::GUILD_TRIBUTE_SIZE, + RoF2::invtype::MERCHANT_SIZE, RoF2::invtype::DELETED_SIZE, RoF2::invtype::CORPSE_SIZE, + RoF2::invtype::BAZAAR_SIZE, RoF2::invtype::INSPECT_SIZE, RoF2::invtype::REAL_ESTATE_SIZE, + RoF2::invtype::VIEW_MOD_PC_SIZE, RoF2::invtype::VIEW_MOD_BANK_SIZE, RoF2::invtype::VIEW_MOD_SHARED_BANK_SIZE, + RoF2::invtype::VIEW_MOD_LIMBO_SIZE, RoF2::invtype::ALT_STORAGE_SIZE, RoF2::invtype::ARCHIVED_SIZE, + RoF2::invtype::MAIL_SIZE, RoF2::invtype::GUILD_TROPHY_TRIBUTE_SIZE, RoF2::invtype::KRONO_SIZE, + RoF2::invtype::OTHER_SIZE + ), + + RoF2::invslot::EQUIPMENT_BITMASK, + RoF2::invslot::GENERAL_BITMASK, + RoF2::invslot::CURSOR_BITMASK, + RoF2::invslot::POSSESSIONS_BITMASK, + RoF2::invslot::CORPSE_BITMASK, + RoF2::invbag::SLOT_COUNT, + RoF2::invaug::SOCKET_COUNT, + + RoF2::inventory::AllowEmptyBagInBag, + RoF2::inventory::AllowClickCastFromBag, + RoF2::inventory::ConcatenateInvTypeLimbo, + RoF2::inventory::AllowOverLevelEquipment + ), /*[MobVersion::NPC] =*/ EQ::inventory::LookupEntry( EQ::inventory::LookupEntry::InventoryTypeSize_Struct( @@ -743,6 +770,33 @@ static const EQ::inventory::LookupEntry inventory_static_lookup_entries[EQ::vers RoF2::invbag::SLOT_COUNT, RoF2::invaug::SOCKET_COUNT, + false, + false, + false, + false + ), + /*[MobVersion::OfflineLS] =*/ + EQ::inventory::LookupEntry( + EQ::inventory::LookupEntry::InventoryTypeSize_Struct( + RoF2::INULL, RoF2::INULL, RoF2::INULL, + RoF2::invtype::TRADE_SIZE, RoF2::INULL, RoF2::INULL, + RoF2::INULL, RoF2::INULL, RoF2::INULL, + RoF2::invtype::MERCHANT_SIZE, RoF2::INULL, RoF2::INULL, + RoF2::invtype::BAZAAR_SIZE, RoF2::invtype::INSPECT_SIZE, RoF2::INULL, + RoF2::invtype::VIEW_MOD_PC_SIZE, RoF2::invtype::VIEW_MOD_BANK_SIZE, RoF2::invtype::VIEW_MOD_SHARED_BANK_SIZE, + RoF2::invtype::VIEW_MOD_LIMBO_SIZE, RoF2::INULL, RoF2::INULL, + RoF2::INULL, RoF2::INULL, RoF2::INULL, + RoF2::INULL + ), + + RoF2::INULL, + RoF2::INULL, + RoF2::INULL, + RoF2::INULL, + RoF2::INULL, + RoF2::invbag::SLOT_COUNT, + RoF2::invaug::SOCKET_COUNT, + false, false, false, @@ -994,6 +1048,10 @@ static const EQ::behavior::LookupEntry behavior_static_lookup_entries[EQ::versio EQ::behavior::LookupEntry( RoF2::behavior::CoinHasWeight ), + /*[MobVersion::LS] =*/ + EQ::behavior::LookupEntry( + RoF2::behavior::CoinHasWeight + ), /*[MobVersion::NPC] =*/ EQ::behavior::LookupEntry( EQ::behavior::CoinHasWeight @@ -1047,6 +1105,10 @@ static const EQ::behavior::LookupEntry behavior_static_lookup_entries[EQ::versio RoF::behavior::CoinHasWeight ), /*[MobVersion::OfflineRoF2] =*/ + EQ::behavior::LookupEntry( + RoF2::behavior::CoinHasWeight + ), + /*[MobVersion::OfflineLS] =*/ EQ::behavior::LookupEntry( RoF2::behavior::CoinHasWeight ) diff --git a/common/eq_limits.h b/common/eq_limits.h index 40b095b15..e1e20aec6 100644 --- a/common/eq_limits.h +++ b/common/eq_limits.h @@ -29,7 +29,7 @@ #include "../common/patches/uf_limits.h" #include "../common/patches/rof_limits.h" #include "../common/patches/rof2_limits.h" - +#include "../common/patches/larion_limits.h" namespace EQ { diff --git a/common/patches/larion.cpp b/common/patches/larion.cpp index 6997b7a7f..9b49c961b 100644 --- a/common/patches/larion.cpp +++ b/common/patches/larion.cpp @@ -126,94 +126,89 @@ namespace Larion // ENCODE methods ENCODE(OP_LogServer) { - EQApplicationPacket* in = *p; - *p = nullptr; - LogServer_Struct* emu = (LogServer_Struct*)in->pBuffer; - - auto outapp = new EQApplicationPacket(OP_LogServer, 1840); - auto buffer = outapp->pBuffer; + SETUP_VAR_ENCODE(LogServer_Struct); + ALLOC_LEN_ENCODE(1840); //pvp if (emu->enable_pvp) { - *(char*)&buffer[0x04] = 1; + *(char*)&__packet->pBuffer[0x04] = 1; } if (emu->enable_FV) { //FV sets these both to 1 //one appears to enable the no drop flag the other just marks the server as special? - *(char*)&buffer[0x08] = 1; - *(char*)&buffer[0x0a] = 1; + *(char*)&__packet->pBuffer[0x08] = 1; + *(char*)&__packet->pBuffer[0x0a] = 1; } //This has something to do with heirloom and prestige items but im not sure what it does //Seems to sit at 0 - *(char*)&buffer[0x71d] = 0; + *(char*)&__packet->pBuffer[0x71d] = 0; //not sure what this does, something to do with server select - *(char*)&buffer[0x09] = 0; + *(char*)&__packet->pBuffer[0x09] = 0; //this appears to have some effect on the tradeskill system; disabling made by tags perhaps? - *(char*)&buffer[0x0b] = 0; + *(char*)&__packet->pBuffer[0x0b] = 0; //not sure, setting it to the value ive seen - *(char*)&buffer[0x0c] = 1; + *(char*)&__packet->pBuffer[0x0c] = 1; //Something to do with languages - *(char*)&buffer[0x0d] = 1; + *(char*)&__packet->pBuffer[0x0d] = 1; //These seem to affect if server has betabuff enabled - *(char*)&buffer[0x5c0] = 0; - *(char*)&buffer[0x5c1] = 0; + *(char*)&__packet->pBuffer[0x5c0] = 0; + *(char*)&__packet->pBuffer[0x5c1] = 0; //This is set on test so it's probably indicating this is a test server - *(char*)&buffer[0x5c2] = 0; + *(char*)&__packet->pBuffer[0x5c2] = 0; //not sure, but it's grouped with the beta and test stuff - *(char*)&buffer[0x5c3] = 0; + *(char*)&__packet->pBuffer[0x5c3] = 0; //world short name - strncpy((char*)&buffer[0x15], emu->worldshortname, 32); + strncpy((char*)&__packet->pBuffer[0x15], emu->worldshortname, 32); //not sure, affects some player calculation but didn't care to look more - *(char*)&buffer[0x5c2] = 0; + *(char*)&__packet->pBuffer[0x5c2] = 0; //Looks right if (emu->enablemail) { - *(char*)&buffer[0x5b5] = 1; + *(char*)&__packet->pBuffer[0x5b5] = 1; } //Looks right if (emu->enablevoicemacros) { - *(char*)&buffer[0x5b4] = 1; + *(char*)&__packet->pBuffer[0x5b4] = 1; } //Not sure, sending what we've seen - *(char*)&buffer[0x5b6] = 0; + *(char*)&__packet->pBuffer[0x5b6] = 0; //Not sure sending what we've seen - *(char*)&buffer[0x5b8] = 1; + *(char*)&__packet->pBuffer[0x5b8] = 1; //Not sure sending what we've seen - *(int32_t*)&buffer[0x5fc] = -1; + *(int32_t*)&__packet->pBuffer[0x5fc] = -1; //Test sets this to 1, everyone else seems to set it to 0 - *(int32_t*)&buffer[0x600] = 0; + *(int32_t*)&__packet->pBuffer[0x600] = 0; //Disassembly puts it next to code dealing with commands, ive not seen anyone send anything but 0 - *(char*)&buffer[0x705] = 0; + *(char*)&__packet->pBuffer[0x705] = 0; //Something about item restrictions, seems to always be set to 1 - *(char*)&buffer[0x710] = 0; + *(char*)&__packet->pBuffer[0x710] = 0; //This and 0x724 are often multiplied together in guild favor calcs, live and test send 1.0f - *(float*)&buffer[0x720] = 1.0f; - *(float*)&buffer[0x724] = 1.0f; + *(float*)&__packet->pBuffer[0x720] = 1.0f; + *(float*)&__packet->pBuffer[0x724] = 1.0f; //This and 0x72c are often multiplied together in non-guild favor calcs, live and test send 1.0f - *(float*)&buffer[0x728] = 1.0f; - *(float*)&buffer[0x72c] = 1.0f; + *(float*)&__packet->pBuffer[0x728] = 1.0f; + *(float*)&__packet->pBuffer[0x72c] = 1.0f; - dest->FastQueuePacket(&outapp); - safe_delete(in); + FINISH_ENCODE(); } ENCODE(OP_SendMembership) { @@ -224,31 +219,31 @@ namespace Larion eq->races = emu->races; eq->classes = emu->classes; eq->entrysize = 33; - eq->entries[0] = -1; - eq->entries[1] = -1; - eq->entries[2] = -1; - eq->entries[3] = -1; - eq->entries[4] = -1; - eq->entries[5] = -1; - eq->entries[6] = 1; - eq->entries[7] = 1; - eq->entries[8] = 1; - eq->entries[9] = -1; - eq->entries[10] = 1; - eq->entries[11] = -1; - eq->entries[12] = -1; - eq->entries[13] = 1; - eq->entries[14] = 1; - eq->entries[15] = 1; - eq->entries[16] = 1; - eq->entries[17] = 1; - eq->entries[18] = 1; - eq->entries[19] = -1; - eq->entries[20] = -1; + eq->entries[0] = -1; // Max AA Restriction + eq->entries[1] = -1; // Max Level Restriction + eq->entries[2] = -1; // Max Char Slots per Account (not used by client?) + eq->entries[3] = -1; // 1 for Silver + eq->entries[4] = -1; // Main Inventory Size + eq->entries[5] = -1; // Max Platinum per level + eq->entries[6] = 1; // Send Mail + eq->entries[7] = 1; // Use Parcels? + eq->entries[8] = 1; // Voice Chat + eq->entries[9] = -1; // Merc Tiers + eq->entries[10] = 1; // Create Guilds + eq->entries[11] = -1; // Shared Bank Slots + eq->entries[12] = -1; // Max Journal Quests + eq->entries[13] = 1; // Housing Enabled + eq->entries[14] = 1; // Prestiege + eq->entries[15] = 1; // Broker System + eq->entries[16] = 1; // Chat + eq->entries[17] = 1; // Progression Server Access + eq->entries[18] = 1; // Customer Support + eq->entries[19] = -1; // Popup reminders? + eq->entries[20] = -1; // Exit Popup? eq->entries[21] = 0; eq->entries[22] = 0; - eq->entries[23] = 0; - eq->entries[24] = 0; + eq->entries[23] = 0; // This is the highest we actually see in detail entries + eq->entries[24] = 0; eq->entries[25] = 0; eq->entries[26] = 0; eq->entries[27] = 0; @@ -262,7 +257,538 @@ namespace Larion } ENCODE(OP_SendMembershipDetails) { + SETUP_VAR_ENCODE(Membership_Details_Struct); + SerializeBuffer buffer; + // Generated via script; we should put this in a better format later + // count + buffer.WriteUInt32(96); + + // settings + buffer.WriteUInt8(0); + buffer.WriteUInt32(0); + buffer.WriteInt32(250); + + buffer.WriteUInt8(1); + buffer.WriteUInt32(0); + buffer.WriteInt32(1000); + + buffer.WriteUInt8(0); + buffer.WriteUInt32(1); + buffer.WriteInt32(-1); + + buffer.WriteUInt8(1); + buffer.WriteUInt32(1); + buffer.WriteInt32(-1); + + buffer.WriteUInt8(0); + buffer.WriteUInt32(2); + buffer.WriteInt32(2); + + buffer.WriteUInt8(2); + buffer.WriteUInt32(0); + buffer.WriteInt32(-1); + + buffer.WriteUInt8(3); + buffer.WriteUInt32(0); + buffer.WriteInt32(-1); + + buffer.WriteUInt8(1); + buffer.WriteUInt32(2); + buffer.WriteInt32(4); + + buffer.WriteUInt8(0); + buffer.WriteUInt32(3); + buffer.WriteInt32(1); + + buffer.WriteUInt8(2); + buffer.WriteUInt32(1); + buffer.WriteInt32(-1); + + buffer.WriteUInt8(3); + buffer.WriteUInt32(1); + buffer.WriteInt32(-1); + + buffer.WriteUInt8(1); + buffer.WriteUInt32(3); + buffer.WriteInt32(1); + + buffer.WriteUInt8(0); + buffer.WriteUInt32(4); + buffer.WriteInt32(-1); + + buffer.WriteUInt8(2); + buffer.WriteUInt32(2); + buffer.WriteInt32(-1); + + buffer.WriteUInt8(3); + buffer.WriteUInt32(2); + buffer.WriteInt32(-1); + + buffer.WriteUInt8(1); + buffer.WriteUInt32(4); + buffer.WriteInt32(-1); + + buffer.WriteUInt8(0); + buffer.WriteUInt32(5); + buffer.WriteInt32(-1); + + buffer.WriteUInt8(2); + buffer.WriteUInt32(3); + buffer.WriteInt32(-1); + + buffer.WriteUInt8(3); + buffer.WriteUInt32(3); + buffer.WriteInt32(-1); + + buffer.WriteUInt8(1); + buffer.WriteUInt32(5); + buffer.WriteInt32(-1); + + buffer.WriteUInt8(0); + buffer.WriteUInt32(6); + buffer.WriteInt32(0); + + buffer.WriteUInt8(2); + buffer.WriteUInt32(4); + buffer.WriteInt32(-1); + + buffer.WriteUInt8(3); + buffer.WriteUInt32(4); + buffer.WriteInt32(-1); + + buffer.WriteUInt8(1); + buffer.WriteUInt32(6); + buffer.WriteInt32(0); + + buffer.WriteUInt8(0); + buffer.WriteUInt32(7); + buffer.WriteInt32(1); + + buffer.WriteUInt8(2); + buffer.WriteUInt32(5); + buffer.WriteInt32(-1); + + buffer.WriteUInt8(3); + buffer.WriteUInt32(5); + buffer.WriteInt32(-1); + + buffer.WriteUInt8(1); + buffer.WriteUInt32(7); + buffer.WriteInt32(1); + + buffer.WriteUInt8(0); + buffer.WriteUInt32(8); + buffer.WriteInt32(1); + + buffer.WriteUInt8(2); + buffer.WriteUInt32(6); + buffer.WriteInt32(1); + + buffer.WriteUInt8(3); + buffer.WriteUInt32(6); + buffer.WriteInt32(1); + + buffer.WriteUInt8(1); + buffer.WriteUInt32(8); + buffer.WriteInt32(1); + + buffer.WriteUInt8(0); + buffer.WriteUInt32(9); + buffer.WriteInt32(5); + + buffer.WriteUInt8(2); + buffer.WriteUInt32(7); + buffer.WriteInt32(1); + + buffer.WriteUInt8(3); + buffer.WriteUInt32(7); + buffer.WriteInt32(1); + + buffer.WriteUInt8(1); + buffer.WriteUInt32(9); + buffer.WriteInt32(5); + + buffer.WriteUInt8(0); + buffer.WriteUInt32(10); + buffer.WriteInt32(0); + + buffer.WriteUInt8(2); + buffer.WriteUInt32(8); + buffer.WriteInt32(1); + + buffer.WriteUInt8(3); + buffer.WriteUInt32(8); + buffer.WriteInt32(1); + + buffer.WriteUInt8(0); + buffer.WriteUInt32(11); + buffer.WriteInt32(-1); + + buffer.WriteUInt8(1); + buffer.WriteUInt32(10); + buffer.WriteInt32(1); + + buffer.WriteUInt8(2); + buffer.WriteUInt32(9); + buffer.WriteInt32(-1); + + buffer.WriteUInt8(3); + buffer.WriteUInt32(9); + buffer.WriteInt32(-1); + + buffer.WriteUInt8(0); + buffer.WriteUInt32(12); + buffer.WriteInt32(-1); + + buffer.WriteUInt8(1); + buffer.WriteUInt32(11); + buffer.WriteInt32(-1); + + buffer.WriteUInt8(2); + buffer.WriteUInt32(10); + buffer.WriteInt32(1); + + buffer.WriteUInt8(3); + buffer.WriteUInt32(10); + buffer.WriteInt32(1); + + buffer.WriteUInt8(0); + buffer.WriteUInt32(13); + buffer.WriteInt32(0); + + buffer.WriteUInt8(1); + buffer.WriteUInt32(12); + buffer.WriteInt32(-1); + + buffer.WriteUInt8(2); + buffer.WriteUInt32(11); + buffer.WriteInt32(-1); + + buffer.WriteUInt8(3); + buffer.WriteUInt32(11); + buffer.WriteInt32(-1); + + buffer.WriteUInt8(0); + buffer.WriteUInt32(14); + buffer.WriteInt32(0); + + buffer.WriteUInt8(1); + buffer.WriteUInt32(13); + buffer.WriteInt32(1); + + buffer.WriteUInt8(2); + buffer.WriteUInt32(12); + buffer.WriteInt32(-1); + + buffer.WriteUInt8(3); + buffer.WriteUInt32(12); + buffer.WriteInt32(-1); + + buffer.WriteUInt8(0); + buffer.WriteUInt32(15); + buffer.WriteInt32(0); + + buffer.WriteUInt8(1); + buffer.WriteUInt32(14); + buffer.WriteInt32(0); + + buffer.WriteUInt8(2); + buffer.WriteUInt32(13); + buffer.WriteInt32(1); + + buffer.WriteUInt8(3); + buffer.WriteUInt32(13); + buffer.WriteInt32(1); + + buffer.WriteUInt8(0); + buffer.WriteUInt32(16); + buffer.WriteInt32(0); + + buffer.WriteUInt8(1); + buffer.WriteUInt32(15); + buffer.WriteInt32(0); + + buffer.WriteUInt8(2); + buffer.WriteUInt32(14); + buffer.WriteInt32(1); + + buffer.WriteUInt8(3); + buffer.WriteUInt32(14); + buffer.WriteInt32(1); + + buffer.WriteUInt8(0); + buffer.WriteUInt32(17); + buffer.WriteInt32(0); + + buffer.WriteUInt8(1); + buffer.WriteUInt32(16); + buffer.WriteInt32(1); + + buffer.WriteUInt8(2); + buffer.WriteUInt32(15); + buffer.WriteInt32(1); + + buffer.WriteUInt8(3); + buffer.WriteUInt32(15); + buffer.WriteInt32(1); + + buffer.WriteUInt8(0); + buffer.WriteUInt32(18); + buffer.WriteInt32(0); + + buffer.WriteUInt8(1); + buffer.WriteUInt32(17); + buffer.WriteInt32(0); + + buffer.WriteUInt8(2); + buffer.WriteUInt32(16); + buffer.WriteInt32(1); + + buffer.WriteUInt8(3); + buffer.WriteUInt32(16); + buffer.WriteInt32(1); + + buffer.WriteUInt8(0); + buffer.WriteUInt32(19); + buffer.WriteInt32(0); + + buffer.WriteUInt8(1); + buffer.WriteUInt32(18); + buffer.WriteInt32(0); + + buffer.WriteUInt8(2); + buffer.WriteUInt32(17); + buffer.WriteInt32(1); + + buffer.WriteUInt8(3); + buffer.WriteUInt32(17); + buffer.WriteInt32(1); + + buffer.WriteUInt8(0); + buffer.WriteUInt32(20); + buffer.WriteInt32(0); + + buffer.WriteUInt8(1); + buffer.WriteUInt32(19); + buffer.WriteInt32(0); + + buffer.WriteUInt8(2); + buffer.WriteUInt32(18); + buffer.WriteInt32(1); + + buffer.WriteUInt8(3); + buffer.WriteUInt32(18); + buffer.WriteInt32(1); + + buffer.WriteUInt8(0); + buffer.WriteUInt32(21); + buffer.WriteInt32(0); + + buffer.WriteUInt8(1); + buffer.WriteUInt32(20); + buffer.WriteInt32(0); + + buffer.WriteUInt8(2); + buffer.WriteUInt32(19); + buffer.WriteInt32(-1); + + buffer.WriteUInt8(3); + buffer.WriteUInt32(19); + buffer.WriteInt32(-1); + + buffer.WriteUInt8(0); + buffer.WriteUInt32(22); + buffer.WriteInt32(0); + + buffer.WriteUInt8(1); + buffer.WriteUInt32(21); + buffer.WriteInt32(0); + + buffer.WriteUInt8(2); + buffer.WriteUInt32(20); + buffer.WriteInt32(-1); + + buffer.WriteUInt8(3); + buffer.WriteUInt32(20); + buffer.WriteInt32(-1); + + buffer.WriteUInt8(2); + buffer.WriteUInt32(21); + buffer.WriteInt32(0); + + buffer.WriteUInt8(0); + buffer.WriteUInt32(23); + buffer.WriteInt32(0); + + buffer.WriteUInt8(1); + buffer.WriteUInt32(22); + buffer.WriteInt32(0); + + buffer.WriteUInt8(3); + buffer.WriteUInt32(21); + buffer.WriteInt32(0); + + buffer.WriteUInt8(2); + buffer.WriteUInt32(22); + buffer.WriteInt32(0); + + buffer.WriteUInt8(1); + buffer.WriteUInt32(23); + buffer.WriteInt32(0); + + buffer.WriteUInt8(3); + buffer.WriteUInt32(22); + buffer.WriteInt32(0); + + buffer.WriteUInt8(2); + buffer.WriteUInt32(23); + buffer.WriteInt32(0); + + buffer.WriteUInt8(3); + buffer.WriteUInt32(23); + buffer.WriteInt32(0); + + // race count + buffer.WriteUInt32(17); + + // races + buffer.WriteUInt32(1); + buffer.WriteUInt32(131071); + + buffer.WriteUInt32(333); + buffer.WriteUInt32(131071); + + buffer.WriteUInt32(90287); + buffer.WriteUInt32(131071); + + buffer.WriteUInt32(90289); + buffer.WriteUInt32(16); + + buffer.WriteUInt32(90290); + buffer.WriteUInt32(32); + + buffer.WriteUInt32(90291); + buffer.WriteUInt32(64); + + buffer.WriteUInt32(90292); + buffer.WriteUInt32(128); + + buffer.WriteUInt32(90293); + buffer.WriteUInt32(256); + + buffer.WriteUInt32(90294); + buffer.WriteUInt32(512); + + buffer.WriteUInt32(90295); + buffer.WriteUInt32(1024); + + buffer.WriteUInt32(90296); + buffer.WriteUInt32(2048); + + buffer.WriteUInt32(90297); + buffer.WriteUInt32(8192); + + buffer.WriteUInt32(90298); + buffer.WriteUInt32(16384); + + buffer.WriteUInt32(90299); + buffer.WriteUInt32(32768); + + buffer.WriteUInt32(90300); + buffer.WriteUInt32(65536); + + buffer.WriteUInt32(2012271); + buffer.WriteUInt32(131071); + + buffer.WriteUInt32(2012277); + buffer.WriteUInt32(131071); + + // classes count + buffer.WriteUInt32(17); + + // classes + buffer.WriteUInt32(1); + buffer.WriteUInt32(131071); + + buffer.WriteUInt32(333); + buffer.WriteUInt32(131071); + + buffer.WriteUInt32(90287); + buffer.WriteUInt32(131071); + + buffer.WriteUInt32(90301); + buffer.WriteUInt32(8); + + buffer.WriteUInt32(90302); + buffer.WriteUInt32(16); + + buffer.WriteUInt32(90303); + buffer.WriteUInt32(32); + + buffer.WriteUInt32(90304); + buffer.WriteUInt32(64); + + buffer.WriteUInt32(90305); + buffer.WriteUInt32(128); + + buffer.WriteUInt32(90306); + buffer.WriteUInt32(256); + + buffer.WriteUInt32(90307); + buffer.WriteUInt32(1024); + + buffer.WriteUInt32(90308); + buffer.WriteUInt32(2048); + + buffer.WriteUInt32(90309); + buffer.WriteUInt32(8192); + + buffer.WriteUInt32(90310); + buffer.WriteUInt32(16384); + + buffer.WriteUInt32(90311); + buffer.WriteUInt32(32768); + + buffer.WriteUInt32(90312); + buffer.WriteUInt32(65536); + + buffer.WriteUInt32(2012271); + buffer.WriteUInt32(131071); + + buffer.WriteUInt32(2012277); + buffer.WriteUInt32(131071); + + // exit string length + buffer.WriteUInt32(0); + + __packet->size = buffer.size(); + __packet->pBuffer = new unsigned char[__packet->size]; + memcpy(__packet->pBuffer, buffer.buffer(), __packet->size); + FINISH_ENCODE(); + } + + ENCODE(OP_SendMaxCharacters) { + ENCODE_LENGTH_EXACT(MaxCharacters_Struct); + SETUP_DIRECT_ENCODE(MaxCharacters_Struct, structs::MaxCharacters_Struct); + + //OUT(max_chars); + eq->max_chars = 8; //needs to be fixed + eq->marketplace_chars = 0; + eq->unknown008 = -1; + eq->unknown00c = 196608; + eq->unknown010 = 0; + eq->unknown014 = 0; + eq->unknown018 = 0; + eq->unknown01c = 0; + eq->unknown020 = -1; + eq->unknown024 = 0; + eq->unknown028 = 0; + eq->unknown02c = 0; + eq->unknown030 = 0; + eq->unknown034 = 0; + + FINISH_ENCODE(); } // DECODE methods diff --git a/common/patches/larion_limits.cpp b/common/patches/larion_limits.cpp index 273e74a5c..49ea7a396 100644 --- a/common/patches/larion_limits.cpp +++ b/common/patches/larion_limits.cpp @@ -16,3 +16,269 @@ along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "larion_limits.h" + +#include "../strings.h" + + +int16 Larion::invtype::GetInvTypeSize(int16 inv_type) +{ + switch (inv_type) { + case invtype::typePossessions: + return invtype::POSSESSIONS_SIZE; + case invtype::typeBank: + return invtype::BANK_SIZE; + case invtype::typeSharedBank: + return invtype::SHARED_BANK_SIZE; + case invtype::typeTrade: + return invtype::TRADE_SIZE; + case invtype::typeWorld: + return invtype::WORLD_SIZE; + case invtype::typeLimbo: + return invtype::LIMBO_SIZE; + case invtype::typeTribute: + return invtype::TRIBUTE_SIZE; + case invtype::typeTrophyTribute: + return invtype::TROPHY_TRIBUTE_SIZE; + case invtype::typeGuildTribute: + return invtype::GUILD_TRIBUTE_SIZE; + case invtype::typeMerchant: + return invtype::MERCHANT_SIZE; + case invtype::typeDeleted: + return invtype::DELETED_SIZE; + case invtype::typeCorpse: + return invtype::CORPSE_SIZE; + case invtype::typeBazaar: + return invtype::BAZAAR_SIZE; + case invtype::typeInspect: + return invtype::INSPECT_SIZE; + case invtype::typeRealEstate: + return invtype::REAL_ESTATE_SIZE; + case invtype::typeViewMODPC: + return invtype::VIEW_MOD_PC_SIZE; + case invtype::typeViewMODBank: + return invtype::VIEW_MOD_BANK_SIZE; + case invtype::typeViewMODSharedBank: + return invtype::VIEW_MOD_SHARED_BANK_SIZE; + case invtype::typeViewMODLimbo: + return invtype::VIEW_MOD_LIMBO_SIZE; + case invtype::typeAltStorage: + return invtype::ALT_STORAGE_SIZE; + case invtype::typeArchived: + return invtype::ARCHIVED_SIZE; + case invtype::typeMail: + return invtype::MAIL_SIZE; + case invtype::typeGuildTrophyTribute: + return invtype::GUILD_TROPHY_TRIBUTE_SIZE; + case invtype::typeKrono: + return invtype::KRONO_SIZE; + case invtype::typeOther: + return invtype::OTHER_SIZE; + default: + return INULL; + } +} + +const char* Larion::invtype::GetInvTypeName(int16 inv_type) +{ + switch (inv_type) { + case invtype::TYPE_INVALID: + return "Invalid Type"; + case invtype::typePossessions: + return "Possessions"; + case invtype::typeBank: + return "Bank"; + case invtype::typeSharedBank: + return "Shared Bank"; + case invtype::typeTrade: + return "Trade"; + case invtype::typeWorld: + return "World"; + case invtype::typeLimbo: + return "Limbo"; + case invtype::typeTribute: + return "Tribute"; + case invtype::typeTrophyTribute: + return "Trophy Tribute"; + case invtype::typeGuildTribute: + return "Guild Tribute"; + case invtype::typeMerchant: + return "Merchant"; + case invtype::typeDeleted: + return "Deleted"; + case invtype::typeCorpse: + return "Corpse"; + case invtype::typeBazaar: + return "Bazaar"; + case invtype::typeInspect: + return "Inspect"; + case invtype::typeRealEstate: + return "Real Estate"; + case invtype::typeViewMODPC: + return "View MOD PC"; + case invtype::typeViewMODBank: + return "View MOD Bank"; + case invtype::typeViewMODSharedBank: + return "View MOD Shared Bank"; + case invtype::typeViewMODLimbo: + return "View MOD Limbo"; + case invtype::typeAltStorage: + return "Alt Storage"; + case invtype::typeArchived: + return "Archived"; + case invtype::typeMail: + return "Mail"; + case invtype::typeGuildTrophyTribute: + return "Guild Trophy Tribute"; + case invtype::typeKrono: + return "Krono"; + case invtype::typeOther: + return "Other"; + default: + return "Unknown Type"; + } +} + +bool Larion::invtype::IsInvTypePersistent(int16 inv_type) +{ + switch (inv_type) { + case invtype::typePossessions: + case invtype::typeBank: + case invtype::typeSharedBank: + case invtype::typeTrade: + case invtype::typeWorld: + case invtype::typeLimbo: + case invtype::typeTribute: + case invtype::typeTrophyTribute: + case invtype::typeGuildTribute: + return true; + default: + return false; + } +} + +const char* Larion::invslot::GetInvPossessionsSlotName(int16 inv_slot) +{ + switch (inv_slot) { + case invslot::SLOT_INVALID: + return "Invalid Slot"; + case invslot::slotCharm: + return "Charm"; + case invslot::slotEar1: + return "Ear 1"; + case invslot::slotHead: + return "Head"; + case invslot::slotFace: + return "Face"; + case invslot::slotEar2: + return "Ear 2"; + case invslot::slotNeck: + return "Neck"; + case invslot::slotShoulders: + return "Shoulders"; + case invslot::slotArms: + return "Arms"; + case invslot::slotBack: + return "Back"; + case invslot::slotWrist1: + return "Wrist 1"; + case invslot::slotWrist2: + return "Wrist 2"; + case invslot::slotRange: + return "Range"; + case invslot::slotHands: + return "Hands"; + case invslot::slotPrimary: + return "Primary"; + case invslot::slotSecondary: + return "Secondary"; + case invslot::slotFinger1: + return "Finger 1"; + case invslot::slotFinger2: + return "Finger 2"; + case invslot::slotChest: + return "Chest"; + case invslot::slotLegs: + return "Legs"; + case invslot::slotFeet: + return "Feet"; + case invslot::slotWaist: + return "Waist"; + case invslot::slotPowerSource: + return "Power Source"; + case invslot::slotAmmo: + return "Ammo"; + case invslot::slotGeneral1: + return "General 1"; + case invslot::slotGeneral2: + return "General 2"; + case invslot::slotGeneral3: + return "General 3"; + case invslot::slotGeneral4: + return "General 4"; + case invslot::slotGeneral5: + return "General 5"; + case invslot::slotGeneral6: + return "General 6"; + case invslot::slotGeneral7: + return "General 7"; + case invslot::slotGeneral8: + return "General 8"; + case invslot::slotGeneral9: + return "General 9"; + case invslot::slotGeneral10: + return "General 10"; + case invslot::slotCursor: + return "Cursor"; + default: + return "Unknown Slot"; + } +} + +const char* Larion::invslot::GetInvSlotName(int16 inv_type, int16 inv_slot) +{ + if (inv_type == invtype::typePossessions) + return invslot::GetInvPossessionsSlotName(inv_slot); + + int16 type_size = invtype::GetInvTypeSize(inv_type); + + if (!type_size || inv_slot == invslot::SLOT_INVALID) + return "Invalid Slot"; + + if ((inv_slot + 1) >= type_size) + return "Unknown Slot"; + + static std::string ret_str; + ret_str = StringFormat("Slot %i", (inv_slot + 1)); + + return ret_str.c_str(); +} + +const char* Larion::invbag::GetInvBagIndexName(int16 bag_index) +{ + if (bag_index == invbag::SLOT_INVALID) + return "Invalid Bag"; + + if (bag_index >= invbag::SLOT_COUNT) + return "Unknown Bag"; + + static std::string ret_str; + ret_str = StringFormat("Bag %i", (bag_index + 1)); + + return ret_str.c_str(); +} + +const char* Larion::invaug::GetInvAugIndexName(int16 aug_index) +{ + if (aug_index == invaug::SOCKET_INVALID) + return "Invalid Augment"; + + if (aug_index >= invaug::SOCKET_COUNT) + return "Unknown Augment"; + + static std::string ret_str; + ret_str = StringFormat("Augment %i", (aug_index + 1)); + + return ret_str.c_str(); +} diff --git a/common/patches/larion_limits.h b/common/patches/larion_limits.h index 2ac784c91..6d3a1ddb0 100644 --- a/common/patches/larion_limits.h +++ b/common/patches/larion_limits.h @@ -20,11 +20,309 @@ #ifndef COMMON_LARION_LIMITS_H #define COMMON_LARION_LIMITS_H +#include "../types.h" +#include "../emu_versions.h" +#include "../skills.h" namespace Larion { - - // put constants here and #include appropriately + const int16 IINVALID = -1; + const int16 INULL = 0; + + namespace inventory { + inline EQ::versions::ClientVersion GetInventoryRef() { return EQ::versions::ClientVersion::Larion; } + + const bool ConcatenateInvTypeLimbo = false; + + const bool AllowOverLevelEquipment = true; + + const bool AllowEmptyBagInBag = true; + const bool AllowClickCastFromBag = true; + + } /*inventory*/ + + namespace invtype { + inline EQ::versions::ClientVersion GetInvTypeRef() { return EQ::versions::ClientVersion::Larion; } + + namespace enum_ { + enum InventoryTypes : int16 { + typePossessions = INULL, + typeBank, + typeSharedBank, + typeTrade, + typeWorld, + typeLimbo, + typeTribute, + typeTrophyTribute, + typeGuildTribute, + typeMerchant, + typeDeleted, + typeCorpse, + typeBazaar, + typeInspect, + typeRealEstate, + typeViewMODPC, + typeViewMODBank, + typeViewMODSharedBank, + typeViewMODLimbo, + typeAltStorage, + typeArchived, + typeMail, + typeGuildTrophyTribute, + typeKrono, + typeOther + }; + + } // namespace enum_ + using namespace enum_; + + const int16 POSSESSIONS_SIZE = 34; + const int16 BANK_SIZE = 24; + const int16 SHARED_BANK_SIZE = 2; + const int16 TRADE_SIZE = 8; + const int16 WORLD_SIZE = 10; + const int16 LIMBO_SIZE = 36; + const int16 TRIBUTE_SIZE = 5; + const int16 TROPHY_TRIBUTE_SIZE = 0;//unknown + const int16 GUILD_TRIBUTE_SIZE = 2;//unverified + const int16 MERCHANT_SIZE = 200; + const int16 DELETED_SIZE = 0;//unknown - "Recovery Tab" + const int16 CORPSE_SIZE = POSSESSIONS_SIZE; + const int16 BAZAAR_SIZE = 200; + const int16 INSPECT_SIZE = 23; + const int16 REAL_ESTATE_SIZE = 0;//unknown + const int16 VIEW_MOD_PC_SIZE = POSSESSIONS_SIZE; + const int16 VIEW_MOD_BANK_SIZE = BANK_SIZE; + const int16 VIEW_MOD_SHARED_BANK_SIZE = SHARED_BANK_SIZE; + const int16 VIEW_MOD_LIMBO_SIZE = LIMBO_SIZE; + const int16 ALT_STORAGE_SIZE = 0;//unknown - "Shroud Bank" + const int16 ARCHIVED_SIZE = 0;//unknown + const int16 MAIL_SIZE = 0;//unknown + const int16 GUILD_TROPHY_TRIBUTE_SIZE = 0;//unknown + const int16 KRONO_SIZE = 0;//unknown + const int16 OTHER_SIZE = 0;//unknown + + const int16 TRADE_NPC_SIZE = 4; // defined by implication + + const int16 TYPE_INVALID = IINVALID; + const int16 TYPE_BEGIN = typePossessions; + const int16 TYPE_END = typeOther; + const int16 TYPE_COUNT = (TYPE_END - TYPE_BEGIN) + 1; + + int16 GetInvTypeSize(int16 inv_type); + const char* GetInvTypeName(int16 inv_type); + + bool IsInvTypePersistent(int16 inv_type); + + } /*invtype*/ + + namespace invslot { + inline EQ::versions::ClientVersion GetInvSlotRef() { return EQ::versions::ClientVersion::Larion; } + + namespace enum_ { + enum InventorySlots : int16 { + slotCharm = INULL, + slotEar1, + slotHead, + slotFace, + slotEar2, + slotNeck, + slotShoulders, + slotArms, + slotBack, + slotWrist1, + slotWrist2, + slotRange, + slotHands, + slotPrimary, + slotSecondary, + slotFinger1, + slotFinger2, + slotChest, + slotLegs, + slotFeet, + slotWaist, + slotPowerSource, + slotAmmo, + slotGeneral1, + slotGeneral2, + slotGeneral3, + slotGeneral4, + slotGeneral5, + slotGeneral6, + slotGeneral7, + slotGeneral8, + slotGeneral9, + slotGeneral10, + slotCursor + }; + + constexpr int16 format_as(InventorySlots slot) { return static_cast(slot); } + } // namespace enum_ + using namespace enum_; + + const int16 SLOT_INVALID = IINVALID; + const int16 SLOT_BEGIN = INULL; + + const int16 POSSESSIONS_BEGIN = slotCharm; + const int16 POSSESSIONS_END = slotCursor; + const int16 POSSESSIONS_COUNT = (POSSESSIONS_END - POSSESSIONS_BEGIN) + 1; + + const int16 EQUIPMENT_BEGIN = slotCharm; + const int16 EQUIPMENT_END = slotAmmo; + const int16 EQUIPMENT_COUNT = (EQUIPMENT_END - EQUIPMENT_BEGIN) + 1; + + const int16 GENERAL_BEGIN = slotGeneral1; + const int16 GENERAL_END = slotGeneral10; + const int16 GENERAL_COUNT = (GENERAL_END - GENERAL_BEGIN) + 1; + + const int16 BONUS_BEGIN = invslot::slotCharm; + const int16 BONUS_STAT_END = invslot::slotPowerSource; + const int16 BONUS_SKILL_END = invslot::slotAmmo; + + const int16 CORPSE_BEGIN = invslot::slotGeneral1; + const int16 CORPSE_END = invslot::slotGeneral1 + invslot::slotCursor; + + const uint64 EQUIPMENT_BITMASK = 0x00000000007FFFFF; + const uint64 GENERAL_BITMASK = 0x00000001FF800000; + const uint64 CURSOR_BITMASK = 0x0000000200000000; + const uint64 POSSESSIONS_BITMASK = (EQUIPMENT_BITMASK | GENERAL_BITMASK | CURSOR_BITMASK); // based on 34-slot count (RoF+) + const uint64 CORPSE_BITMASK = (GENERAL_BITMASK | CURSOR_BITMASK | (EQUIPMENT_BITMASK << 34)); // based on 34-slot count (RoF+) + + + const char* GetInvPossessionsSlotName(int16 inv_slot); + const char* GetInvSlotName(int16 inv_type, int16 inv_slot); + + } /*invslot*/ + + namespace invbag { + inline EQ::versions::ClientVersion GetInvBagRef() { return EQ::versions::ClientVersion::Larion; } + + const int16 SLOT_INVALID = IINVALID; + const int16 SLOT_BEGIN = INULL; + const int16 SLOT_END = 9; //254; + const int16 SLOT_COUNT = 10; //255; // server Size will be 255..unsure what actual client is (test) + + const char* GetInvBagIndexName(int16 bag_index); + + } /*invbag*/ + + namespace invaug { + inline EQ::versions::ClientVersion GetInvAugRef() { return EQ::versions::ClientVersion::Larion; } + + const int16 SOCKET_INVALID = IINVALID; + const int16 SOCKET_BEGIN = INULL; + const int16 SOCKET_END = 5; + const int16 SOCKET_COUNT = 6; + + const char* GetInvAugIndexName(int16 aug_index); + + } /*invaug*/ + + namespace item { + inline EQ::versions::ClientVersion GetItemRef() { return EQ::versions::ClientVersion::Larion; } + + //enum Unknown : int { // looks like item class..but, RoF has it too - nothing in UF- + // Unknown1 = 0, + // Unknown2 = 1, + // Unknown3 = 2, + // Unknown4 = 5 // krono? + //}; + + enum ItemPacketType : int { + ItemPacketMerchant = 100, + ItemPacketTradeView = 101, + ItemPacketLoot = 102, + ItemPacketTrade = 103, + ItemPacketCharInventory = 105, + ItemPacketLimbo = 106, + ItemPacketWorldContainer = 107, + ItemPacketTributeItem = 108, + ItemPacketGuildTribute = 109, + ItemPacket10 = 110, + ItemPacket11 = 111, + ItemPacket12 = 112, + ItemPacketRecovery = 113, + ItemPacket14 = 115 // Parcel? adds to merchant window too + }; + + } /*item*/ + + namespace profile { + inline EQ::versions::ClientVersion GetProfileRef() { return EQ::versions::ClientVersion::Larion; } + + const int16 BANDOLIERS_SIZE = 20; // number of bandolier instances + const int16 BANDOLIER_ITEM_COUNT = 4; // number of equipment slots in bandolier instance + + const int16 POTION_BELT_SIZE = 5; + + const int16 SKILL_ARRAY_SIZE = 100; + + } /*profile*/ + + namespace constants { + inline EQ::versions::ClientVersion GetConstantsRef() { return EQ::versions::ClientVersion::Larion; } + + const EQ::expansions::Expansion EXPANSION = EQ::expansions::Expansion::RoF; + const uint32 EXPANSION_BIT = EQ::expansions::bitRoF; + const uint32 EXPANSIONS_MASK = EQ::expansions::maskRoF; + + const size_t CHARACTER_CREATION_LIMIT = 12; + + const size_t SAY_LINK_BODY_SIZE = 56; + const uint32 MAX_GUILD_ID = 50000; + + } /*constants*/ + + namespace behavior { + inline EQ::versions::ClientVersion GetBehaviorRef() { return EQ::versions::ClientVersion::Larion; } + + const bool CoinHasWeight = false; + + } /*behavior*/ + + namespace skills { + inline EQ::versions::ClientVersion GetSkillsRef() { return EQ::versions::ClientVersion::Larion; } + + const size_t LastUsableSkill = EQ::skills::Skill2HPiercing; + + } /*skills*/ + + namespace spells { + inline EQ::versions::ClientVersion GetSkillsRef() { return EQ::versions::ClientVersion::Larion; } + + enum class CastingSlot : uint32 { + Gem1 = 0, + Gem2 = 1, + Gem3 = 2, + Gem4 = 3, + Gem5 = 4, + Gem6 = 5, + Gem7 = 6, + Gem8 = 7, + Gem9 = 8, + Gem10 = 9, + Gem11 = 10, + Gem12 = 11, + MaxGems = 16, // fallacy..only 12 slot are useable... + Item = 12, + Discipline = 13, + AltAbility = 0xFF + }; + + const int SPELL_ID_MAX = 45000; + const int SPELLBOOK_SIZE = 720; + const int SPELL_GEM_COUNT = static_cast(CastingSlot::MaxGems); + + const int LONG_BUFFS = 42; + const int SHORT_BUFFS = 20; + const int DISC_BUFFS = 1; + const int TOTAL_BUFFS = LONG_BUFFS + SHORT_BUFFS + DISC_BUFFS; + const int NPC_BUFFS = 97; + const int PET_BUFFS = NPC_BUFFS; + const int MERC_BUFFS = LONG_BUFFS; + + } /*spells*/ }; /* Larion */ diff --git a/common/patches/larion_ops.h b/common/patches/larion_ops.h index 0daf37f65..fac805f07 100644 --- a/common/patches/larion_ops.h +++ b/common/patches/larion_ops.h @@ -5,6 +5,7 @@ E(OP_LogServer) E(OP_SendMembership) E(OP_SendMembershipDetails) +E(OP_SendMaxCharacters) #undef E #undef D diff --git a/common/patches/larion_structs.h b/common/patches/larion_structs.h index e05d96240..d9640219e 100644 --- a/common/patches/larion_structs.h +++ b/common/patches/larion_structs.h @@ -37,9 +37,9 @@ namespace Larion { struct Membership_Setting_Struct { - /*000*/ uint8 setting_index; // 0, 1, 2 or 3 - /*001*/ uint32 setting_id; // 0 to 23 - /*005*/ int32 setting_value; // All can be 0, 1, or -1 + /*000*/ uint8 setting_index; // 0, 1, 2 or 3: f2p, silver, gold, platinum? + /*001*/ uint32 setting_id; // 0 to 23 actually seen but the OP_Membership packet has up to 32 + /*005*/ int32 setting_value; /*009*/ }; @@ -55,6 +55,24 @@ namespace Larion { /*480*/ //char exit_url[42]; // Upgrade to Silver or Gold Membership URL }; + struct MaxCharacters_Struct { + /*000*/ uint32 max_chars; + /*004*/ uint32 marketplace_chars; + /*008*/ int32 unknown008; //some of these probably deal with heroic characters or something + /*00c*/ int32 unknown00c; + /*010*/ int32 unknown010; + /*014*/ int32 unknown014; + /*018*/ int32 unknown018; + /*01c*/ int32 unknown01c; + /*020*/ int32 unknown020; + /*024*/ int32 unknown024; + /*028*/ int32 unknown028; + /*02c*/ int32 unknown02c; + /*030*/ int32 unknown030; + /*034*/ int32 unknown034; + /*038*/ + }; + }; //end namespace structs }; //end namespace larion