Starting work on character guids

common/CMakeLists.txt

@@ -111,6 +111,8 @@ SET(common_sources
     net/websocket_server.cpp
     net/websocket_server_connection.cpp
     patches/patches.cpp
+	patches/larion.cpp
+    patches/larion_limits.cpp
     patches/sod.cpp
     patches/sod_limits.cpp
     patches/sof.cpp
@@ -653,7 +655,11 @@ SET(common_headers
     net/websocket_server.h
     net/websocket_server_connection.h
     patches/patches.h
-    patches/sod.h
+    patches/larion.h
+    patches/larion_limits.h
+    patches/larion_ops.h
+    patches/larion_structs.h
+	patches/sod.h
     patches/sod_limits.h
     patches/sod_ops.h
     patches/sod_structs.h
@@ -739,6 +745,10 @@ SOURCE_GROUP(Net FILES
 
 SOURCE_GROUP(Patches FILES
     patches/patches.h
+	patches/larion.h
+    patches/larion_limits.h
+    patches/larion_ops.h
+    patches/larion_structs.h
     patches/sod.h
     patches/sod_limits.h
     patches/sod_ops.h
@@ -767,6 +777,8 @@ SOURCE_GROUP(Patches FILES
     patches/uf_ops.h
     patches/uf_structs.h
     patches/patches.cpp
+	patches/larion.cpp
+    patches/larion_limits.cpp
     patches/sod.cpp
     patches/sod_limits.cpp
     patches/sof.cpp

common/base_packet.h

@@ -59,6 +59,7 @@ public:
 	void WriteUInt8(uint8 value) { *(uint8 *)(pBuffer + _wpos) = value; _wpos += sizeof(uint8); }
 	void WriteUInt32(uint32 value) { *(uint32 *)(pBuffer + _wpos) = value; _wpos += sizeof(uint32); }
 	void WriteUInt64(uint64 value) { *(uint64 *)(pBuffer + _wpos) = value; _wpos += sizeof(uint64); }
+	void WriteSInt16(int32 value) { *(int16*)(pBuffer + _wpos) = value; _wpos += sizeof(int16); }
 	void WriteUInt16(uint32 value) { *(uint16 *)(pBuffer + _wpos) = value; _wpos += sizeof(uint16); }
 	void WriteSInt32(int32 value) { *(int32 *)(pBuffer + _wpos) = value; _wpos += sizeof(int32); }
 	void WriteFloat(float value) { *(float *)(pBuffer + _wpos) = value; _wpos += sizeof(float); }

common/crc32.cpp

@@ -101,6 +101,24 @@ void CRC32::SetEQChecksum(uchar* in_data, uint32 in_length, uint32 start_at)
 	memcpy(in_data, (char*)&check, 4);
 }
 
+unsigned long CRC32::GetEQChecksum(uchar* in_data, uint32 in_length, uint32 start_at)
+{
+	unsigned long data;
+	unsigned long check = 0xffffffff;
+
+	for (uint32 i = start_at; i < in_length; i++)
+	{
+		data = in_data[i];
+		data = data ^ (check);
+		data = data & 0x000000ff;
+		check = check >> 8;
+		data = CRC32Table[data];
+		check = check ^ data;
+	}
+
+	return check;
+}
+
 uint32 CRC32::Update(const uint8* buf, uint32 bufsize, uint32 crc32var) {
 	for(uint32 i=0; i < bufsize; i++)
 		Calc(buf[i], crc32var);

common/crc32.h

@@ -8,6 +8,7 @@ public:
 	static uint32			Generate(const uint8* buf, uint32 bufsize);
 	static uint32			GenerateNoFlip(const uint8* buf, uint32 bufsize); // Same as Generate(), but without the ~
 	static void				SetEQChecksum(uchar* in_data, uint32 in_length, uint32 start_at=4);
+	static unsigned long	GetEQChecksum(uchar* in_data, uint32 in_length, uint32 start_at = 4);
 
 	// Multiple buffer CRC32
 	static uint32			Update(const uint8* buf, uint32 bufsize, uint32 crc32 = 0xFFFFFFFF);

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<unsigned int>(ClientVersion::RoF2) - 1)) :
 		return ClientVersion::RoF2;
+	case ((uint32)1 << (static_cast<unsigned int>(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;
 	}

common/emu_versions.h

@@ -36,7 +36,8 @@ namespace EQ
 			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'
+			RoF2,		// Build: 'May 10 2013 23:30:08'
+			Larion
 		};
 
 		enum ClientVersionBitmask : uint32 {
@@ -48,6 +49,7 @@ namespace EQ
 			bitUF = 0x00000010,
 			bitRoF = 0x00000020,
 			bitRoF2 = 0x00000040,
+			bitLarion = 0x00000080,
 			maskUnknown = 0x00000000,
 			maskTitaniumAndEarlier = 0x00000003,
 			maskSoFAndEarlier = 0x00000007,
@@ -59,10 +61,11 @@ namespace EQ
 			maskUFAndLater = 0xFFFFFFF0,
 			maskRoFAndLater = 0xFFFFFFE0,
 			maskRoF2AndLater = 0xFFFFFFC0,
+			maskLarionAndLater = 0xFFFFFF80,
 			maskAllClients = 0xFFFFFFFF
 		};
 
-		const ClientVersion LastClientVersion = ClientVersion::RoF2;
+		const ClientVersion LastClientVersion = ClientVersion::Larion;
 		const size_t ClientVersionCount = (static_cast<size_t>(LastClientVersion) + 1);
 
 		bool IsValidClientVersion(ClientVersion client_version);
@@ -80,6 +83,7 @@ namespace EQ
 			UF,
 			RoF,
 			RoF2,
+			Larion,
 			NPC,
 			NPCMerchant,
 			Merc,
@@ -93,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<size_t>(LastMobVersion) + 1);
 
 		bool IsValidMobVersion(MobVersion mob_version);
@@ -131,7 +136,8 @@ namespace EQ
 			ucsSoDCombined = 'D',
 			ucsUFCombined = 'E',
 			ucsRoFCombined = 'F',
-			ucsRoF2Combined = 'G'
+			ucsRoF2Combined = 'G',
+			ucsLaurionCombined = 'G'
 		};
 
 	} /*versions*/
@@ -158,7 +164,17 @@ namespace EQ
 			HoT,
 			VoA,
 			RoF,
-			CotF
+			CotF,
+			TDS,
+			TBM,
+			EoK,
+			RoS,
+			TBL,
+			ToV,
+			CoV,
+			ToL,
+			NoS,
+			LS
 		};
 
 		enum ExpansionBitmask : uint32 {
@@ -183,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,
@@ -203,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);

common/eq_limits.cpp

@@ -104,6 +104,14 @@ static const EQ::constants::LookupEntry constants_static_lookup_entries[EQ::vers
 		RoF2::constants::EXPANSIONS_MASK,
 		RoF2::constants::CHARACTER_CREATION_LIMIT,
 		RoF2::constants::SAY_LINK_BODY_SIZE
+	),
+	/*[ClientVersion::Larion] =*/
+	EQ::constants::LookupEntry(
+		Larion::constants::EXPANSION,
+		Larion::constants::EXPANSION_BIT,
+		Larion::constants::EXPANSIONS_MASK,
+		Larion::constants::CHARACTER_CREATION_LIMIT,
+		Larion::constants::SAY_LINK_BODY_SIZE
 	)
 };
 
@@ -370,6 +378,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 +778,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 +1056,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 +1113,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
 	)
@@ -1202,6 +1272,19 @@ static const EQ::spells::LookupEntry spells_static_lookup_entries[EQ::versions::
 		RoF2::spells::NPC_BUFFS,
 		RoF2::spells::PET_BUFFS,
 		RoF2::spells::MERC_BUFFS
+	),
+	/*[ClientVersion::Larion] =*/
+	EQ::spells::LookupEntry(
+		Larion::spells::SPELL_ID_MAX,
+		Larion::spells::SPELLBOOK_SIZE,
+		UF::spells::SPELL_GEM_COUNT, // client translators are setup to allow the max value a client supports..however, the top 4 indices are not valid in this case
+		Larion::spells::LONG_BUFFS,
+		Larion::spells::SHORT_BUFFS,
+		Larion::spells::DISC_BUFFS,
+		Larion::spells::TOTAL_BUFFS,
+		Larion::spells::NPC_BUFFS,
+		Larion::spells::PET_BUFFS,
+		Larion::spells::MERC_BUFFS
 	)
 };
 

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
 {

common/eq_packet_structs.h

@@ -6435,6 +6435,13 @@ struct BuylineItemDetails_Struct {
 	uint32      item_quantity;
 };
 
+struct EqGuid
+{
+	uint32_t Id;
+	uint16_t WorldId;
+	uint16_t Reserved;
+};
+
 // Restore structure packing to default
 #pragma pack()
 

common/patches/larion.h

@@ -0,0 +1,55 @@
+/*	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_LARION_H
+#define COMMON_LARION_H
+
+#include "../struct_strategy.h"
+
+class EQStreamIdentifier;
+
+namespace Larion
+{
+
+	//these are the only public member of this namespace.
+	extern void Register(EQStreamIdentifier& into);
+	extern void Reload();
+
+
+
+	//you should not directly access anything below..
+	//I just dont feel like making a seperate header for it.
+
+	class Strategy : public StructStrategy {
+	public:
+		Strategy();
+
+	protected:
+
+		virtual std::string Describe() const;
+		virtual const EQ::versions::ClientVersion ClientVersion() const;
+
+		//magic macro to declare our opcode processors
+#include "ss_declare.h"
+#include "larion_ops.h"
+	};
+
+}; /*Larion*/
+
+#endif /*COMMON_LARION_H*/

common/patches/larion_limits.cpp

@@ -0,0 +1,284 @@
+/*	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 "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();
+}

common/patches/larion_limits.h

@@ -0,0 +1,330 @@
+/*	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_LARION_LIMITS_H
+#define COMMON_LARION_LIMITS_H
+
+#include "../types.h"
+#include "../emu_versions.h"
+#include "../skills.h"
+
+namespace Larion
+{
+	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<int16>(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::LS;
+		const uint32 EXPANSION_BIT = EQ::expansions::bitLS;
+		const uint32 EXPANSIONS_MASK = EQ::expansions::maskLS;
+
+		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 = 18, // fallacy..only 12 slot are useable...
+			Item = 12,
+			Discipline = 13,
+			AltAbility = 0xFF
+		};
+
+		const int SPELL_ID_MAX = 71999;
+		const int SPELLBOOK_SIZE = 1120;
+		const int SPELL_GEM_COUNT = static_cast<uint32>(CastingSlot::MaxGems);
+		const int SPELL_GEM_RECAST_TIMER = 15;
+
+		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 */
+
+#endif /*COMMON_LARION_LIMITS_H*/

common/patches/larion_ops.h

@@ -0,0 +1,19 @@
+
+//list of packets we need to encode on the way out:
+E(OP_LogServer)
+E(OP_SendMembership)
+E(OP_SendMembershipDetails)
+E(OP_SendMaxCharacters)
+E(OP_SendCharInfo)
+E(OP_ExpansionInfo)
+E(OP_SpawnAppearance)
+//E(OP_SendAATable)
+E(OP_PlayerProfile)
+E(OP_ZoneEntry)
+E(OP_ZoneSpawns)
+
+//list of packets we need to decode on the way in:
+D(OP_ZoneEntry)
+
+#undef E
+#undef D

common/patches/larion_structs.h

@@ -0,0 +1,233 @@
+#ifndef LARION_STRUCTS_H_
+#define LARION_STRUCTS_H_
+
+namespace Larion {
+	namespace structs {
+		// constants
+		static const uint32 MAX_PP_AA_ARRAY = 300;
+		static const uint32 MAX_PP_SKILL = PACKET_SKILL_ARRAY_SIZE;
+		static const uint32 MAX_PP_INNATE_SKILL = 25;
+		static const uint32 MAX_PP_DISCIPLINES = 300;
+		static const uint32 MAX_PP_COMBAT_ABILITY_TIMERS = 25;
+		static const uint32 MAX_PP_UNKNOWN_ABILITIES = 25;
+		static const uint32 MAX_RECAST_TYPES = 25;
+		static const uint32 MAX_ITEM_RECAST_TYPES = 100;
+		static const uint32 BUFF_COUNT = 62;
+		static const uint32 MAX_PP_LANGUAGE = 32;
+#pragma pack(1)
+		
+		struct LoginInfo_Struct {
+			/*000*/	char	login_info[64];
+			/*064*/	uint8	unknown064[124];
+			/*188*/	uint8	zoning;			// 01 if zoning, 00 if not
+			/*189*/	uint8	unknown189[275];
+			/*488*/
+		};
+
+		struct ClientZoneEntry_Struct {
+			/*00*/ uint32	unknown00;	// ***Placeholder
+			/*04*/ char	char_name[64];	// Player firstname [32]
+			/*68*/ uint32	unknown68;
+			/*72*/ uint32	unknown72;
+			/*76*/ uint32	unknown76;
+			/*80*/ uint32	unknown80;
+			/*84*/ uint32	unknown84;
+			/*88*/ uint32	unknown88;
+			/*92*/
+		};
+
+		struct Membership_Struct
+		{
+			/*000*/ uint8 membership; //0 not gold, 2 gold
+			/*001*/ uint32 races;	// Seen ff ff 01 00
+			/*005*/ uint32 classes;	// Seen ff ff 01 00
+			/*009*/ uint32 entrysize; // Seen 33
+			/*013*/ int32 entries[33]; // Most -1, 1, and 0 for Gold Status
+			/*145*/
+		};
+
+		struct Membership_Entry_Struct
+		{
+			/*000*/ uint32 purchase_id;		// Seen 1, then increments 90287 to 90300
+			/*004*/ uint32 bitwise_entry;	// Seen 16 to 65536 - Skips 4096
+			/*008*/
+		};
+
+		struct Membership_Setting_Struct
+		{
+			/*000*/ int8 setting_index;	// 0, 1, 2 or 3: f2p, silver, gold, platinum?
+			/*001*/ int32 setting_id;		// 0 to 23 actually seen but the OP_Membership packet has up to 32
+			/*005*/ int32 setting_value;	
+			/*009*/
+		};
+
+		struct Membership_Details_Struct
+		{
+			/*000*/ uint32 membership_setting_count;	// Seen 96
+			/*004*/ Membership_Setting_Struct settings[96]; // 864 Bytes
+			/*364*/ uint32 race_entry_count;	// Seen 17
+			/*368*/ Membership_Entry_Struct membership_races[17]; // 136 Bytes
+			/*3f0*/ uint32 class_entry_count;	// Seen 15
+			/*3f4*/ Membership_Entry_Struct membership_classes[17]; // 136 Bytes
+			/*47c*/ uint32 exit_url_length;	// Length of the exit_url string (0 for none)
+			/*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*/
+		};
+
+		struct ExpansionInfo_Struct {
+			/*000*/	char	Unknown000[64];
+			/*064*/	uint32	Expansions;
+		};
+
+		/*
+		* Visible equiptment.
+		* Size: 20 Octets
+		*/
+		struct Texture_Struct
+		{
+			uint32 Material;
+			uint32 Unknown1;
+			uint32 EliteMaterial;
+			uint32 HeroForgeModel;
+			uint32 Material2;	// Same as material?
+		};
+
+		/*
+		** Color_Struct
+		** Size: 4 bytes
+		** Used for convenience
+		** Merth: Gave struct a name so gcc 2.96 would compile
+		**
+		*/
+		struct Tint_Struct
+		{
+			union {
+				struct {
+					uint8 Blue;
+					uint8 Green;
+					uint8 Red;
+					uint8 UseTint;	// if there's a tint this is FF
+				};
+				uint32 Color;
+			};
+		};
+
+		struct CharSelectEquip : Texture_Struct, Tint_Struct {};
+
+		struct CharacterSelectEntry_Struct
+		{
+			char Name[1];
+			uint32 Class;
+			uint32 Race;
+			uint8 Level;
+			uint32 ShroudClass;
+			uint32 ShroudRace;
+			uint16 Zone;
+			uint16 Instance;
+			uint8 Gender;
+			uint8 Face;
+			CharSelectEquip Equip[9];
+			uint8 Unknown1; //Seen 256
+			uint8 Unknown2; //Seen 0
+			uint32 DrakkinTattoo;
+			uint32 DrakkinDetails;
+			uint32 Deity;
+			uint32 PrimaryIDFile;
+			uint32 SecondaryIDFile;
+			uint8 HairColor;
+			uint8 BeardColor;
+			uint8 EyeColor1;
+			uint8 EyeColor2;
+			uint8 HairStyle;
+			uint8 Beard;
+			uint8 Enabled;
+			uint8 Tutorial;
+			uint32 DrakkinHeritage;
+			uint8 Unknown3;
+			uint8 GoHome;
+			uint32 LastLogin;
+			uint8 Unknown4; // Seen 0
+			uint8 Unknown5; // Seen 0
+			uint8 Unknown6; // Seen 0
+			uint8 Unknown7; // Seen 0
+			uint32 CharacterId; //A Guess, Character I made a little bit after has a number a few hundred after the first
+			uint32 Unknown8; // Seen 1
+		};
+
+		/*
+		** Character Selection Struct
+		**
+		*/
+		struct CharacterSelect_Struct
+		{
+			/*000*/	uint32 CharCount;	//number of chars in this packet
+		};
+
+		struct SpawnAppearance_Struct
+		{
+			/*0000*/ uint32 spawn_id;		// ID of the spawn
+			/*0004*/ uint32 type;			// Values associated with the type
+			/*0008*/ uint32 parameter;		// Type of data sent
+			/*0012*/ uint32 unknown012;
+			/*0016*/ uint32 unknown016;
+			/*0020*/ uint32 unknown020;
+			/*0024*/
+		};
+
+		struct Spawn_Struct_Bitfields
+		{
+			// byte 1
+			/*00*/	unsigned   gender : 2;		// Gender (0=male, 1=female, 2=monster)
+			/*02*/	unsigned   ispet : 1;			// Guessed based on observing live spawns
+			/*03*/	unsigned   afk : 1;			// 0=no, 1=afk
+			/*04*/	unsigned   anon : 2;			// 0=normal, 1=anon, 2=roleplay
+			/*06*/	unsigned   gm : 1;
+			/*07*/	unsigned   sneak : 1;
+			// byte 2
+			/*08*/	unsigned   lfg : 1;
+			/*09*/	unsigned   unk9 : 1;
+			/*10*/	unsigned   invis : 12;		// there are 3000 different (non-GM) invis levels
+			/*22*/	unsigned   linkdead : 1;		// 1 Toggles LD on or off after name. Correct for RoF2
+			/*23*/	unsigned   showhelm : 1;
+			// byte 4
+			/*24*/	unsigned   betabuffed : 1;		// Prefixes name with !
+			/*25*/	unsigned   trader : 1;
+			/*26*/	unsigned   animationonpop : 1;
+			/*27*/	unsigned   targetable : 1;
+			/*28*/	unsigned   targetable_with_hotkey : 1;
+			/*29*/	unsigned   showname : 1;
+			/*30*/	unsigned   idleanimationsoff : 1; // what we called statue?
+			/*31*/	unsigned   untargetable : 1;	// bClickThrough
+			// byte 5
+			/*32*/	unsigned   buyer : 1;
+			/*33*/	unsigned   offline : 1;
+			/*34*/	unsigned   interactiveobject : 1;
+			/*35*/	unsigned   missile : 1;
+			/*36*/	unsigned   title : 1;
+			/*37*/	unsigned   suffix : 1;
+			/*38*/	unsigned   unk38 : 1;
+			/*39*/	unsigned   unk39 : 1;
+		};
+#pragma pack()
+
+	};	//end namespace structs
+};	//end namespace larion
+
+#endif /*LARION_STRUCTS_H_*/

common/patches/patches.cpp

@@ -26,7 +26,7 @@
 #include "sod.h"
 #include "rof.h"
 #include "rof2.h"
-
+#include "larion.h"
 
 void RegisterAllPatches(EQStreamIdentifier &into)
 {
@@ -36,6 +36,7 @@ void RegisterAllPatches(EQStreamIdentifier &into)
 	UF::Register(into);
 	RoF::Register(into);
 	RoF2::Register(into);
+	Larion::Register(into);
 }
 
 void ReloadAllPatches()
@@ -46,4 +47,5 @@ void ReloadAllPatches()
 	UF::Reload();
 	RoF::Reload();
 	RoF2::Reload();
+	Larion::Reload();
 }

common/patches/rof2.cpp

@@ -2680,7 +2680,7 @@ namespace RoF2
 		{
 			float instrument_mod = 0.0f;
 			uint8 effect_type = emu->buffs[r].effect_type;
-			uint32 player_id = emu->buffs[r].player_id;;
+			uint32 player_id = emu->buffs[r].player_id;
 
 			if (emu->buffs[r].spellid != 0xFFFF && emu->buffs[r].spellid != 0)
 			{

common/repositories/buyer_buy_lines_repository.h

@@ -236,6 +236,10 @@ public:
 				)
 			);
 
+			if (buyers.empty()) {
+				return all_entries;
+			}
+
 			std::vector<std::string> char_ids{};
 			for (auto const &bl : buyers) {
 				char_ids.push_back((std::to_string(bl.char_id)));

common/repositories/buyer_repository.h

@@ -120,6 +120,10 @@ public:
 			}
 
 			DeleteWhere(db, fmt::format("`char_id` = '{}';", char_id));
+			if (buy_line_ids.empty()) {
+				return false;
+			}
+
 			BaseBuyerBuyLinesRepository::DeleteWhere(
 				db,
 				fmt::format("`id` IN({})", Strings::Implode(", ", buy_line_ids))

common/repositories/trader_repository.h

@@ -217,6 +217,10 @@ public:
 			delete_ids.push_back(std::to_string(e.id));
 		}
 
+		if (delete_ids.empty()) {
+			return 0;
+		}
+
 		return DeleteWhere(db, fmt::format("`id` IN({})", Strings::Implode(",", delete_ids)));
 	}
 };

common/ruletypes.h

@@ -338,6 +338,8 @@ RULE_STRING(World, IPExemptionZones, "", "Comma-delimited list of zones to exclu
 RULE_STRING(World, MOTD, "", "Server MOTD sent on login, change from empty to have this be used instead of variables table 'motd' value")
 RULE_STRING(World, Rules, "", "Server Rules, change from empty to have this be used instead of variables table 'rules' value, lines are pipe (|) separated, example: A|B|C")
 RULE_BOOL(World, EnableAutoLogin, false, "Enables or disables auto login of characters, allowing people to log characters in directly from loginserver to ingame")
+RULE_BOOL(World, EnablePVPRegions, true, "Enables or disables PVP Regions automatically setting your PVP flag")
+RULE_INT(World, Id, 100, "Used by later clients to create GUIDs, expected to be Unique to the world but ultimately not that important")
 RULE_CATEGORY_END()
 
 RULE_CATEGORY(Zone)

loginserver/client.cpp

@@ -573,10 +573,13 @@ void Client::SendExpansionPacketData(PlayerLoginReply_Struct& plrs)
 {
 	SerializeBuffer buf;
 	//from eqlsstr_us.txt id of each expansion, excluding 'Everquest'
-	int ExpansionLookup[20] = { 3007, 3008, 3009, 3010,	3012,
+	int ExpansionLookup[30] = { 3007, 3008, 3009, 3010,	3012,
 								3014, 3031, 3033, 3036, 3040,
 								3045, 3046, 3047, 3514, 3516,
-								3518, 3520, 3522, 3524 };
+								3518, 3520, 3522, 3524, 3526,
+								3528, 3530, 3532, 3534, 3535,
+								3536, 3537, 3538, 3539, 3540
+	};
 
 
 	if (server.options.IsDisplayExpansions()) {
@@ -584,7 +587,26 @@ void Client::SendExpansionPacketData(PlayerLoginReply_Struct& plrs)
 		int32_t expansion = server.options.GetMaxExpansions();
 		int32_t owned_expansion = (expansion << 1) | 1;
 
-		if (m_client_version == cv_sod) {
+		if (m_client_version == cv_larion) {
+			buf.WriteInt32(0x00);
+			buf.WriteInt32(0x00);
+			buf.WriteInt16(0x00);
+			buf.WriteInt32(30);
+
+			for (int i = 0; i < 30; i++)
+			{
+				buf.WriteUInt32(i + 1);
+				buf.WriteUInt8(1);
+				buf.WriteInt32(ExpansionLookup[i]);
+				buf.WriteInt32(6046);
+				buf.WriteUInt32(0xFFFFFFFF);
+				buf.WriteUInt32(0);
+			}
+
+			auto out = std::make_unique<EQApplicationPacket>(OP_LoginExpansionPacketData, buf);
+			m_connection->QueuePacket(out.get());
+		}
+		else if (m_client_version == cv_sod) {
 
 			// header info of packet.  Requires OP_LoginExpansionPacketData=0x0031 to be in login_opcodes_sod.conf
 			buf.WriteInt32(0x00);

loginserver/world_server.cpp

@@ -977,8 +977,7 @@ bool WorldServer::ValidateWorldServerAdminLogin(
 	return false;
 }
 
-void WorldServer::SerializeForClientServerList(SerializeBuffer& out, bool use_local_ip, LSClientVersion version) const
-{
+void WorldServer::SerializeForClientServerListLegacy(class SerializeBuffer& out, bool use_local_ip) const {
 	// see LoginClientServerData_Struct
 	if (use_local_ip) {
 		out.WriteString(GetLocalIP());
@@ -987,10 +986,6 @@ void WorldServer::SerializeForClientServerList(SerializeBuffer& out, bool use_lo
 		out.WriteString(GetRemoteIP());
 	}
 
-	if (version == cv_larion) {
-		out.WriteUInt32(9000);
-	}
-
 	switch (GetServerListID()) {
 	case LS::ServerType::Legends:
 		out.WriteInt32(LS::ServerTypeFlags::Legends);
@@ -1002,15 +997,8 @@ void WorldServer::SerializeForClientServerList(SerializeBuffer& out, bool use_lo
 		out.WriteInt32(LS::ServerTypeFlags::Standard);
 		break;
 	}
-	if (version == cv_larion) {
-		auto server_id = GetServerId();
-		//if this is 0, the client will not show the server in the list
-		out.WriteUInt32(1);
-		out.WriteUInt32(server_id);
-	}
-	else {
-		out.WriteUInt32(GetServerId());
-	}
+
+	out.WriteUInt32(GetServerId());
 
 	out.WriteString(GetServerLongName());
 	out.WriteString("us"); // country code
@@ -1032,6 +1020,61 @@ void WorldServer::SerializeForClientServerList(SerializeBuffer& out, bool use_lo
 	out.WriteUInt32(GetPlayersOnline());
 }
 
+void WorldServer::SerializeForClientServerListLarion(class SerializeBuffer& out, bool use_local_ip) const {
+	if (use_local_ip) {
+		out.WriteString(GetLocalIP());
+	}
+	else {
+		out.WriteString(GetRemoteIP());
+	}
+
+	out.WriteUInt32(9000);
+	out.WriteUInt32(0);
+
+	uint32_t flags = 32; //all servers i saw had this set
+	switch (GetServerListID()) {
+	case LS::ServerType::Legends:
+		flags += LS::ServerTypeFlags::Legends;
+		break;
+	case LS::ServerType::Preferred:
+		flags += LS::ServerTypeFlags::Preferred;
+		break;
+	default:
+		flags += LS::ServerTypeFlags::Standard;
+		break;
+	}
+
+	out.WriteUInt32(flags);
+	out.WriteUInt32(GetServerId());
+	out.WriteString(GetServerLongName());
+	out.WriteString("EN");
+	out.WriteString("US");
+
+	if (GetStatus() < 0) {
+		if (GetZonesBooted() == 0) {
+			out.WriteInt32(LS::ServerStatusFlags::Down);
+		}
+		else {
+			out.WriteInt32(LS::ServerStatusFlags::Locked);
+		}
+	}
+	else {
+		out.WriteInt32(LS::ServerStatusFlags::Up);
+	}
+
+	out.WriteUInt32(GetPlayersOnline());
+}
+
+void WorldServer::SerializeForClientServerList(SerializeBuffer& out, bool use_local_ip, LSClientVersion version) const
+{
+	if (version == cv_larion) {
+		SerializeForClientServerListLarion(out, use_local_ip);
+	}
+	else {
+		SerializeForClientServerListLegacy(out, use_local_ip);
+	}
+}
+
 /**
  * @param in_server_list_id
  * @return

loginserver/world_server.h

@@ -149,7 +149,10 @@ public:
 
 	bool HandleNewLoginserverRegisteredOnly(Database::DbWorldRegistration &world_registration);
 	bool HandleNewLoginserverInfoUnregisteredAllowed(Database::DbWorldRegistration &world_registration);
-
+private:
+	void SerializeForClientServerListLegacy(class SerializeBuffer& out, bool use_local_ip) const;
+	void SerializeForClientServerListLarion(class SerializeBuffer& out, bool use_local_ip) const;
+public:
 	void SerializeForClientServerList(class SerializeBuffer& out, bool use_local_ip, LSClientVersion version) const;
 
 private:

utils/patches/patch_Larion.conf

@@ -0,0 +1,730 @@
+# ShowEQ Import Notes:
+# ZERO THE FILE first
+# perl -pi -e 's/0x[0-9a-fA-F]{4}/0x0000/g' opcodes.conf
+# Unknown Mapping:
+# OP_Action2 -> OP_Damage
+# OP_EnvDamage -> OP_Damage ---> might have been a one time mistake
+# Name Differences:
+# OP_CancelInvite -> OP_GroupCancelInvite
+# OP_GMFind -> OP_FindPersonRequest
+# OP_CommonMessage -> OP_ChannelMessage
+
+OP_Unknown=0x0000
+OP_ExploreUnknown=0x0000	# used for unknown explorer
+
+# world packets
+# Required to reach Char Select:
+OP_SendLoginInfo=0x2fca
+OP_ApproveWorld=0x0000
+OP_LogServer=0x6d4d
+OP_SendCharInfo=0x832
+OP_ExpansionInfo=0x066d
+OP_GuildsList=0x0000
+OP_EnterWorld=0x6691
+OP_PostEnterWorld=0x2062
+OP_World_Client_CRC1=0x74c8
+OP_World_Client_CRC2=0x3984
+OP_World_Client_CRC3=0x6516
+OP_SendSpellChecksum=0x0000
+OP_SendSkillCapsChecksum=0x0000
+
+# Character Select Related:
+OP_SendMaxCharacters=0x13af
+OP_SendMembership=0x2aca
+OP_SendMembershipDetails=0x2608
+OP_CharacterCreateRequest=0x0000
+OP_CharacterCreate=0x0000
+OP_DeleteCharacter=0x0000
+OP_RandomNameGenerator=0x0000
+OP_ApproveName=0x0000
+OP_MOTD=0x0000
+OP_SetChatServer=0x2726
+OP_SetChatServer2=0x0000
+OP_ZoneServerInfo=0x2273
+OP_WorldComplete=0x195c
+OP_WorldUnknown001=0x2049
+OP_FloatListThing=0x0000
+
+# Reasons for Disconnect:
+OP_ZoneUnavail=0x0000
+OP_WorldClientReady=0x0000
+OP_CharacterStillInZone=0x0000
+OP_WorldChecksumFailure=0x0000
+OP_WorldLoginFailed=0x0000
+OP_WorldLogout=0x0000
+OP_WorldLevelTooHigh=0x0000
+OP_CharInacessable=0x0000
+OP_UserCompInfo=0x0000
+OP_SendExeChecksum=0x0000
+OP_SendBaseDataChecksum=0x0000
+
+# Zone in opcodes
+OP_AckPacket=0x77c9
+OP_ZoneEntry=0x0000
+OP_ReqNewZone=0x0000
+OP_NewZone=0x0000
+OP_ZoneSpawns=0x0000
+OP_PlayerProfile=0x0000
+OP_TimeOfDay=0x0000
+OP_LevelUpdate=0x0000
+OP_Stamina=0x0000
+OP_RequestClientZoneChange=0x0000
+OP_ZoneChange=0x0000
+OP_LockoutTimerInfo=0x0000
+OP_ZoneServerReady=0x0000
+OP_ZoneInUnknown=0x0000
+OP_LogoutReply=0x0000
+OP_PreLogoutReply=0x0000
+
+# Required to fully log in
+OP_SpawnAppearance=0x0000
+OP_ChangeSize=0x0000
+OP_TributeUpdate=0x0000
+OP_TributeTimer=0x0000
+OP_SendTributes=0x0000
+OP_RequestGuildTributes=0x0000
+OP_TributeInfo=0x0000
+OP_Weather=0x0000
+OP_ReqClientSpawn=0x0000
+OP_SpawnDoor=0x0000
+OP_GroundSpawn=0x0000
+OP_SendZonepoints=0x0000
+OP_BlockedBuffs=0x0000
+OP_RemoveBlockedBuffs=0x0000
+OP_ClearBlockedBuffs=0x0000
+OP_WorldObjectsSent=0x0000
+OP_SendExpZonein=0x0000
+OP_SendAATable=0x0000
+OP_ClearAA=0x0000
+OP_ClearLeadershipAbilities=0x0000
+OP_RespondAA=0x0000
+OP_UpdateAA=0x0000
+OP_SendAAStats=0x0000
+OP_AAExpUpdate=0x0000
+OP_ExpUpdate=0x0000
+OP_HPUpdate=0x0000
+OP_ManaChange=0x0000
+OP_TGB=0x0000
+OP_SpecialMesg=0x0000
+OP_GuildMemberList=0x0000
+OP_GuildMOTD=0x0000
+OP_CharInventory=0x0000
+OP_WearChange=0x0000
+OP_ClientUpdate=0x0000
+OP_ClientReady=0x0000
+OP_SetServerFilter=0x0000
+
+# Guild Opcodes
+OP_GetGuildMOTD=0x0000
+OP_GetGuildMOTDReply=0x0000
+OP_GuildMemberUpdate=0x0000
+OP_GuildInvite=0x0000
+OP_GuildRemove=0x0000
+OP_GuildPeace=0x0000
+OP_SetGuildMOTD=0x0000
+OP_GuildWar=0x0000
+OP_GuildLeader=0x0000
+OP_GuildDelete=0x0000
+OP_GuildInviteAccept=0x0000
+OP_GuildDemote=0x0000
+OP_GuildPromote=0x0000
+OP_GuildPublicNote=0x0000
+OP_GuildManageBanker=0x0000
+OP_GuildBank=0x0000
+OP_GuildBankItemList=0x0000
+OP_SetGuildRank=0x0000
+OP_GuildUpdate=0x0000
+OP_GuildStatus=0x0000
+OP_GuildCreate=0x0000
+OP_GuildOpenGuildWindow=0x0000
+OP_GuildMemberLevel=0x0000
+OP_GuildMemberRankAltBanker=0x0000
+OP_GuildMemberPublicNote=0x0000
+OP_GuildMemberAdd=0x0000
+OP_GuildMemberRename=0x0000
+OP_GuildMemberDelete=0x0000
+OP_GuildMemberDetails=0x0000
+OP_GuildRenameGuild=0x0000
+OP_LFGuild=0x0000
+OP_GuildDeleteGuild=0x0000
+
+# GM/Guide Opcodes
+OP_GMServers=0x0000
+OP_GMBecomeNPC=0x0000
+OP_GMZoneRequest=0x0000
+OP_GMZoneRequest2=0x0000
+OP_GMGoto=0x0000
+OP_GMSearchCorpse=0x0000
+OP_GMHideMe=0x0000
+OP_GMDelCorpse=0x0000
+OP_GMApproval=0x0000
+OP_GMToggle=0x0000
+OP_GMSummon=0x0000
+OP_GMEmoteZone=0x0000
+OP_GMEmoteWorld=0x0000
+OP_GMFind=0x0000
+OP_GMKick=0x0000
+OP_GMKill=0x0000
+OP_GMNameChange=0x0000
+OP_GMLastName=0x0000
+
+# Misc Opcodes
+OP_QueryUCSServerStatus=0x0000
+OP_InspectRequest=0x0000
+OP_InspectAnswer=0x0000
+OP_InspectMessageUpdate=0x0000
+OP_BeginCast=0x0000
+OP_ColoredText=0x0000
+OP_ConsentResponse=0x0000
+OP_MemorizeSpell=0x0000
+OP_LinkedReuse=0x0000
+OP_SwapSpell=0x0000
+OP_CastSpell=0x0000
+OP_Consider=0x0000
+OP_FormattedMessage=0x0000
+OP_SimpleMessage=0x0000
+OP_Buff=0x0000
+OP_Illusion=0x0000
+OP_MoneyOnCorpse=0x0000
+OP_RandomReply=0x0000
+OP_DenyResponse=0x0000
+OP_SkillUpdate=0x04c
+OP_GMTrainSkillConfirm=0x0000
+OP_RandomReq=0x0000
+OP_Death=0x0000
+OP_GMTraining=0x0000
+OP_GMEndTraining=0x0000
+OP_GMTrainSkill=0x0000
+OP_Animation=0x0000
+OP_Begging=0x0000
+OP_Consent=0x0000
+OP_ConsentDeny=0x0000
+OP_AutoFire=0x0000
+OP_PetCommands=0x0000
+OP_PetCommandState=0x0000
+OP_PetHoTT=0x0000
+OP_DeleteSpell=0x0000
+OP_Surname=0x0000
+OP_ClearSurname=0x0000
+OP_FaceChange=0x0000
+OP_SetFace=0x0000
+OP_SenseHeading=0x0000
+OP_Action=0x0000
+OP_ConsiderCorpse=0x0000
+OP_HideCorpse=0x0000
+OP_CorpseDrag=0x0000
+OP_CorpseDrop=0x0000
+OP_Bug=0x0000
+OP_Feedback=0x0000
+OP_Report=0x0000
+OP_Damage=0x0000
+OP_ChannelMessage=0x0000
+OP_Assist=0x0000
+OP_AssistGroup=0x0000
+OP_MoveCoin=0x0000
+OP_ZonePlayerToBind=0x0000
+OP_KeyRing=0x0000
+OP_WhoAllRequest=0x0000
+OP_WhoAllResponse=0x0000
+OP_FriendsWho=0x0000
+OP_ConfirmDelete=0x0000
+OP_Logout=0x0000
+OP_Rewind=0x0000
+OP_TargetCommand=0x0000
+OP_Hide=0x0000
+OP_Jump=0x0000
+OP_Camp=0x0000
+OP_Emote=0x0000
+OP_SetRunMode=0x0000
+OP_BankerChange=0x0000
+OP_TargetMouse=0x0000
+OP_MobHealth=0x0000
+OP_InitialMobHealth=0x0000	# Unused?
+OP_TargetHoTT=0x0000
+OP_TargetBuffs=0x0000
+OP_XTargetResponse=0x0000
+OP_XTargetRequest=0x0000
+OP_XTargetAutoAddHaters=0x0000
+OP_XTargetOpen=0x0000
+OP_XTargetOpenResponse=0x0000
+OP_BuffCreate=0x0000
+OP_BuffRemoveRequest=0x0000
+OP_DeleteSpawn=0x0000
+OP_AutoAttack=0x0000
+OP_AutoAttack2=0x0000
+OP_Consume=0x0000
+OP_MoveItem=0x0000
+OP_MoveMultipleItems=0x0000
+OP_DeleteItem=0x0000
+OP_DeleteCharge=0x0000
+OP_ItemPacket=0x0000
+OP_ItemLinkResponse=0x0000
+OP_ItemLinkClick=0x0000
+OP_ItemPreview=0x0000
+OP_NewSpawn=0x0000
+OP_Track=0x0000
+OP_TrackTarget=0x0000
+OP_TrackUnknown=0x0000
+OP_ClickDoor=0x0000
+OP_MoveDoor=0x0000
+OP_RemoveAllDoors=0x0000
+OP_EnvDamage=0x0000
+OP_BoardBoat=0x0000
+OP_LeaveBoat=0x0000
+OP_ControlBoat=0x0000
+OP_Forage=0x0000
+OP_SafeFallSuccess=0x0000
+OP_RezzComplete=0x0000
+OP_RezzRequest=0x0000
+OP_RezzAnswer=0x0000
+OP_Shielding=0x0000
+OP_RequestDuel=0x0000
+OP_MobRename=0x0000
+OP_AugmentItem=0x0000
+OP_WeaponEquip1=0x0000
+OP_PlayerStateAdd=0x0000
+OP_PlayerStateRemove=0x0000
+OP_ApplyPoison=0x0000
+OP_Save=0x0000
+OP_TestBuff=0x0000
+OP_CustomTitles=0x0000
+OP_Split=0x0000
+OP_YellForHelp=0x0000
+OP_LoadSpellSet=0x0000
+OP_Bandolier=0x0000
+OP_PotionBelt=0x0000
+OP_DuelDecline=0x0000
+OP_DuelAccept=0x0000
+OP_SaveOnZoneReq=0x0000
+OP_ReadBook=0x0000
+OP_Dye=0x0000
+OP_InterruptCast=0x0000
+OP_AAAction=0x0000
+OP_LeadershipExpToggle=0x0000
+OP_LeadershipExpUpdate=0x0000
+OP_PurchaseLeadershipAA=0x0000
+OP_UpdateLeadershipAA=0x0000
+OP_MarkNPC=0x0000
+OP_ClearNPCMarks=0x0000
+OP_DelegateAbility=0x0000
+OP_SetGroupTarget=0x0000
+OP_Charm=0x0000
+OP_Stun=0x0000
+OP_SendFindableNPCs=0x0000
+OP_FindPersonRequest=0x0000
+OP_FindPersonReply=0x0000
+OP_Sound=0x0000
+OP_CashReward=0x0000
+OP_PetBuffWindow=0x0000
+OP_LevelAppearance=0x0000
+OP_Translocate=0x0000
+OP_Sacrifice=0x0000
+OP_PopupResponse=0x0000
+OP_OnLevelMessage=0x0000
+OP_AugmentInfo=0x0000
+OP_Petition=0x0000
+OP_SomeItemPacketMaybe=0x0000
+OP_PVPStats=0x0000
+OP_PVPLeaderBoardRequest=0x0000
+OP_PVPLeaderBoardReply=0x0000
+OP_PVPLeaderBoardDetailsRequest=0x0000
+OP_PVPLeaderBoardDetailsReply=0x0000
+OP_RestState=0x0000
+OP_RespawnWindow=0x0000
+OP_LDoNButton=0x0000
+OP_SetStartCity=0x0000
+OP_VoiceMacroIn=0x0000
+OP_VoiceMacroOut=0x0000
+OP_ItemViewUnknown=0x0000
+OP_VetRewardsAvaliable=0x0000
+OP_VetClaimRequest=0x0000
+OP_VetClaimReply=0x0000
+OP_DisciplineUpdate=0x0000
+OP_DisciplineTimer=0x0000
+OP_BecomeCorpse=0x0000			# Unused?
+OP_Action2=0x0000				# Unused?
+OP_MobUpdate=0x0000
+OP_NPCMoveUpdate=0x0000
+OP_CameraEffect=0x0000
+OP_SpellEffect=0x0000
+OP_AddNimbusEffect=0x0000
+OP_RemoveNimbusEffect=0x0000
+OP_AltCurrency=0x0000
+OP_AltCurrencyMerchantRequest=0x0000
+OP_AltCurrencyMerchantReply=0x0000
+OP_AltCurrencyPurchase=0x0000
+OP_AltCurrencySell=0x0000
+OP_AltCurrencySellSelection=0x0000
+OP_AltCurrencyReclaim=0x0000
+OP_CrystalCountUpdate=0x0000
+OP_CrystalCreate=0x0000
+OP_CrystalReclaim=0x0000
+OP_Untargetable=0x0000
+OP_IncreaseStats=0x0000
+OP_Weblink=0x0000
+OP_OpenContainer=0x0000
+OP_Marquee=0x0000
+OP_ItemRecastDelay=0x0000
+#OP_OpenInventory=0x0000			# Likely does not exist in RoF -U
+OP_ResetAA=0x0000
+OP_Fling=0x0000
+OP_CancelSneakHide=0x0000
+OP_AggroMeterLockTarget=0x0000
+OP_AggroMeterTargetInfo=0x0000
+OP_AggroMeterUpdate=0x0000
+OP_UnderWorld=0x0000			# clients sends up when they detect an underworld issue, might be useful for cheat detection
+OP_KickPlayers=0x0000
+OP_BookButton=0x0000
+
+# Expeditions
+OP_DzQuit=0x0000
+OP_DzListTimers=0x0000
+OP_DzAddPlayer=0x0000
+OP_DzRemovePlayer=0x0000
+OP_DzSwapPlayer=0x0000
+OP_DzMakeLeader=0x0000
+OP_DzPlayerList=0x0000
+OP_DzExpeditionInvite=0x0000
+OP_DzExpeditionInviteResponse=0x0000
+OP_DzExpeditionInfo=0x0000
+OP_DzExpeditionLockoutTimers=0x0000
+OP_DzMemberList=0x0000
+OP_DzMemberListName=0x0000
+OP_DzMemberListStatus=0x0000
+OP_DzSetLeaderName=0x0000
+OP_DzExpeditionEndsWarning=0x0000
+OP_DzCompass=0x0000
+OP_DzChooseZone=0x0000
+OP_DzChooseZoneReply=0x0000
+
+# New Opcodes
+OP_SpawnPositionUpdate=0x0000	# Actually OP_MobUpdate ?
+OP_ManaUpdate=0x0000
+OP_EnduranceUpdate=0x0000
+OP_MobManaUpdate=0x0000
+OP_MobEnduranceUpdate=0x0000
+
+# Mercenary Opcodes
+OP_MercenaryDataUpdateRequest=0x0000
+OP_MercenaryDataUpdate=0x0000
+OP_MercenaryDataRequest=0x0000
+OP_MercenaryDataResponse=0x0000
+OP_MercenaryHire=0x0000
+OP_MercenaryDismiss=0x0000
+OP_MercenaryTimerRequest=0x0000
+OP_MercenaryTimer=0x0000
+OP_MercenaryUnknown1=0x0000
+OP_MercenaryCommand=0x0000
+OP_MercenarySuspendRequest=0x0000
+OP_MercenarySuspendResponse=0x0000
+OP_MercenaryUnsuspendResponse=0x0000
+
+# Looting
+OP_LootRequest=0x0000
+OP_EndLootRequest=0x0000
+OP_LootItem=0x0000
+OP_LootComplete=0x0000
+
+# bazaar trader stuff:
+OP_BazaarSearch=0x0000
+OP_TraderDelItem=0x0000
+OP_BecomeTrader=0x0000
+OP_TraderShop=0x0000
+OP_TraderBulkSend=0x0000
+OP_Trader=0x0000
+OP_Barter=0x0000
+OP_BuyerItems=0x0000
+OP_TraderBuy=0x0000
+OP_ShopItem=0x0000
+OP_BazaarInspect=0x0000
+OP_Bazaar=0x0000
+OP_TraderItemUpdate=0x0000
+
+# pc/npc trading
+OP_TradeRequest=0x0000
+OP_TradeAcceptClick=0x0000
+OP_TradeRequestAck=0x0000
+OP_TradeCoins=0x0000
+OP_FinishTrade=0x0000
+OP_CancelTrade=0x0000
+OP_TradeMoneyUpdate=0x0000
+OP_MoneyUpdate=0x0000
+OP_TradeBusy=0x0000
+
+# Sent after canceling trade or after closing tradeskill object
+OP_FinishWindow=0x0000
+OP_FinishWindow2=0x0000
+
+# Sent on Live for what seems to be item existance verification
+# Ex. Before Right Click Effect happens from items
+OP_ItemVerifyRequest=0x0000
+OP_ItemVerifyReply=0x0000
+
+OP_ItemAdvancedLoreText=0x0000
+
+# merchant stuff
+OP_ShopPlayerSell=0x0000
+OP_ShopRequest=0x0000
+OP_ShopEnd=0x0000
+OP_ShopEndConfirm=0x0000
+OP_ShopPlayerBuy=0x0000
+OP_ShopDelItem=0x0000
+OP_ShopSendParcel=0x0000
+OP_ShopDeleteParcel=0x0000
+OP_ShopRetrieveParcel=0x0000
+OP_ShopParcelIcon=0x0000
+
+# tradeskill stuff:
+OP_ClickObject=0x0000
+OP_ClickObjectAction=0x0000
+OP_ClearObject=0x0000
+OP_RecipeDetails=0x0000
+OP_RecipesFavorite=0x0000
+OP_RecipesSearch=0x0000
+OP_RecipeReply=0x0000
+OP_RecipeAutoCombine=0x0000
+OP_TradeSkillCombine=0x0000
+
+# Tribute Packets:
+OP_OpenTributeMaster=0x0000
+OP_SelectTribute=0x0000
+OP_TributeItem=0x0000
+OP_TributeMoney=0x0000
+OP_TributeToggle=0x0000
+OP_TributePointUpdate=0x0000
+OP_TributeNPC=0x0000
+OP_GuildTributeInfo=0x0000
+OP_OpenTributeReply=0x0000
+OP_GuildTributeStatus=0x0000
+OP_GuildSaveActiveTributes=0x0000
+OP_GuildSendActiveTributes=0x0000
+OP_GuildTributeToggleReq=0x0000
+OP_GuildTributeToggleReply=0x0000
+OP_GuildTributeFavorAndTimer=0x0000
+OP_GuildTributeDonateItem=0x0000
+OP_GuildTributeDonatePlat=0x0000
+OP_GuildSelectTribute=0x0000
+OP_GuildModifyBenefits=0x0000
+OP_GuildOptInOut=0x0000
+OP_SendGuildTributes=0x0000
+OP_OpenGuildTributeMaster=0x0000
+
+# Adventure packets:
+OP_LeaveAdventure=0x0000
+OP_AdventureFinish=0x0000
+OP_AdventureInfoRequest=0x0000
+OP_AdventureInfo=0x0000
+OP_AdventureRequest=0x0000
+OP_AdventureDetails=0x0000
+OP_AdventureData=0x0000
+OP_AdventureUpdate=0x0000
+OP_AdventureMerchantRequest=0x0000
+OP_AdventureMerchantResponse=0x0000
+OP_AdventureMerchantPurchase=0x0000
+OP_AdventureMerchantSell=0x0000
+OP_AdventurePointsUpdate=0x0000
+OP_AdventureStatsRequest=0x0000
+OP_AdventureStatsReply=0x0000
+OP_AdventureLeaderboardRequest=0x0000
+OP_AdventureLeaderboardReply=0x0000
+
+# Group Opcodes
+OP_GroupDisband=0x0000
+OP_GroupInvite=0x0000
+OP_GroupFollow=0x0000
+OP_GroupUpdate=0x0000
+OP_GroupUpdateB=0x0000
+OP_GroupCancelInvite=0x0000
+OP_GroupAcknowledge=0x0000
+OP_GroupDelete=0x0000
+OP_CancelInvite=0x0000
+OP_GroupFollow2=0x0000
+OP_GroupInvite2=0x0000
+OP_GroupDisbandYou=0x0000
+OP_GroupDisbandOther=0x0000
+OP_GroupLeaderChange=0x0000
+OP_GroupRoles=0x0000
+OP_GroupMakeLeader=0x0000
+OP_DoGroupLeadershipAbility=0x0000
+OP_GroupLeadershipAAUpdate=0x0000
+OP_GroupMentor=0x0000
+OP_InspectBuffs=0x0000
+
+# LFG/LFP Opcodes
+OP_LFGCommand=0x0000
+OP_LFGGetMatchesRequest=0x0000
+OP_LFGGetMatchesResponse=0x0000
+OP_LFPGetMatchesRequest=0x0000
+OP_LFPGetMatchesResponse=0x0000
+OP_LFPCommand=0x0000
+OP_LFGAppearance=0x0000
+OP_LFGResponse=0x0000
+
+# Raid Opcodes
+OP_RaidInvite=0x0000
+OP_RaidUpdate=0x0000
+OP_RaidJoin=0x0000
+OP_RaidDelegateAbility=0x0000
+OP_MarkRaidNPC=0x0000
+OP_RaidClearNPCMarks=0x0000							 
+
+# Button-push commands
+OP_Taunt=0x0000
+OP_CombatAbility=0x0000
+OP_SenseTraps=0x0000
+OP_PickPocket=0x0000
+OP_DisarmTraps=0x0000
+OP_Disarm=0x0000
+OP_Sneak=0x0000
+OP_Fishing=0x0000
+OP_InstillDoubt=0x0000
+OP_FeignDeath=0x0000
+OP_Mend=0x0000
+OP_Bind_Wound=0x0000
+OP_LDoNOpen=0x0000
+#OP_LDoNDisarmTraps=  #Same as OP_DisarmTraps in RoF
+OP_LDoNPickLock=0x0000
+OP_LDoNInspect=0x0000
+
+# Task packets
+OP_TaskDescription=0x0000
+OP_TaskActivity=0x0000
+OP_CompletedTasks=0x0000
+OP_TaskActivityComplete=0x0000
+OP_AcceptNewTask=0x0000
+OP_CancelTask=0x0000
+OP_AvaliableTask=0x0000
+OP_TaskHistoryRequest=0x0000
+OP_TaskHistoryReply=0x0000
+OP_DeclineAllTasks=0x0000
+OP_TaskRequestTimer=0x0000
+OP_TaskSelectWindow=0x0000
+
+# Shared Tasks
+OP_SharedTaskMemberList=0x0000      #
+OP_SharedTaskRemovePlayer=0x0000    # /taskremoveplayer
+OP_SharedTaskAddPlayer=0x0000       # /taskaddplayer
+OP_SharedTaskMakeLeader=0x0000      # /taskmakeleader
+OP_SharedTaskInvite=0x0000          # Dialog window
+OP_SharedTaskInviteResponse=0x0000  # Dialog window response
+OP_SharedTaskAcceptNew=0x0000       #
+OP_SharedTaskMemberChange=0x0000    #
+OP_TaskTimers=0x0000                # /tasktimers
+OP_SharedTaskQuit=0x0000            # /taskquit
+OP_SharedTaskSelectWindow=0x0000
+OP_SharedTaskPlayerList=0x0000      # /taskplayerlist
+
+# Title opcodes
+OP_NewTitlesAvailable=0x0000
+OP_RequestTitles=0x0000
+OP_SendTitleList=0x0000
+OP_SetTitle=0x0000
+OP_SetTitleReply=0x0000
+
+# mail opcodes
+OP_Command=0x0000
+OP_MailboxHeader=0x0000
+OP_MailHeader=0x0000
+OP_MailBody=0x0000
+OP_NewMail=0x0000
+OP_SentConfirm=0x0000
+
+########### Below this point should not be needed ###########
+
+# This section are all unknown in Titanium
+OP_ForceFindPerson=0x0000
+OP_LocInfo=0x0000
+OP_ReloadUI=0x0000
+OP_ItemName=0x0000
+OP_ItemLinkText=0x0000
+OP_MultiLineMsg=0x0000
+OP_MendHPUpdate=0x0000
+OP_TargetReject=0x0000
+OP_SafePoint=0x0000
+OP_ApproveZone=0x0000
+OP_ZoneComplete=0x0000
+OP_ClientError=0x0000
+OP_DumpName=0x0000
+OP_Heartbeat=0x0000
+OP_CrashDump=0x0000
+OP_LoginComplete=0x0000
+
+# discovered opcodes not yet used:
+OP_PickLockSuccess=0x0000
+OP_PlayMP3=0x0000
+OP_ReclaimCrystals=0x0000
+OP_DynamicWall=0x0000
+OP_OpenDiscordMerchant=0x0000
+OP_DiscordMerchantInventory=0x0000
+OP_GiveMoney=0x0000
+OP_RequestKnowledgeBase=0x0000
+OP_KnowledgeBase=0x0000
+OP_SlashAdventure=0x0000 # /adventure
+OP_BecomePVPPrompt=0x0000
+OP_MoveLogRequest=0x0000 # gone I think
+OP_MoveLogDisregard=0x0000 # gone I think
+
+# named unknowns, to make looking for real unknown easier
+OP_AnnoyingZoneUnknown=0x0000
+OP_Some6ByteHPUpdate=0x0000 #seems to happen when you target group members
+OP_QueryResponseThing=0x0000
+
+
+# realityincarnate: these are just here to stop annoying several thousand byte packet dumps
+#OP_LoginUnknown1=0x0000 # OP_SendSpellChecksum
+#OP_LoginUnknown2=0x0000 # OP_SendSkillCapsChecksum
+
+# Petition Opcodes
+OP_PetitionSearch=0x0000 #search term for petition
+OP_PetitionSearchResults=0x0000 #(list of?) matches from search
+OP_PetitionSearchText=0x0000 #text results of search
+
+OP_PetitionUpdate=0x0000
+OP_PetitionCheckout=0x0000
+OP_PetitionCheckIn=0x0000
+OP_PetitionQue=0x0000
+OP_PetitionUnCheckout=0x0000
+OP_PetitionDelete=0x0000
+OP_DeletePetition=0x0000
+OP_PetitionResolve=0x0000
+OP_PDeletePetition=0x0000
+OP_PetitionBug=0x0000
+OP_PetitionRefresh=0x0000
+OP_PetitionCheckout2=0x0000
+OP_PetitionViewPetition=0x0000
+
+# Login opcodes
+OP_SessionReady=0x0000
+OP_Login=0x0000
+OP_ServerListRequest=0x0000
+OP_PlayEverquestRequest=0x0000
+OP_PlayEverquestResponse=0x0000
+OP_ChatMessage=0x0000
+OP_LoginAccepted=0x0000
+OP_ServerListResponse=0x0000
+OP_Poll=0x0000
+OP_EnterChat=0x0000
+OP_PollResponse=0x0000
+
+# raw opcodes
+OP_RAWSessionRequest=0x0000
+OP_RAWSessionResponse=0x0000
+OP_RAWCombined=0x0000
+OP_RAWSessionDisconnect=0x0000
+OP_RAWKeepAlive=0x0000
+OP_RAWSessionStatRequest=0x0000
+OP_RAWSessionStatResponse=0x0000
+OP_RAWPacket=0x0000
+OP_RAWFragment=0x0000
+OP_RAWOutOfOrderAck=0x0000
+OP_RAWAck=0x0000
+OP_RAWAppCombined=0x0000
+OP_RAWOutOfSession=0x0000
+
+# we need to document the differences between these packets to make identifying them easier
+OP_Some3ByteHPUpdate=0x0000 # initial HP update for mobs
+OP_InitialHPUpdate=0x0000
+
+#aura related
+OP_UpdateAura=0x0000
+OP_RemoveTrap=0x0000

utils/stream_parser/common/Daybreak/Connection.cs

@@ -176,6 +176,11 @@ namespace StreamParser.Common.Daybreak
                     case Opcode.SessionResponse:
                         if (_connect_code == 0)
                         {
+                            if(data.Length != 21)
+                            {
+                                return;
+                            }
+
                             _connect_code = BitConverter.ToUInt32(data.Slice(2, 4));
                             _encode_key = IPAddress.NetworkToHostOrder(BitConverter.ToInt32(data.Slice(6, 4)));
                             _crc_bytes = data[10];
@@ -443,27 +448,33 @@ namespace StreamParser.Common.Daybreak
 
         private bool ValidateCRC(ReadOnlySpan<byte> p)
         {
-            if (_crc_bytes == 0)
+            try
             {
-                return true;
-            }
+                if (_crc_bytes == 0)
+                {
+                    return true;
+                }
 
-            int actual = 0;
-            int calculated = _crc_generator.Calculate(p.Slice(0, p.Length - _crc_bytes), _encode_key);
-            switch (_crc_bytes)
+                int actual = 0;
+                int calculated = _crc_generator.Calculate(p.Slice(0, p.Length - _crc_bytes), _encode_key);
+                switch (_crc_bytes)
+                {
+                    case 2:
+                        actual = IPAddress.NetworkToHostOrder(BitConverter.ToInt16(p.Slice(p.Length - 2, 2))) & 0xFFFF;
+                        calculated = calculated & 0xFFFF;
+                        break;
+                    case 4:
+                        actual = IPAddress.NetworkToHostOrder(BitConverter.ToInt32(p.Slice(p.Length - 4, 4)));
+                        break;
+                    default:
+                        return false;
+                }
+
+                return actual == calculated;
+            } catch(Exception ex)
             {
-                case 2:
-                    actual = IPAddress.NetworkToHostOrder(BitConverter.ToInt16(p.Slice(p.Length - 2, 2))) & 0xFFFF;
-                    calculated = calculated & 0xFFFF;
-                    break;
-                case 4:
-                    actual = IPAddress.NetworkToHostOrder(BitConverter.ToInt32(p.Slice(p.Length - 4, 4)));
-                    break;
-                default:
-                    return false;
+                return false;
             }
-
-            return actual == calculated;
         }
 
         private byte[] Decompress(byte[] p, int offset, int length)

utils/stream_parser/common/Daybreak/Parser.cs

@@ -87,6 +87,12 @@ namespace StreamParser.Common.Daybreak
             }
             else if (data[0] == 0 && data[1] == Opcode.SessionRequest)
             {
+                if(data.Length != 24)
+                {
+                    _logger.LogTrace("Tossing packet, {0} was not the right size for a SessionRequest", data.Length);
+                    return;
+                }
+
                 c = new Connection(this, srcAddr, srcPort, dstAddr, dstPort);
                 _connections.Add(c);
                 c.ProcessPacket(srcAddr, srcPort, packetTime, data);

utils/stream_parser/stream_parser/ConsoleHostedService.cs

@@ -57,42 +57,54 @@ namespace StreamParser
             {
                 var args = Environment.GetCommandLineArgs();
 
-                CommandLine.Parser.Default.ParseArguments<ConsoleHostedServiceOptions>(args)
-                   .WithParsed<ConsoleHostedServiceOptions>(o =>
-                   {
-                       _parser.OnNewConnection += OnNewConnection;
-                       _parser.OnLostConnection += OnLostConnection;
-
-                       foreach(var f in o.Input)
+                try
+                {
+                    CommandLine.Parser.Default.ParseArguments<ConsoleHostedServiceOptions>(args)
+                       .WithParsed<ConsoleHostedServiceOptions>(o =>
                        {
-                           _logger.LogInformation("Parsing {0}...", f);
-                           _parser.Parse(f);
-                       }
+                           _parser.OnNewConnection += OnNewConnection;
+                           _parser.OnLostConnection += OnLostConnection;
 
-                       foreach(var c in _connections)
-                       {
-                           if(o.Text)
+                           foreach (var f in o.Input)
                            {
-                               DumpConnectionToTextFile(c.Value, o.Output, o.Decrypt, o.DecompressOpcodes);
+                               _logger.LogInformation("Parsing {0}...", f);
+                               _parser.Parse(f);
                            }
-                       }
 
-                       _applicationLifetime.StopApplication();
-                   })
-                   .WithNotParsed<ConsoleHostedServiceOptions>(e =>
-                   {
-                       bool stops_processing = false;
-                       foreach(var err in e)
-                       {
-                           _logger.LogError("Error: {0}", err.Tag);
-                           stops_processing = stops_processing || err.StopsProcessing;
-                       }
+                           foreach (var c in _connections)
+                           {
+                               if (c.Value.ConnectionType == ConnectionType.Unknown && !o.DumpUnknownStreams)
+                               {
+                                   continue;
+                               }
+
+                               if (o.Text)
+                               {
+                                   DumpConnectionToTextFile(c.Value, o.Output, o.Decrypt, o.DecompressOpcodes);
+                               }
+                           }
 
-                       if(stops_processing)
-                       {
                            _applicationLifetime.StopApplication();
-                       }
-                   });
+                       })
+                       .WithNotParsed<ConsoleHostedServiceOptions>(e =>
+                       {
+                           bool stops_processing = false;
+                           foreach (var err in e)
+                           {
+                               stops_processing = stops_processing || err.StopsProcessing || err is MissingRequiredOptionError;
+                           }
+
+                           if (stops_processing)
+                           {
+                               _applicationLifetime.StopApplication();
+                           }
+                       });
+                } 
+                catch(Exception ex)
+                {
+                    _logger.LogError(ex, "Error parsing command line arguments");
+                    _applicationLifetime.StopApplication();
+                }
             });
 
             return Task.CompletedTask;

utils/stream_parser/stream_parser/ConsoleHostedServiceOptions.cs

@@ -22,5 +22,8 @@ namespace StreamParser
 
         [Option("decompress", Default = null, HelpText = "Which opcodes to attempt to decompress")]
         public IEnumerable<int> DecompressOpcodes { get; set; }
+
+        [Option("enable-unknown-streams", Default = false, HelpText = "Enable dumping of unknown streams; they will be skipped otherwise.")]
+        public bool DumpUnknownStreams { get; set; }
     }
 }

zone/client.cpp

@@ -8677,14 +8677,16 @@ int Client::GetAccountAge() {
 
 void Client::CheckRegionTypeChanges()
 {
-	if (!zone->HasWaterMap())
+	if (!zone->HasWaterMap()) {
 		return;
+	}
 
 	auto new_region = zone->watermap->ReturnRegionType(glm::vec3(m_Position));
 
 	// still same region, do nothing
-	if (last_region_type == new_region)
+	if (last_region_type == new_region) {
 		return;
+	}
 
 	// If we got out of water clear any water aggro for water only npcs
 	if (last_region_type == RegionTypeWater) {
@@ -8695,13 +8697,15 @@ void Client::CheckRegionTypeChanges()
 	last_region_type = new_region;
 
 	// PVP is the only state we need to keep track of, so we can just return now for PVP servers
-	if (RuleI(World, PVPSettings) > 0)
+	if (RuleI(World, PVPSettings) > 0) {
 		return;
+	}
 
-	if (last_region_type == RegionTypePVP)
+	if (last_region_type == RegionTypePVP && RuleB(World, EnablePVPRegions)) {
 		temp_pvp = true;
-	else if (temp_pvp)
+	} else if (temp_pvp) {
 		temp_pvp = false;
+	}
 }
 
 void Client::ProcessAggroMeter()