Player session in the World. More...

#include <WorldSession.h>

Classes
union	ConnectToKey

class	DosProtection

Public Member Functions
	WorldSession (uint32 id, std::string &&name, uint32 battlenetAccountId, std::shared_ptr< WorldSocket > sock, AccountTypes sec, uint8 expansion, time_t mute_time, std::string os, LocaleConstant locale, uint32 recruiter, bool isARecruiter)
	WorldSession constructor. More...

	~WorldSession ()
	WorldSession destructor. More...

bool	PlayerLoading () const

bool	PlayerLogout () const

bool	PlayerLogoutWithSave () const

bool	PlayerRecentlyLoggedOut () const

bool	PlayerDisconnected () const

bool	IsAddonRegistered (std::string_view prefix) const

void	SendPacket (WorldPacket const *packet, bool forced=false)
	Send a packet to the client. More...

void	AddInstanceConnection (std::shared_ptr< WorldSocket > sock)

void	SendNotification (char const *format,...) ATTR_PRINTF(2

void void	SendNotification (uint32 stringId,...)

void	SendPetNameInvalid (uint32 error, std::string const &name, Optional< DeclinedName > const &declinedName)

void	SendPartyResult (PartyOperation operation, std::string const &member, PartyResult res, uint32 val=0)

void	SendQueryTimeResponse ()

void	SendAuthResponse (uint32 code, bool queued, uint32 queuePos=0)

void	SendClientCacheVersion (uint32 version)

void	SendAvailableHotfixes ()

void	InitializeSession ()

void	InitializeSessionCallback (LoginDatabaseQueryHolder const &holder, CharacterDatabaseQueryHolder const &realmHolder)

rbac::RBACData *	GetRBACData ()

bool	HasPermission (uint32 permissionId)

void	LoadPermissions ()

QueryCallback	LoadPermissionsAsync ()

void	InvalidateRBACData ()

AccountTypes	GetSecurity () const

uint32	GetAccountId () const

ObjectGuid	GetAccountGUID () const

std::string const &	GetAccountName () const

uint32	GetBattlenetAccountId () const

ObjectGuid	GetBattlenetAccountGUID () const

Player *	GetPlayer () const

std::string const &	GetPlayerName () const

std::string	GetPlayerInfo () const

void	SetSecurity (AccountTypes security)

std::string const &	GetRemoteAddress () const

void	SetPlayer (Player *player)

uint8	GetAccountExpansion () const

uint8	GetExpansion () const

std::string const &	GetOS () const

bool	CanAccessAlliedRaces () const

Warden *	GetWarden ()

Warden const *	GetWarden () const

void	InitWarden (SessionKey const &k)

void	SetInQueue (bool state)
	Session in auth.queue currently. More...

bool	isLogingOut () const
	Is the user engaged in a log out process? More...

void	SetLogoutStartTime (time_t requestTime)
	Engage the logout process for the user. More...

bool	ShouldLogOut (time_t currTime) const
	Is logout cooldown expired? More...

void	LogoutPlayer (bool save)
	Log the player out More...

void	KickPlayer (std::string const &reason)
	Kick a player out of the World. More...

bool	ValidateHyperlinksAndMaybeKick (std::string const &str)

bool	DisallowHyperlinksAndMaybeKick (std::string const &str)

void	QueuePacket (WorldPacket *new_packet)
	Add an incoming packet to the queue. More...

bool	Update (uint32 diff, PacketFilter &updater)
	Update the WorldSession (triggered by World update) More...

void	SendAuthWaitQueue (uint32 position)
	Handle the authentication waiting queue (to be completed) More...

void	SendSetTimeZoneInformation ()

void	SendFeatureSystemStatus ()

void	SendFeatureSystemStatusGlueScreen ()

void	BuildNameQueryData (ObjectGuid guid, WorldPackets::Query::NameCacheLookupResult &lookupData)

void	SendTrainerList (Creature *npc, uint32 trainerId)

void	SendListInventory (ObjectGuid guid)

void	SendShowBank (ObjectGuid guid)

bool	CanOpenMailBox (ObjectGuid guid)

void	SendShowMailBox (ObjectGuid guid)

void	SendTabardVendorActivate (ObjectGuid guid)

void	SendSpiritResurrect ()

void	SendBindPoint (Creature *npc)

void	SendOpenTransmogrifier (ObjectGuid const &guid)

void	SendAttackStop (Unit const *enemy)

void	SendTradeStatus (WorldPackets::Trade::TradeStatus &status)

void	SendUpdateTrade (bool trader_data=true)

void	SendCancelTrade ()

void	SendPetitionQueryOpcode (ObjectGuid petitionguid)

void	SendQueryPetNameResponse (ObjectGuid guid)

void	SendStablePet (ObjectGuid guid)

void	SendPetStableResult (StableResult result)

bool	CheckStableMaster (ObjectGuid guid)

AccountData const *	GetAccountData (AccountDataType type) const

void	SetAccountData (AccountDataType type, time_t time, std::string const &data)

void	SendAccountDataTimes (ObjectGuid playerGuid, uint32 mask)

void	LoadAccountData (PreparedQueryResult result, uint32 mask)

void	LoadTutorialsData (PreparedQueryResult result)

void	SendTutorialsData ()

void	SaveTutorialsData (CharacterDatabaseTransaction trans)

uint32	GetTutorialInt (uint8 index) const

void	SetTutorialInt (uint8 index, uint32 value)

void	SendAuctionHello (ObjectGuid guid, Creature *unit)

void	SendAuctionCommandResult (uint32 auctionId, AuctionCommand command, AuctionResult errorCode, Milliseconds delayForNextAction, InventoryResult bagError=InventoryResult(0))
	Notifies the client of the result of his last auction operation. It is called when the player bids, creates, or deletes an auction. More...

void	SendAuctionClosedNotification (AuctionPosting const *auction, float mailDelay, bool sold)

void	SendAuctionOwnerBidNotification (AuctionPosting const *auction)

void	SendBlackMarketOpenResult (ObjectGuid guid, Creature *auctioneer)

void	SendBlackMarketBidOnItemResult (int32 result, int32 marketId, WorldPackets::Item::ItemInstance &item)

void	SendBlackMarketWonNotification (BlackMarketEntry const entry, Item const item)

void	SendBlackMarketOutbidNotification (BlackMarketTemplate const *templ)

void	SendEnchantmentLog (ObjectGuid owner, ObjectGuid caster, ObjectGuid itemGuid, uint32 itemId, uint32 enchantId, uint32 enchantSlot)

void	SendItemEnchantTimeUpdate (ObjectGuid Playerguid, ObjectGuid Itemguid, uint32 slot, uint32 Duration)

void	SendTaxiStatus (ObjectGuid guid)

void	SendTaxiMenu (Creature *unit)

void	SendDoFlight (uint32 mountDisplayId, uint32 path, uint32 pathNode=0)

bool	SendLearnNewTaxiNode (Creature *unit)

void	SendDiscoverNewTaxiNode (uint32 nodeid)

void	SendPetitionShowList (ObjectGuid guid)

void	DoLootRelease (Loot *loot)

void	DoLootReleaseAll ()

bool	CanSpeak () const

LocaleConstant	GetSessionDbcLocale () const

LocaleConstant	GetSessionDbLocaleIndex () const

char const *	GetTrinityString (uint32 entry) const

uint32	GetLatency () const

void	SetLatency (uint32 latency)

void	ResetTimeOutTime (bool onlyActive)

bool	IsConnectionIdle () const

uint32	GetRecruiterId () const

bool	IsARecruiter () const

void	ResetTimeSync ()

void	SendTimeSync ()

uint32	AdjustClientMovementTime (uint32 time) const

time_t	GetCalendarEventCreationCooldown () const

void	SetCalendarEventCreationCooldown (time_t cooldown)

BattlePets::BattlePetMgr *	GetBattlePetMgr () const

CollectionMgr *	GetCollectionMgr () const

void	Handle_NULL (WorldPackets::Null &null)

void	Handle_EarlyProccess (WorldPackets::Null &null)

void	LogUnprocessedTail (WorldPacket const *packet)
	Logging helper for unexpected opcodes. More...

void	HandleCharEnum (CharacterDatabaseQueryHolder const &holder)

void	HandleCharEnumOpcode (WorldPackets::Character::EnumCharacters &)

void	HandleCharUndeleteEnumOpcode (WorldPackets::Character::EnumCharacters &)

void	HandleCharDeleteOpcode (WorldPackets::Character::CharDelete &charDelete)

void	HandleCharCreateOpcode (WorldPackets::Character::CreateCharacter &charCreate)

void	HandlePlayerLoginOpcode (WorldPackets::Character::PlayerLogin &playerLogin)

void	SendConnectToInstance (WorldPackets::Auth::ConnectToSerial serial)

void	HandleContinuePlayerLogin ()

void	AbortLogin (WorldPackets::Character::LoginFailureReason reason)

void	HandleLoadScreenOpcode (WorldPackets::Character::LoadingScreenNotify &loadingScreenNotify)

void	HandlePlayerLogin (LoginQueryHolder const &holder)

void	HandleCheckCharacterNameAvailability (WorldPackets::Character::CheckCharacterNameAvailability &checkCharacterNameAvailability)

void	HandleCharRenameOpcode (WorldPackets::Character::CharacterRenameRequest &request)

void	HandleCharRenameCallBack (std::shared_ptr< WorldPackets::Character::CharacterRenameInfo > renameInfo, PreparedQueryResult result)

void	HandleSetPlayerDeclinedNames (WorldPackets::Character::SetPlayerDeclinedNames &packet)

void	HandleAlterAppearance (WorldPackets::Character::AlterApperance &packet)

void	HandleCharCustomizeOpcode (WorldPackets::Character::CharCustomize &packet)

void	HandleCharCustomizeCallback (std::shared_ptr< WorldPackets::Character::CharCustomizeInfo > customizeInfo, PreparedQueryResult result)

void	HandleCharRaceOrFactionChangeOpcode (WorldPackets::Character::CharRaceOrFactionChange &packet)

void	HandleCharRaceOrFactionChangeCallback (std::shared_ptr< WorldPackets::Character::CharRaceOrFactionChangeInfo > factionChangeInfo, PreparedQueryResult result)

void	HandleRandomizeCharNameOpcode (WorldPackets::Character::GenerateRandomCharacterName &packet)

void	HandleReorderCharacters (WorldPackets::Character::ReorderCharacters &reorderChars)

void	HandleOpeningCinematic (WorldPackets::Misc::OpeningCinematic &packet)

void	HandleGetUndeleteCooldownStatus (WorldPackets::Character::GetUndeleteCharacterCooldownStatus &)

void	HandleUndeleteCooldownStatusCallback (PreparedQueryResult result)

void	HandleCharUndeleteOpcode (WorldPackets::Character::UndeleteCharacter &undeleteInfo)

bool	MeetsChrCustomizationReq (ChrCustomizationReqEntry const req, Classes playerClass, bool checkRequiredDependentChoices, Trinity::IteratorPair< UF::ChrCustomizationChoice const > selectedChoices) const

bool	ValidateAppearance (Races race, Classes playerClass, Gender gender, Trinity::IteratorPair< UF::ChrCustomizationChoice const * > customizations)

void	SendCharCreate (ResponseCodes result, ObjectGuid const &guid=ObjectGuid::Empty)

void	SendCharDelete (ResponseCodes result)

void	SendCharRename (ResponseCodes result, WorldPackets::Character::CharacterRenameInfo const *renameInfo)

void	SendCharCustomize (ResponseCodes result, WorldPackets::Character::CharCustomizeInfo const *customizeInfo)

void	SendCharFactionChange (ResponseCodes result, WorldPackets::Character::CharRaceOrFactionChangeInfo const *factionChangeInfo)

void	SendSetPlayerDeclinedNamesResult (DeclinedNameResult result, ObjectGuid guid)

void	SendUndeleteCooldownStatusResponse (uint32 currentCooldown, uint32 maxCooldown)

void	SendUndeleteCharacterResponse (CharacterUndeleteResult result, WorldPackets::Character::CharacterUndeleteInfo const *undeleteInfo)

void	HandlePlayedTime (WorldPackets::Character::RequestPlayedTime &packet)

void	HandlePortGraveyard (WorldPackets::Misc::PortGraveyard &packet)

void	HandleRequestCemeteryList (WorldPackets::Misc::RequestCemeteryList &packet)

void	HandleInspectOpcode (WorldPackets::Inspect::Inspect &inspect)

void	HandleQueryInspectAchievements (WorldPackets::Inspect::QueryInspectAchievements &inspect)

void	HandleMountSpecialAnimOpcode (WorldPackets::Misc::MountSpecial &mountSpecial)

void	HandleRepairItemOpcode (WorldPackets::Item::RepairItem &packet)

void	HandleMoveKnockBackAck (WorldPackets::Movement::MoveKnockBackAck &movementAck)

void	HandleMoveTeleportAck (WorldPackets::Movement::MoveTeleportAck &packet)

void	HandleForceSpeedChangeAck (WorldPackets::Movement::MovementSpeedAck &packet)

void	HandleSetCollisionHeightAck (WorldPackets::Movement::MoveSetCollisionHeightAck &setCollisionHeightAck)

void	HandleMoveApplyMovementForceAck (WorldPackets::Movement::MoveApplyMovementForceAck &moveApplyMovementForceAck)

void	HandleMoveRemoveMovementForceAck (WorldPackets::Movement::MoveRemoveMovementForceAck &moveRemoveMovementForceAck)

void	HandleMoveSetModMovementForceMagnitudeAck (WorldPackets::Movement::MovementSpeedAck &setModMovementForceMagnitudeAck)

void	HandleRepopRequest (WorldPackets::Misc::RepopRequest &packet)

void	HandleAutostoreLootItemOpcode (WorldPackets::Loot::LootItem &packet)

void	HandleLootMoneyOpcode (WorldPackets::Loot::LootMoney &packet)

void	HandleLootOpcode (WorldPackets::Loot::LootUnit &packet)

void	HandleLootReleaseOpcode (WorldPackets::Loot::LootRelease &packet)

void	HandleLootMasterGiveOpcode (WorldPackets::Loot::MasterLootItem &masterLootItem)

void	HandleSetLootSpecialization (WorldPackets::Loot::SetLootSpecialization &packet)

void	HandleWhoOpcode (WorldPackets::Who::WhoRequestPkt &whoRequest)

void	HandleLogoutRequestOpcode (WorldPackets::Character::LogoutRequest &logoutRequest)

void	HandleLogoutCancelOpcode (WorldPackets::Character::LogoutCancel &logoutCancel)

void	HandleGMTicketGetCaseStatusOpcode (WorldPackets::Ticket::GMTicketGetCaseStatus &packet)

void	HandleGMTicketSystemStatusOpcode (WorldPackets::Ticket::GMTicketGetSystemStatus &packet)

void	HandleSubmitUserFeedback (WorldPackets::Ticket::SubmitUserFeedback &userFeedback)

void	HandleSupportTicketSubmitComplaint (WorldPackets::Ticket::SupportTicketSubmitComplaint &packet)

void	HandleBugReportOpcode (WorldPackets::Ticket::BugReport &bugReport)

void	HandleComplaint (WorldPackets::Ticket::Complaint &packet)

void	HandleTogglePvP (WorldPackets::Misc::TogglePvP &packet)

void	HandleSetPvP (WorldPackets::Misc::SetPvP &packet)

void	HandleSetWarMode (WorldPackets::Misc::SetWarMode &packet)

void	HandleSetSelectionOpcode (WorldPackets::Misc::SetSelection &packet)

void	HandleStandStateChangeOpcode (WorldPackets::Misc::StandStateChange &packet)

void	HandleEmoteOpcode (WorldPackets::Chat::EmoteClient &packet)

void	HandleContactListOpcode (WorldPackets::Social::SendContactList &packet)

void	HandleAddFriendOpcode (WorldPackets::Social::AddFriend &packet)

void	HandleDelFriendOpcode (WorldPackets::Social::DelFriend &packet)

void	HandleAddIgnoreOpcode (WorldPackets::Social::AddIgnore &packet)

void	HandleDelIgnoreOpcode (WorldPackets::Social::DelIgnore &packet)

void	HandleSetContactNotesOpcode (WorldPackets::Social::SetContactNotes &packet)

void	HandleAreaTriggerOpcode (WorldPackets::AreaTrigger::AreaTrigger &packet)

void	HandleSetFactionAtWar (WorldPackets::Character::SetFactionAtWar &packet)

void	HandleSetFactionNotAtWar (WorldPackets::Character::SetFactionNotAtWar &packet)

void	HandleSetFactionCheat (WorldPacket &recvData)

void	HandleSetWatchedFactionOpcode (WorldPackets::Character::SetWatchedFaction &packet)

void	HandleSetFactionInactiveOpcode (WorldPackets::Character::SetFactionInactive &packet)

void	HandleRequestForcedReactionsOpcode (WorldPackets::Reputation::RequestForcedReactions &requestForcedReactions)

void	HandleUpdateAccountData (WorldPackets::ClientConfig::UserClientUpdateAccountData &packet)

void	HandleRequestAccountData (WorldPackets::ClientConfig::RequestAccountData &request)

void	HandleSetAdvancedCombatLogging (WorldPackets::ClientConfig::SetAdvancedCombatLogging &setAdvancedCombatLogging)

void	HandleSetActionButtonOpcode (WorldPackets::Spells::SetActionButton &packet)

void	HandleGameObjectUseOpcode (WorldPackets::GameObject::GameObjUse &packet)

void	HandleGameobjectReportUse (WorldPackets::GameObject::GameObjReportUse &packet)

void	HandleQueryPlayerNames (WorldPackets::Query::QueryPlayerNames &queryPlayerNames)

void	HandleQueryTimeOpcode (WorldPackets::Query::QueryTime &queryTime)

void	HandleCreatureQuery (WorldPackets::Query::QueryCreature &packet)
	Only static data is sent in this packet !!! More...

void	HandleGameObjectQueryOpcode (WorldPackets::Query::QueryGameObject &packet)
	Only static data is sent in this packet !!! More...

void	HandleDBQueryBulk (WorldPackets::Hotfix::DBQueryBulk &dbQuery)

void	HandleHotfixRequest (WorldPackets::Hotfix::HotfixRequest &hotfixQuery)

void	HandleMoveWorldportAckOpcode (WorldPackets::Movement::WorldPortResponse &packet)

void	HandleMoveWorldportAck ()

void	HandleSuspendTokenResponse (WorldPackets::Movement::SuspendTokenResponse &suspendTokenResponse)

void	HandleMovementOpcodes (WorldPackets::Movement::ClientPlayerMovement &packet)

void	HandleMovementOpcode (OpcodeClient opcode, MovementInfo &movementInfo)

void	HandleSetActiveMoverOpcode (WorldPackets::Movement::SetActiveMover &packet)

void	HandleMoveDismissVehicle (WorldPackets::Vehicle::MoveDismissVehicle &moveDismissVehicle)

void	HandleRequestVehiclePrevSeat (WorldPackets::Vehicle::RequestVehiclePrevSeat &requestVehiclePrevSeat)

void	HandleRequestVehicleNextSeat (WorldPackets::Vehicle::RequestVehicleNextSeat &requestVehicleNextSeat)

void	HandleMoveChangeVehicleSeats (WorldPackets::Vehicle::MoveChangeVehicleSeats &moveChangeVehicleSeats)

void	HandleRequestVehicleSwitchSeat (WorldPackets::Vehicle::RequestVehicleSwitchSeat &requestVehicleSwitchSeat)

void	HandleRideVehicleInteract (WorldPackets::Vehicle::RideVehicleInteract &rideVehicleInteract)

void	HandleEjectPassenger (WorldPackets::Vehicle::EjectPassenger &ejectPassenger)

void	HandleRequestVehicleExit (WorldPackets::Vehicle::RequestVehicleExit &requestVehicleExit)

void	HandleMoveSetVehicleRecAck (WorldPackets::Vehicle::MoveSetVehicleRecIdAck &setVehicleRecIdAck)

void	HandleMoveTimeSkippedOpcode (WorldPackets::Movement::MoveTimeSkipped &moveTimeSkipped)

void	HandleMovementAckMessage (WorldPackets::Movement::MovementAckMessage &movementAck)

void	HandleMoveInitActiveMoverComplete (WorldPackets::Movement::MoveInitActiveMoverComplete &moveInitActiveMoverComplete)

void	HandleRequestRaidInfoOpcode (WorldPackets::Party::RequestRaidInfo &packet)

void	HandlePartyInviteOpcode (WorldPackets::Party::PartyInviteClient &packet)

void	HandlePartyInviteResponseOpcode (WorldPackets::Party::PartyInviteResponse &packet)

void	HandlePartyUninviteOpcode (WorldPackets::Party::PartyUninvite &packet)

void	HandleSetPartyLeaderOpcode (WorldPackets::Party::SetPartyLeader &packet)

void	HandleSetRoleOpcode (WorldPackets::Party::SetRole &packet)

void	HandleLeaveGroupOpcode (WorldPackets::Party::LeaveGroup &packet)

void	HandleOptOutOfLootOpcode (WorldPackets::Party::OptOutOfLoot &packet)

void	HandleSetLootMethodOpcode (WorldPackets::Party::SetLootMethod &packet)

void	HandleLootRoll (WorldPackets::Loot::LootRoll &packet)

void	HandleRequestPartyMemberStatsOpcode (WorldPackets::Party::RequestPartyMemberStats &packet)

void	HandleUpdateRaidTargetOpcode (WorldPackets::Party::UpdateRaidTarget &packet)

void	HandleDoReadyCheckOpcode (WorldPackets::Party::DoReadyCheck &packet)

void	HandleReadyCheckResponseOpcode (WorldPackets::Party::ReadyCheckResponseClient &packet)

void	HandleConvertRaidOpcode (WorldPackets::Party::ConvertRaid &packet)

void	HandleRequestPartyJoinUpdates (WorldPackets::Party::RequestPartyJoinUpdates &packet)

void	HandleChangeSubGroupOpcode (WorldPackets::Party::ChangeSubGroup &packet)

void	HandleSwapSubGroupsOpcode (WorldPackets::Party::SwapSubGroups &packet)

void	HandleSetAssistantLeaderOpcode (WorldPackets::Party::SetAssistantLeader &packet)

void	HandleSetPartyAssignment (WorldPackets::Party::SetPartyAssignment &packet)

void	HandleInitiateRolePoll (WorldPackets::Party::InitiateRolePoll &packet)

void	HandleSetEveryoneIsAssistant (WorldPackets::Party::SetEveryoneIsAssistant &packet)

void	HandleClearRaidMarker (WorldPackets::Party::ClearRaidMarker &packet)

void	HandlePetitionBuy (WorldPackets::Petition::PetitionBuy &packet)

void	HandlePetitionShowSignatures (WorldPackets::Petition::PetitionShowSignatures &packet)

void	SendPetitionSigns (Petition const petition, Player sendTo)

void	HandleQueryPetition (WorldPackets::Petition::QueryPetition &packet)

void	HandlePetitionRenameGuild (WorldPackets::Petition::PetitionRenameGuild &packet)

void	HandleSignPetition (WorldPackets::Petition::SignPetition &packet)

void	HandleDeclinePetition (WorldPackets::Petition::DeclinePetition &packet)

void	HandleOfferPetition (WorldPackets::Petition::OfferPetition &packet)

void	HandleTurnInPetition (WorldPackets::Petition::TurnInPetition &packet)

void	HandleGuildQueryOpcode (WorldPackets::Guild::QueryGuildInfo &query)

void	HandleGuildInviteByName (WorldPackets::Guild::GuildInviteByName &packet)

void	HandleGuildOfficerRemoveMember (WorldPackets::Guild::GuildOfficerRemoveMember &packet)

void	HandleGuildAcceptInvite (WorldPackets::Guild::AcceptGuildInvite &invite)

void	HandleGuildDeclineInvitation (WorldPackets::Guild::GuildDeclineInvitation &decline)

void	HandleGuildEventLogQuery (WorldPackets::Guild::GuildEventLogQuery &packet)

void	HandleGuildGetRoster (WorldPackets::Guild::GuildGetRoster &packet)

void	HandleRequestGuildRewardsList (WorldPackets::Guild::RequestGuildRewardsList &packet)

void	HandleGuildPromoteMember (WorldPackets::Guild::GuildPromoteMember &promote)

void	HandleGuildDemoteMember (WorldPackets::Guild::GuildDemoteMember &demote)

void	HandleGuildAssignRank (WorldPackets::Guild::GuildAssignMemberRank &packet)

void	HandleGuildLeave (WorldPackets::Guild::GuildLeave &leave)

void	HandleGuildDelete (WorldPackets::Guild::GuildDelete &packet)

void	HandleGuildReplaceGuildMaster (WorldPackets::Guild::GuildReplaceGuildMaster &replaceGuildMaster)

void	HandleGuildSetAchievementTracking (WorldPackets::Guild::GuildSetAchievementTracking &packet)

void	HandleGuildGetAchievementMembers (WorldPackets::Achievement::GuildGetAchievementMembers &getAchievementMembers)

void	HandleGuildSetGuildMaster (WorldPackets::Guild::GuildSetGuildMaster &packet)

void	HandleGuildUpdateMotdText (WorldPackets::Guild::GuildUpdateMotdText &packet)

void	HandleGuildNewsUpdateSticky (WorldPackets::Guild::GuildNewsUpdateSticky &packet)

void	HandleGuildSetMemberNote (WorldPackets::Guild::GuildSetMemberNote &packet)

void	HandleGuildGetRanks (WorldPackets::Guild::GuildGetRanks &packet)

void	HandleGuildQueryNews (WorldPackets::Guild::GuildQueryNews &newsQuery)

void	HandleGuildSetRankPermissions (WorldPackets::Guild::GuildSetRankPermissions &packet)

void	HandleGuildAddRank (WorldPackets::Guild::GuildAddRank &packet)

void	HandleGuildDeleteRank (WorldPackets::Guild::GuildDeleteRank &packet)

void	HandleGuildShiftRank (WorldPackets::Guild::GuildShiftRank &shiftRank)

void	HandleGuildUpdateInfoText (WorldPackets::Guild::GuildUpdateInfoText &packet)

void	HandleSaveGuildEmblem (WorldPackets::Guild::SaveGuildEmblem &packet)

void	HandleGuildRequestPartyState (WorldPackets::Guild::RequestGuildPartyState &packet)

void	HandleGuildChallengeUpdateRequest (WorldPackets::Guild::GuildChallengeUpdateRequest &packet)

void	HandleDeclineGuildInvites (WorldPackets::Guild::DeclineGuildInvites &packet)

void	HandleEnableTaxiNodeOpcode (WorldPackets::Taxi::EnableTaxiNode &enableTaxiNode)

void	HandleTaxiNodeStatusQueryOpcode (WorldPackets::Taxi::TaxiNodeStatusQuery &taxiNodeStatusQuery)

void	HandleTaxiQueryAvailableNodesOpcode (WorldPackets::Taxi::TaxiQueryAvailableNodes &taxiQueryAvailableNodes)

void	HandleActivateTaxiOpcode (WorldPackets::Taxi::ActivateTaxi &activateTaxi)

void	HandleMoveSplineDoneOpcode (WorldPackets::Movement::MoveSplineDone &moveSplineDone)

void	SendActivateTaxiReply (ActivateTaxiReply reply)

void	HandleTaxiRequestEarlyLanding (WorldPackets::Taxi::TaxiRequestEarlyLanding &taxiRequestEarlyLanding)

void	HandleTabardVendorActivateOpcode (WorldPackets::NPC::Hello &packet)

void	HandleBankerActivateOpcode (WorldPackets::NPC::Hello &packet)

void	HandleTrainerListOpcode (WorldPackets::NPC::Hello &packet)

void	HandleTrainerBuySpellOpcode (WorldPackets::NPC::TrainerBuySpell &packet)

void	HandlePetitionShowList (WorldPackets::Petition::PetitionShowList &packet)

void	HandleGossipHelloOpcode (WorldPackets::NPC::Hello &packet)

void	HandleGossipSelectOptionOpcode (WorldPackets::NPC::GossipSelectOption &packet)

void	HandleSpiritHealerActivate (WorldPackets::NPC::SpiritHealerActivate &packet)

void	HandleNpcTextQueryOpcode (WorldPackets::Query::QueryNPCText &packet)

void	HandleBinderActivateOpcode (WorldPackets::NPC::Hello &packet)

void	HandleRequestStabledPets (WorldPackets::NPC::RequestStabledPets &packet)

void	HandleSetPetSlot (WorldPackets::NPC::SetPetSlot &setPetSlot)

void	HandleCanDuel (WorldPackets::Duel::CanDuel &packet)

void	HandleDuelResponseOpcode (WorldPackets::Duel::DuelResponse &duelResponse)

void	HandleDuelAccepted (ObjectGuid arbiterGuid)

void	HandleDuelCancelled ()

void	HandleAcceptTradeOpcode (WorldPackets::Trade::AcceptTrade &acceptTrade)

void	HandleBeginTradeOpcode (WorldPackets::Trade::BeginTrade &beginTrade)

void	HandleBusyTradeOpcode (WorldPackets::Trade::BusyTrade &busyTrade)

void	HandleCancelTradeOpcode (WorldPackets::Trade::CancelTrade &cancelTrade)

void	HandleClearTradeItemOpcode (WorldPackets::Trade::ClearTradeItem &clearTradeItem)

void	HandleIgnoreTradeOpcode (WorldPackets::Trade::IgnoreTrade &ignoreTrade)

void	HandleInitiateTradeOpcode (WorldPackets::Trade::InitiateTrade &initiateTrade)

void	HandleSetTradeCurrencyOpcode (WorldPackets::Trade::SetTradeCurrency &setTradeCurrency)

void	HandleSetTradeGoldOpcode (WorldPackets::Trade::SetTradeGold &setTradeGold)

void	HandleSetTradeItemOpcode (WorldPackets::Trade::SetTradeItem &setTradeItem)

void	HandleUnacceptTradeOpcode (WorldPackets::Trade::UnacceptTrade &unacceptTrade)

void	HandleAuctionBrowseQuery (WorldPackets::AuctionHouse::AuctionBrowseQuery &browseQuery)

void	HandleAuctionCancelCommoditiesPurchase (WorldPackets::AuctionHouse::AuctionCancelCommoditiesPurchase &cancelCommoditiesPurchase)

void	HandleAuctionConfirmCommoditiesPurchase (WorldPackets::AuctionHouse::AuctionConfirmCommoditiesPurchase &confirmCommoditiesPurchase)

void	HandleAuctionGetCommodityQuote (WorldPackets::AuctionHouse::AuctionGetCommodityQuote &startCommoditiesPurchase)

void	HandleAuctionHelloOpcode (WorldPackets::AuctionHouse::AuctionHelloRequest &hello)

void	HandleAuctionListBiddedItems (WorldPackets::AuctionHouse::AuctionListBiddedItems &listBiddedItems)

void	HandleAuctionListBucketsByBucketKeys (WorldPackets::AuctionHouse::AuctionListBucketsByBucketKeys &listBucketsByBucketKeys)

void	HandleAuctionListItemsByBucketKey (WorldPackets::AuctionHouse::AuctionListItemsByBucketKey &listItemsByBucketKey)

void	HandleAuctionListItemsByItemID (WorldPackets::AuctionHouse::AuctionListItemsByItemID &listItemsByItemID)

void	HandleAuctionListOwnedItems (WorldPackets::AuctionHouse::AuctionListOwnedItems &listOwnedItems)

void	HandleAuctionPlaceBid (WorldPackets::AuctionHouse::AuctionPlaceBid &placeBid)

void	HandleAuctionRemoveItem (WorldPackets::AuctionHouse::AuctionRemoveItem &removeItem)

void	HandleAuctionReplicateItems (WorldPackets::AuctionHouse::AuctionReplicateItems &replicateItems)

void	HandleAuctionRequestFavoriteList (WorldPackets::AuctionHouse::AuctionRequestFavoriteList &requestFavoriteList)

void	HandleAuctionSellCommodity (WorldPackets::AuctionHouse::AuctionSellCommodity &sellCommodity)

void	HandleAuctionSellItem (WorldPackets::AuctionHouse::AuctionSellItem &sellItem)

void	HandleAuctionSetFavoriteItem (WorldPackets::AuctionHouse::AuctionSetFavoriteItem &setFavoriteItem)

void	HandleAutoBankItemOpcode (WorldPackets::Bank::AutoBankItem &packet)

void	HandleAutoStoreBankItemOpcode (WorldPackets::Bank::AutoStoreBankItem &packet)

void	HandleBuyBankSlotOpcode (WorldPackets::Bank::BuyBankSlot &packet)

void	HandleBuyReagentBankOpcode (WorldPackets::Bank::ReagentBank &reagentBank)

void	HandleAutoBankReagentOpcode (WorldPackets::Bank::AutoBankReagent &autoBankRegent)

void	HandleAutoStoreBankReagentOpcode (WorldPackets::Bank::AutoStoreBankReagent &autoStoreBankReagent)

void	HandleReagentBankDepositOpcode (WorldPackets::Bank::ReagentBank &reagentBank)

void	HandleBlackMarketOpen (WorldPackets::BlackMarket::BlackMarketOpen &blackMarketOpen)

void	HandleBlackMarketRequestItems (WorldPackets::BlackMarket::BlackMarketRequestItems &blackMarketRequestItems)

void	HandleBlackMarketBidOnItem (WorldPackets::BlackMarket::BlackMarketBidOnItem &blackMarketBidOnItem)

void	HandleGetMailList (WorldPackets::Mail::MailGetList &getList)

void	HandleSendMail (WorldPackets::Mail::SendMail &sendMail)

void	HandleMailTakeMoney (WorldPackets::Mail::MailTakeMoney &takeMoney)

void	HandleMailTakeItem (WorldPackets::Mail::MailTakeItem &takeItem)

void	HandleMailMarkAsRead (WorldPackets::Mail::MailMarkAsRead &markAsRead)

void	HandleMailReturnToSender (WorldPackets::Mail::MailReturnToSender &returnToSender)

void	HandleMailDelete (WorldPackets::Mail::MailDelete &mailDelete)

void	HandleItemTextQuery (WorldPackets::Query::ItemTextQuery &itemTextQuery)

void	HandleMailCreateTextItem (WorldPackets::Mail::MailCreateTextItem &createTextItem)

void	HandleQueryNextMailTime (WorldPackets::Mail::MailQueryNextMailTime &queryNextMailTime)

void	HandleCancelChanneling (WorldPackets::Spells::CancelChannelling &cancelChanneling)

void	HandleSplitItemOpcode (WorldPackets::Item::SplitItem &splitItem)

void	HandleSwapInvItemOpcode (WorldPackets::Item::SwapInvItem &swapInvItem)

void	HandleDestroyItemOpcode (WorldPackets::Item::DestroyItem &destroyItem)

void	HandleAutoEquipItemOpcode (WorldPackets::Item::AutoEquipItem &autoEquipItem)

void	HandleSellItemOpcode (WorldPackets::Item::SellItem &packet)

void	HandleBuyItemOpcode (WorldPackets::Item::BuyItem &packet)

void	HandleListInventoryOpcode (WorldPackets::NPC::Hello &packet)

void	HandleAutoStoreBagItemOpcode (WorldPackets::Item::AutoStoreBagItem &packet)

void	HandleReadItem (WorldPackets::Item::ReadItem &readItem)

void	HandleAutoEquipItemSlotOpcode (WorldPackets::Item::AutoEquipItemSlot &autoEquipItemSlot)

void	HandleSwapItem (WorldPackets::Item::SwapItem &swapItem)

void	HandleBuybackItem (WorldPackets::Item::BuyBackItem &packet)

void	HandleWrapItem (WorldPackets::Item::WrapItem &packet)

void	HandleUseCritterItem (WorldPackets::Item::UseCritterItem &packet)

void	HandleAttackSwingOpcode (WorldPackets::Combat::AttackSwing &packet)

void	HandleAttackStopOpcode (WorldPackets::Combat::AttackStop &packet)

void	HandleSetSheathedOpcode (WorldPackets::Combat::SetSheathed &packet)

void	HandleUseItemOpcode (WorldPackets::Spells::UseItem &packet)

void	HandleOpenItemOpcode (WorldPackets::Spells::OpenItem &packet)

void	HandleOpenWrappedItemCallback (uint16 pos, ObjectGuid itemGuid, PreparedQueryResult result)

void	HandleCastSpellOpcode (WorldPackets::Spells::CastSpell &castRequest)

void	HandleCancelCastOpcode (WorldPackets::Spells::CancelCast &packet)

void	HandleCancelAuraOpcode (WorldPackets::Spells::CancelAura &cancelAura)

void	HandleCancelGrowthAuraOpcode (WorldPackets::Spells::CancelGrowthAura &cancelGrowthAura)

void	HandleCancelMountAuraOpcode (WorldPackets::Spells::CancelMountAura &cancelMountAura)

void	HandleCancelModSpeedNoControlAuras (WorldPackets::Spells::CancelModSpeedNoControlAuras &cancelModSpeedNoControlAuras)

void	HandleCancelAutoRepeatSpellOpcode (WorldPackets::Spells::CancelAutoRepeatSpell &cancelAutoRepeatSpell)

void	HandleMissileTrajectoryCollision (WorldPackets::Spells::MissileTrajectoryCollision &packet)

void	HandleUpdateMissileTrajectory (WorldPackets::Spells::UpdateMissileTrajectory &packet)

void	HandleLearnPvpTalentsOpcode (WorldPackets::Talent::LearnPvpTalents &packet)

void	HandleLearnTalentsOpcode (WorldPackets::Talent::LearnTalents &packet)

void	HandleConfirmRespecWipeOpcode (WorldPackets::Talent::ConfirmRespecWipe &confirmRespecWipe)

void	HandleUnlearnSkillOpcode (WorldPackets::Spells::UnlearnSkill &packet)

void	HandleTradeSkillSetFavorite (WorldPackets::Spells::TradeSkillSetFavorite const &tradeSkillSetFavorite)

void	HandleTraitsCommitConfig (WorldPackets::Traits::TraitsCommitConfig const &traitsCommitConfig)

void	HandleClassTalentsRequestNewConfig (WorldPackets::Traits::ClassTalentsRequestNewConfig &classTalentsRequestNewConfig)

void	HandleClassTalentsRenameConfig (WorldPackets::Traits::ClassTalentsRenameConfig &classTalentsRenameConfig)

void	HandleClassTalentsDeleteConfig (WorldPackets::Traits::ClassTalentsDeleteConfig const &classTalentsDeleteConfig)

void	HandleClassTalentsSetStarterBuildActive (WorldPackets::Traits::ClassTalentsSetStarterBuildActive const &classTalentsSetStarterBuildActive)

void	HandleClassTalentsSetUsesSharedActionBars (WorldPackets::Traits::ClassTalentsSetUsesSharedActionBars const &classTalentsSetUsesSharedActionBars)

void	HandleQuestgiverStatusQueryOpcode (WorldPackets::Quest::QuestGiverStatusQuery &packet)

void	HandleQuestgiverStatusMultipleQuery (WorldPackets::Quest::QuestGiverStatusMultipleQuery &packet)

void	HandleQuestgiverStatusTrackedQueryOpcode (WorldPackets::Quest::QuestGiverStatusTrackedQuery &questGiverStatusTrackedQuery)

void	HandleQuestgiverHelloOpcode (WorldPackets::Quest::QuestGiverHello &packet)

void	HandleQuestgiverAcceptQuestOpcode (WorldPackets::Quest::QuestGiverAcceptQuest &packet)

void	HandleQuestgiverQueryQuestOpcode (WorldPackets::Quest::QuestGiverQueryQuest &packet)

void	HandleQuestgiverChooseRewardOpcode (WorldPackets::Quest::QuestGiverChooseReward &packet)

void	HandleQuestgiverRequestRewardOpcode (WorldPackets::Quest::QuestGiverRequestReward &packet)

void	HandleQuestQueryOpcode (WorldPackets::Quest::QueryQuestInfo &packet)

void	HandleQuestLogRemoveQuest (WorldPackets::Quest::QuestLogRemoveQuest &packet)

void	HandleQuestConfirmAccept (WorldPackets::Quest::QuestConfirmAccept &packet)

void	HandleQuestgiverCompleteQuest (WorldPackets::Quest::QuestGiverCompleteQuest &packet)

void	HandleQuestgiverCloseQuest (WorldPackets::Quest::QuestGiverCloseQuest &questGiverCloseQuest)

void	HandlePushQuestToParty (WorldPackets::Quest::PushQuestToParty &packet)

void	HandleQuestPushResult (WorldPackets::Quest::QuestPushResult &packet)

void	HandleRequestWorldQuestUpdate (WorldPackets::Quest::RequestWorldQuestUpdate &packet)

void	HandlePlayerChoiceResponse (WorldPackets::Quest::ChoiceResponse &choiceResponse)

void	HandleChatMessageOpcode (WorldPackets::Chat::ChatMessage &chatMessage)

void	HandleChatMessageWhisperOpcode (WorldPackets::Chat::ChatMessageWhisper &chatMessageWhisper)

void	HandleChatMessageChannelOpcode (WorldPackets::Chat::ChatMessageChannel &chatMessageChannel)

void	HandleChatMessage (ChatMsg type, Language lang, std::string msg, std::string target="", Optional< ObjectGuid > channelGuid={})

void	HandleChatAddonMessageOpcode (WorldPackets::Chat::ChatAddonMessage &chatAddonMessage)

void	HandleChatAddonMessageTargetedOpcode (WorldPackets::Chat::ChatAddonMessageTargeted &chatAddonMessageTargeted)

void	HandleChatAddonMessage (ChatMsg type, std::string prefix, std::string text, bool isLogged, std::string target="", Optional< ObjectGuid > channelGuid={})

void	HandleChatMessageAFKOpcode (WorldPackets::Chat::ChatMessageAFK &chatMessageAFK)

void	HandleChatMessageDNDOpcode (WorldPackets::Chat::ChatMessageDND &chatMessageDND)

void	HandleChatMessageEmoteOpcode (WorldPackets::Chat::ChatMessageEmote &chatMessageEmote)

void	SendChatPlayerNotfoundNotice (std::string const &name)

void	SendPlayerAmbiguousNotice (std::string const &name)

void	SendChatRestricted (ChatRestrictionType restriction)

void	HandleTextEmoteOpcode (WorldPackets::Chat::CTextEmote &packet)

void	HandleChatIgnoredOpcode (WorldPackets::Chat::ChatReportIgnored &chatReportIgnored)

void	HandleUnregisterAllAddonPrefixesOpcode (WorldPackets::Chat::ChatUnregisterAllAddonPrefixes &packet)

void	HandleAddonRegisteredPrefixesOpcode (WorldPackets::Chat::ChatRegisterAddonPrefixes &packet)

void	HandleReclaimCorpse (WorldPackets::Misc::ReclaimCorpse &packet)

void	HandleQueryCorpseLocation (WorldPackets::Query::QueryCorpseLocationFromClient &packet)

void	HandleQueryCorpseTransport (WorldPackets::Query::QueryCorpseTransport &packet)

void	HandleResurrectResponse (WorldPackets::Misc::ResurrectResponse &packet)

void	HandleSummonResponseOpcode (WorldPackets::Movement::SummonResponse &packet)

void	HandleJoinChannel (WorldPackets::Channel::JoinChannel &packet)

void	HandleLeaveChannel (WorldPackets::Channel::LeaveChannel &packet)

void	HandleChannelCommand (WorldPackets::Channel::ChannelCommand &packet)

void	HandleChannelPlayerCommand (WorldPackets::Channel::ChannelPlayerCommand &packet)

void	HandleChannelPassword (WorldPackets::Channel::ChannelPassword &channelPassword)

void	HandleCompleteCinematic (WorldPackets::Misc::CompleteCinematic &packet)

void	HandleNextCinematicCamera (WorldPackets::Misc::NextCinematicCamera &packet)

void	HandleCompleteMovie (WorldPackets::Misc::CompleteMovie &packet)

void	HandleQueryPageText (WorldPackets::Query::QueryPageText &packet)
	Only static data is sent in this packet !!! More...

void	HandleTutorialFlag (WorldPackets::Misc::TutorialSetFlag &packet)

void	HandlePetAction (WorldPackets::Pet::PetAction &packet)

void	HandlePetStopAttack (WorldPackets::Pet::PetStopAttack &packet)

void	HandlePetActionHelper (Unit *pet, ObjectGuid guid1, uint32 spellid, uint16 flag, ObjectGuid guid2, Position const &pos)

void	HandleQueryPetName (WorldPackets::Query::QueryPetName &packet)

void	HandlePetSetAction (WorldPackets::Pet::PetSetAction &packet)

void	HandlePetAbandon (WorldPackets::Pet::PetAbandon &packet)

void	HandlePetRename (WorldPackets::Pet::PetRename &packet)

void	HandlePetCancelAuraOpcode (WorldPackets::Spells::PetCancelAura &packet)

void	HandlePetSpellAutocastOpcode (WorldPackets::Pet::PetSpellAutocast &packet)

void	HandlePetCastSpellOpcode (WorldPackets::Spells::PetCastSpell &petCastSpell)

void	HandleSetActionBarToggles (WorldPackets::Character::SetActionBarToggles &packet)

void	HandleTotemDestroyed (WorldPackets::Totem::TotemDestroyed &totemDestroyed)

void	HandleDismissCritter (WorldPackets::Pet::DismissCritter &dismissCritter)

void	HandleBattlemasterHelloOpcode (WorldPackets::NPC::Hello &hello)

void	HandleBattlemasterJoinOpcode (WorldPackets::Battleground::BattlemasterJoin &battlemasterJoin)

void	HandlePVPLogDataOpcode (WorldPackets::Battleground::PVPLogDataRequest &pvpLogDataRequest)

void	HandleBattleFieldPortOpcode (WorldPackets::Battleground::BattlefieldPort &battlefieldPort)

void	HandleBattlefieldListOpcode (WorldPackets::Battleground::BattlefieldListRequest &battlefieldList)

void	HandleBattlefieldLeaveOpcode (WorldPackets::Battleground::BattlefieldLeave &battlefieldLeave)

void	HandleBattlemasterJoinArena (WorldPackets::Battleground::BattlemasterJoinArena &packet)

void	HandleReportPvPAFK (WorldPackets::Battleground::ReportPvPPlayerAFK &reportPvPPlayerAFK)

void	HandleRequestRatedPvpInfo (WorldPackets::Battleground::RequestRatedPvpInfo &packet)

void	HandleGetPVPOptionsEnabled (WorldPackets::Battleground::GetPVPOptionsEnabled &getPvPOptionsEnabled)

void	HandleRequestPvpReward (WorldPackets::Battleground::RequestPVPRewards &packet)

void	HandleAreaSpiritHealerQueryOpcode (WorldPackets::Battleground::AreaSpiritHealerQuery &areaSpiritHealerQuery)

void	HandleAreaSpiritHealerQueueOpcode (WorldPackets::Battleground::AreaSpiritHealerQueue &areaSpiritHealerQueue)

void	HandleHearthAndResurrect (WorldPackets::Battleground::HearthAndResurrect &hearthAndResurrect)

void	HandleRequestBattlefieldStatusOpcode (WorldPackets::Battleground::RequestBattlefieldStatus &requestBattlefieldStatus)

void	HandleMinimapPingOpcode (WorldPackets::Party::MinimapPingClient &packet)

void	HandleRandomRollOpcode (WorldPackets::Misc::RandomRollClient &packet)

void	HandleFarSightOpcode (WorldPackets::Misc::FarSight &packet)

void	HandleSetDungeonDifficultyOpcode (WorldPackets::Misc::SetDungeonDifficulty &setDungeonDifficulty)

void	HandleSetRaidDifficultyOpcode (WorldPackets::Misc::SetRaidDifficulty &setRaidDifficulty)

void	HandleSetTitleOpcode (WorldPackets::Character::SetTitle &packet)

void	HandleTimeSyncResponse (WorldPackets::Misc::TimeSyncResponse &timeSyncResponse)

void	HandleWhoIsOpcode (WorldPackets::Who::WhoIsRequest &packet)

void	HandleResetInstancesOpcode (WorldPackets::Instance::ResetInstances &packet)

void	HandleInstanceLockResponse (WorldPackets::Instance::InstanceLockResponse &packet)

void	SendLfgPlayerLockInfo ()

void	SendLfgPartyLockInfo ()

void	HandleLfgJoinOpcode (WorldPackets::LFG::DFJoin &dfJoin)

void	HandleLfgLeaveOpcode (WorldPackets::LFG::DFLeave &dfLeave)

void	HandleLfgProposalResultOpcode (WorldPackets::LFG::DFProposalResponse &dfProposalResponse)

void	HandleLfgSetRolesOpcode (WorldPackets::LFG::DFSetRoles &dfSetRoles)

void	HandleLfgSetBootVoteOpcode (WorldPackets::LFG::DFBootPlayerVote &dfBootPlayerVote)

void	HandleLfgTeleportOpcode (WorldPackets::LFG::DFTeleport &dfTeleport)

void	HandleDFGetSystemInfo (WorldPackets::LFG::DFGetSystemInfo &dfGetSystemInfo)

void	HandleDFGetJoinStatus (WorldPackets::LFG::DFGetJoinStatus &dfGetJoinStatus)

void	SendLfgUpdateStatus (lfg::LfgUpdateData const &updateData, bool party)

void	SendLfgRoleChosen (ObjectGuid guid, uint8 roles)

void	SendLfgRoleCheckUpdate (lfg::LfgRoleCheck const &pRoleCheck)

void	SendLfgJoinResult (lfg::LfgJoinResultData const &joinData)

void	SendLfgQueueStatus (lfg::LfgQueueStatusData const &queueData)

void	SendLfgPlayerReward (lfg::LfgPlayerRewardData const &lfgPlayerRewardData)

void	SendLfgBootProposalUpdate (lfg::LfgPlayerBoot const &boot)

void	SendLfgUpdateProposal (lfg::LfgProposal const &proposal)

void	SendLfgDisabled ()

void	SendLfgOfferContinue (uint32 dungeonEntry)

void	SendLfgTeleportError (lfg::LfgTeleportResult err)

void	HandleSelfResOpcode (WorldPackets::Spells::SelfRes &selfRes)

void	HandleRequestPetInfo (WorldPackets::Pet::RequestPetInfo &requestPetInfo)

void	HandleSocketGems (WorldPackets::Item::SocketGems &socketGems)

void	HandleSortBags (WorldPackets::Item::SortBags &sortBags)

void	HandleSortBankBags (WorldPackets::Item::SortBankBags &sortBankBags)

void	HandleSortReagentBankBags (WorldPackets::Item::SortReagentBankBags &sortReagentBankBags)

void	HandleRemoveNewItem (WorldPackets::Item::RemoveNewItem &removeNewItem)

void	HandleCancelTempEnchantmentOpcode (WorldPackets::Item::CancelTempEnchantment &cancelTempEnchantment)

void	HandleGetItemPurchaseData (WorldPackets::Item::GetItemPurchaseData &packet)

void	HandleItemRefund (WorldPackets::Item::ItemPurchaseRefund &packet)

void	HandleSetTaxiBenchmark (WorldPackets::Misc::SetTaxiBenchmarkMode &packet)

void	HandleGuildPermissionsQuery (WorldPackets::Guild::GuildPermissionsQuery &packet)

void	HandleGuildBankMoneyWithdrawn (WorldPackets::Guild::GuildBankRemainingWithdrawMoneyQuery &packet)

void	HandleGuildBankActivate (WorldPackets::Guild::GuildBankActivate &packet)

void	HandleGuildBankQueryTab (WorldPackets::Guild::GuildBankQueryTab &packet)

void	HandleGuildBankLogQuery (WorldPackets::Guild::GuildBankLogQuery &packet)

void	HandleGuildBankDepositMoney (WorldPackets::Guild::GuildBankDepositMoney &packet)

void	HandleGuildBankWithdrawMoney (WorldPackets::Guild::GuildBankWithdrawMoney &packet)

void	HandleAutoGuildBankItem (WorldPackets::Guild::AutoGuildBankItem &autoGuildBankItem)

void	HandleStoreGuildBankItem (WorldPackets::Guild::StoreGuildBankItem &storeGuildBankItem)

void	HandleSwapItemWithGuildBankItem (WorldPackets::Guild::SwapItemWithGuildBankItem &swapItemWithGuildBankItem)

void	HandleSwapGuildBankItemWithGuildBankItem (WorldPackets::Guild::SwapGuildBankItemWithGuildBankItem &swapGuildBankItemWithGuildBankItem)

void	HandleMoveGuildBankItem (WorldPackets::Guild::MoveGuildBankItem &moveGuildBankItem)

void	HandleMergeItemWithGuildBankItem (WorldPackets::Guild::MergeItemWithGuildBankItem &mergeItemWithGuildBankItem)

void	HandleSplitItemToGuildBank (WorldPackets::Guild::SplitItemToGuildBank &splitItemToGuildBank)

void	HandleMergeGuildBankItemWithItem (WorldPackets::Guild::MergeGuildBankItemWithItem &mergeGuildBankItemWithItem)

void	HandleSplitGuildBankItemToInventory (WorldPackets::Guild::SplitGuildBankItemToInventory &splitGuildBankItemToInventory)

void	HandleAutoStoreGuildBankItem (WorldPackets::Guild::AutoStoreGuildBankItem &autoStoreGuildBankItem)

void	HandleMergeGuildBankItemWithGuildBankItem (WorldPackets::Guild::MergeGuildBankItemWithGuildBankItem &mergeGuildBankItemWithGuildBankItem)

void	HandleSplitGuildBankItem (WorldPackets::Guild::SplitGuildBankItem &splitGuildBankItem)

void	HandleGuildBankUpdateTab (WorldPackets::Guild::GuildBankUpdateTab &packet)

void	HandleGuildBankBuyTab (WorldPackets::Guild::GuildBankBuyTab &packet)

void	HandleGuildBankTextQuery (WorldPackets::Guild::GuildBankTextQuery &packet)

void	HandleGuildBankSetTabText (WorldPackets::Guild::GuildBankSetTabText &packet)

void	HandleCalendarGetCalendar (WorldPackets::Calendar::CalendarGetCalendar &calendarGetCalendar)

void	HandleCalendarGetEvent (WorldPackets::Calendar::CalendarGetEvent &calendarGetEvent)

void	HandleCalendarCommunityInvite (WorldPackets::Calendar::CalendarCommunityInviteRequest &calendarCommunityInvite)

void	HandleCalendarAddEvent (WorldPackets::Calendar::CalendarAddEvent &calendarAddEvent)

void	HandleCalendarUpdateEvent (WorldPackets::Calendar::CalendarUpdateEvent &calendarUpdateEvent)

void	HandleCalendarRemoveEvent (WorldPackets::Calendar::CalendarRemoveEvent &calendarRemoveEvent)

void	HandleCalendarCopyEvent (WorldPackets::Calendar::CalendarCopyEvent &calendarCopyEvent)

void	HandleCalendarInvite (WorldPackets::Calendar::CalendarInvite &calendarEventInvite)

void	HandleCalendarRsvp (WorldPackets::Calendar::CalendarRSVP &calendarRSVP)

void	HandleCalendarEventRemoveInvite (WorldPackets::Calendar::CalendarRemoveInvite &calendarRemoveInvite)

void	HandleCalendarStatus (WorldPackets::Calendar::CalendarStatus &calendarStatus)

void	HandleCalendarModeratorStatus (WorldPackets::Calendar::CalendarModeratorStatusQuery &calendarModeratorStatus)

void	HandleCalendarComplain (WorldPackets::Calendar::CalendarComplain &calendarComplain)

void	HandleCalendarGetNumPending (WorldPackets::Calendar::CalendarGetNumPending &calendarGetNumPending)

void	HandleCalendarEventSignup (WorldPackets::Calendar::CalendarEventSignUp &calendarEventSignUp)

void	SendCalendarRaidLockoutAdded (InstanceLock const *lock)

void	SendCalendarRaidLockoutRemoved (InstanceLock const *lock)

void	HandleSetSavedInstanceExtend (WorldPackets::Calendar::SetSavedInstanceExtend &setSavedInstanceExtend)

void	HandleVoidStorageUnlock (WorldPackets::VoidStorage::UnlockVoidStorage &unlockVoidStorage)

void	HandleVoidStorageQuery (WorldPackets::VoidStorage::QueryVoidStorage &queryVoidStorage)

void	HandleVoidStorageTransfer (WorldPackets::VoidStorage::VoidStorageTransfer &voidStorageTransfer)

void	HandleVoidSwapItem (WorldPackets::VoidStorage::SwapVoidItem &swapVoidItem)

void	SendVoidStorageTransferResult (VoidTransferError result)

void	HandleCollectionItemSetFavorite (WorldPackets::Collections::CollectionItemSetFavorite &collectionItemSetFavorite)

void	HandleTransmogrifyItems (WorldPackets::Transmogrification::TransmogrifyItems &transmogrifyItems)

void	HandleSpellClick (WorldPackets::Spells::SpellClick &spellClick)

void	HandleMirrorImageDataRequest (WorldPackets::Spells::GetMirrorImageData &getMirrorImageData)

void	HandleGuildSetFocusedAchievement (WorldPackets::Achievement::GuildSetFocusedAchievement &setFocusedAchievement)

void	HandleEquipmentSetSave (WorldPackets::EquipmentSet::SaveEquipmentSet &saveEquipmentSet)

void	HandleDeleteEquipmentSet (WorldPackets::EquipmentSet::DeleteEquipmentSet &deleteEquipmentSet)

void	HandleUseEquipmentSet (WorldPackets::EquipmentSet::UseEquipmentSet &useEquipmentSet)

void	HandleServerTimeOffsetRequest (WorldPackets::Misc::ServerTimeOffsetRequest &)

void	HandleQueryQuestCompletionNPCs (WorldPackets::Query::QueryQuestCompletionNPCs &queryQuestCompletionNPCs)

void	HandleQuestPOIQuery (WorldPackets::Query::QuestPOIQuery &questPoiQuery)

void	HandleViolenceLevel (WorldPackets::Misc::ViolenceLevel &violenceLevel)

void	HandleObjectUpdateFailedOpcode (WorldPackets::Misc::ObjectUpdateFailed &objectUpdateFailed)

void	HandleObjectUpdateRescuedOpcode (WorldPackets::Misc::ObjectUpdateRescued &objectUpdateRescued)

void	HandleRequestCategoryCooldowns (WorldPackets::Spells::RequestCategoryCooldowns &requestCategoryCooldowns)

void	HandleCloseInteraction (WorldPackets::Misc::CloseInteraction &closeInteraction)

void	HandleConversationLineStarted (WorldPackets::Misc::ConversationLineStarted &conversationLineStarted)

void	HandleKeyboundOverride (WorldPackets::Spells::KeyboundOverride &keyboundOverride)

void	HandleAdventureJournalOpenQuest (WorldPackets::AdventureJournal::AdventureJournalOpenQuest &openQuest)

void	HandleAdventureJournalUpdateSuggestions (WorldPackets::AdventureJournal::AdventureJournalUpdateSuggestions &updateSuggestions)

void	HandleAdventureMapStartQuest (WorldPackets::AdventureMap::AdventureMapStartQuest &startQuest)

void	HandleAddToy (WorldPackets::Toy::AddToy &packet)

void	HandleUseToy (WorldPackets::Toy::UseToy &packet)

void	HandleToyClearFanfare (WorldPackets::Toy::ToyClearFanfare &toyClearFanfare)

void	HandleMountSetFavorite (WorldPackets::Misc::MountSetFavorite &mountSetFavorite)

void	HandleSceneTriggerEvent (WorldPackets::Scenes::SceneTriggerEvent &sceneTriggerEvent)

void	HandleScenePlaybackComplete (WorldPackets::Scenes::ScenePlaybackComplete &scenePlaybackComplete)

void	HandleScenePlaybackCanceled (WorldPackets::Scenes::ScenePlaybackCanceled &scenePlaybackCanceled)

void	HandleCommerceTokenGetLog (WorldPackets::Token::CommerceTokenGetLog &updateListedAuctionableTokens)

void	HandleCommerceTokenGetMarketPrice (WorldPackets::Token::CommerceTokenGetMarketPrice &requestWowTokenMarketPrice)

void	HandleSaveCUFProfiles (WorldPackets::Misc::SaveCUFProfiles &packet)

void	SendLoadCUFProfiles ()

void	HandleGetGarrisonInfo (WorldPackets::Garrison::GetGarrisonInfo &getGarrisonInfo)

void	HandleGarrisonPurchaseBuilding (WorldPackets::Garrison::GarrisonPurchaseBuilding &garrisonPurchaseBuilding)

void	HandleGarrisonCancelConstruction (WorldPackets::Garrison::GarrisonCancelConstruction &garrisonCancelConstruction)

void	HandleGarrisonRequestBlueprintAndSpecializationData (WorldPackets::Garrison::GarrisonRequestBlueprintAndSpecializationData &garrisonRequestBlueprintAndSpecializationData)

void	HandleGarrisonGetMapData (WorldPackets::Garrison::GarrisonGetMapData &garrisonGetMapData)

void	HandleBattlePetRequestJournal (WorldPackets::BattlePet::BattlePetRequestJournal &battlePetRequestJournal)

void	HandleBattlePetRequestJournalLock (WorldPackets::BattlePet::BattlePetRequestJournalLock &battlePetRequestJournalLock)

void	HandleBattlePetSetBattleSlot (WorldPackets::BattlePet::BattlePetSetBattleSlot &battlePetSetBattleSlot)

void	HandleBattlePetModifyName (WorldPackets::BattlePet::BattlePetModifyName &battlePetModifyName)

void	HandleQueryBattlePetName (WorldPackets::BattlePet::QueryBattlePetName &queryBattlePetName)

void	HandleBattlePetDeletePet (WorldPackets::BattlePet::BattlePetDeletePet &battlePetDeletePet)

void	HandleBattlePetSetFlags (WorldPackets::BattlePet::BattlePetSetFlags &battlePetSetFlags)

void	HandleBattlePetClearFanfare (WorldPackets::BattlePet::BattlePetClearFanfare &battlePetClearFanfare)

void	HandleBattlePetSummon (WorldPackets::BattlePet::BattlePetSummon &battlePetSummon)

void	HandleBattlePetUpdateNotify (WorldPackets::BattlePet::BattlePetUpdateNotify &battlePetUpdateNotify)

void	HandleCageBattlePet (WorldPackets::BattlePet::CageBattlePet &cageBattlePet)

void	HandleWardenData (WorldPackets::Warden::WardenData &packet)

void	HandleBattlenetChangeRealmTicket (WorldPackets::Battlenet::ChangeRealmTicket &changeRealmTicket)

void	HandleBattlenetRequest (WorldPackets::Battlenet::Request &request)

void	SendBattlenetResponse (uint32 serviceHash, uint32 methodId, uint32 token, pb::Message const *response)

void	SendBattlenetResponse (uint32 serviceHash, uint32 methodId, uint32 token, uint32 status)

void	SendBattlenetRequest (uint32 serviceHash, uint32 methodId, pb::Message const *request, std::function< void(MessageBuffer)> callback)

void	SendBattlenetRequest (uint32 serviceHash, uint32 methodId, pb::Message const *request)

std::array< uint8, 32 > const &	GetRealmListSecret () const

void	SetRealmListSecret (std::array< uint8, 32 > const &secret)

std::unordered_map< uint32, uint8 > const &	GetRealmCharacterCounts () const

void	HandleQueryRealmName (WorldPackets::Query::QueryRealmName &queryRealmName)

void	HandleArtifactAddPower (WorldPackets::Artifact::ArtifactAddPower &artifactAddPower)

void	HandleArtifactSetAppearance (WorldPackets::Artifact::ArtifactSetAppearance &artifactSetAppearance)

void	HandleConfirmArtifactRespec (WorldPackets::Artifact::ConfirmArtifactRespec &confirmArtifactRespec)

void	HandleQueryScenarioPOI (WorldPackets::Scenario::QueryScenarioPOI &queryScenarioPOI)

void	HandleAzeriteEssenceUnlockMilestone (WorldPackets::Azerite::AzeriteEssenceUnlockMilestone &azeriteEssenceUnlockMilestone)

void	HandleAzeriteEssenceActivateEssence (WorldPackets::Azerite::AzeriteEssenceActivateEssence &azeriteEssenceActivateEssence)

void	HandleAzeriteEmpoweredItemViewed (WorldPackets::Azerite::AzeriteEmpoweredItemViewed &azeriteEmpoweredItemViewed)

void	HandleAzeriteEmpoweredItemSelectPower (WorldPackets::Azerite::AzeriteEmpoweredItemSelectPower &azeriteEmpoweredItemSelectPower)

void	SendAzeriteRespecNPC (ObjectGuid npc)

void	HandleRequestLatestSplashScreen (WorldPackets::Misc::RequestLatestSplashScreen &requestLatestSplashScreen)

void	HandleSocialContractRequest (WorldPackets::Social::SocialContractRequest &socialContractRequest)

uint64	GetConnectToInstanceKey () const

QueryCallbackProcessor &	GetQueryProcessor ()

TransactionCallback &	AddTransactionCallback (TransactionCallback &&callback)

SQLQueryHolderCallback &	AddQueryHolderCallback (SQLQueryHolderCallback &&callback)

Public Attributes
time_t	m_muteTime

std::atomic< time_t >	m_timeOutTime

Protected Attributes
class WorldSession::DosProtection	AntiDOS

Private Member Functions
void	ProcessQueryCallbacks ()

void	moveItems (Item myItems[], Item hisItems[])

bool	CanUseBank (ObjectGuid bankerGUID=ObjectGuid::Empty) const

void	LogUnexpectedOpcode (WorldPacket packet, char const status, const char *reason)
	Logging helper for unexpected opcodes. More...

bool	IsLegitCharacterForAccount (ObjectGuid lowGUID)

void	ComputeNewClockDelta ()

	WorldSession (WorldSession const &right)=delete

WorldSession &	operator= (WorldSession const &right)=delete

Private Attributes
QueryCallbackProcessor	_queryProcessor

AsyncCallbackProcessor< TransactionCallback >	_transactionCallbacks

AsyncCallbackProcessor< SQLQueryHolderCallback >	_queryHolderProcessor

GuidSet	_legitCharacters

ObjectGuid::LowType	m_GUIDLow

Player *	_player

std::shared_ptr< WorldSocket >	m_Socket [MAX_CONNECTION_TYPES]

std::string	m_Address

AccountTypes	_security

uint32	_accountId

std::string	_accountName

uint32	_battlenetAccountId

uint8	m_accountExpansion

uint8	m_expansion

std::string	_os

std::array< uint8, 32 >	_realmListSecret

std::unordered_map< uint32, uint8 >	_realmCharacterCounts

std::unordered_map< uint32, std::function< void(MessageBuffer)> >	_battlenetResponseCallbacks

uint32	_battlenetRequestToken

std::unique_ptr< Warden >	_warden

time_t	_logoutTime

bool	m_inQueue

ObjectGuid	m_playerLoading

bool	m_playerLogout

bool	m_playerRecentlyLogout

bool	m_playerSave

LocaleConstant	m_sessionDbcLocale

LocaleConstant	m_sessionDbLocaleIndex

std::atomic< uint32 >	m_latency

AccountData	_accountData [NUM_ACCOUNT_DATA_TYPES]

uint32	_tutorials [MAX_ACCOUNT_TUTORIAL_VALUES]

uint8	_tutorialsChanged

std::vector< std::string >	_registeredAddonPrefixes

bool	_filterAddonMessages

uint32	recruiterId

bool	isRecruiter

LockedQueue< WorldPacket * >	_recvQueue

rbac::RBACData *	_RBACData

uint32	expireTime

bool	forceExit

std::unique_ptr< boost::circular_buffer< std::pair< int64, uint32 > > >	_timeSyncClockDeltaQueue

int64	_timeSyncClockDelta

std::map< uint32, uint32 >	_pendingTimeSyncRequests

uint32	_timeSyncNextCounter

uint32	_timeSyncTimer

time_t	_calendarEventCreationCooldown

std::unique_ptr< BattlePets::BattlePetMgr >	_battlePetMgr

std::unique_ptr< CollectionMgr >	_collectionMgr

ConnectToKey	_instanceConnectKey

Friends
class	World

Detailed Description

Player session in the World.

Constructor & Destructor Documentation

◆ WorldSession() [1/2]

WorldSession::WorldSession	(	uint32	id,
		std::string &&	name,
		uint32	battlenetAccountId,
		std::shared_ptr< WorldSocket >	sock,
		AccountTypes	sec,
		uint8	expansion,
		time_t	mute_time,
		std::string	os,
		LocaleConstant	locale,
		uint32	recruiter,
		bool	isARecruiter
	)

WorldSession constructor.

 :
 m_muteTime(mute_time),
 m_timeOutTime(0),
 AntiDOS(this),
 m_GUIDLow(UI64LIT(0)),
 _player(nullptr),
 _security(sec),
 _accountId(id),
 _accountName(std::move(name)),
 _battlenetAccountId(battlenetAccountId),
 m_accountExpansion(expansion),
 m_expansion(std::min<uint8>(expansion, sWorld->getIntConfig(CONFIG_EXPANSION))),
 _os(os),
 _battlenetRequestToken(0),
 _logoutTime(0),
 m_inQueue(false),
 m_playerLogout(false),
 m_playerRecentlyLogout(false),
 m_playerSave(false),
 m_sessionDbcLocale(sWorld->GetAvailableDbcLocale(locale)),
 m_sessionDbLocaleIndex(locale),
 m_latency(0),
 _tutorialsChanged(TUTORIALS_FLAG_NONE),
 _filterAddonMessages(false),
 recruiterId(recruiter),
 isRecruiter(isARecruiter),
 _RBACData(nullptr),
 expireTime(60000), // 1 min after socket loss, session is deleted
 forceExit(false),
 _timeSyncClockDeltaQueue(std::make_unique<boost::circular_buffer<std::pair<int64, uint32>>>(6)),
 _timeSyncClockDelta(0),
 _pendingTimeSyncRequests(),
 _timeSyncNextCounter(0),
 _timeSyncTimer(0),
 _calendarEventCreationCooldown(0),
 _battlePetMgr(std::make_unique<BattlePets::BattlePetMgr>(this)),
 _collectionMgr(std::make_unique<CollectionMgr>(this))
{
 memset(_tutorials, 0, sizeof(_tutorials));
 
 if (sock)
 {
 m_Address = sock->GetRemoteIpAddress().to_string();
 ResetTimeOutTime(false);
 LoginDatabase.PExecute("UPDATE account SET online = 1 WHERE id = {};", GetAccountId()); // One-time query
 }
 
 m_Socket[CONNECTION_TYPE_REALM] = sock;
 _instanceConnectKey.Raw = UI64LIT(0);
}

Here is the call graph for this function:

◆ ~WorldSession()

WorldSession::~WorldSession ( )

WorldSession destructor.

unload player if not unloaded
If have unclosed socket, close it
empty incoming packet queue

{
 if (_player)
 LogoutPlayer (true);
 
 for (uint8 i = 0; i < 2; ++i)
 {
 if (m_Socket[i])
 {
 m_Socket[i]->CloseSocket();
 m_Socket[i].reset();
 }
 }
 
 delete _RBACData;
 
 WorldPacket* packet = nullptr;
 while (_recvQueue.next(packet))
 delete packet;
 
 LoginDatabase.PExecute("UPDATE account SET online = 0 WHERE id = {};", GetAccountId()); // One-time query
}

Here is the call graph for this function:

◆ WorldSession() [2/2]

WorldSession::WorldSession ( WorldSession const & right )

privatedelete

Member Function Documentation

◆ AbortLogin()

void WorldSession::AbortLogin ( WorldPackets::Character::LoginFailureReason reason )

{
 if (!PlayerLoading() || GetPlayer())
 {
 KickPlayer("WorldSession::AbortLogin incorrect player state when logging in");
 return;
 }
 
 m_playerLoading.Clear();
 SendPacket(WorldPackets::Character::CharacterLoginFailed(reason).Write());
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AddInstanceConnection()

void WorldSession::AddInstanceConnection ( std::shared_ptr< WorldSocket > sock )

inline

968{ m_Socket[CONNECTION_TYPE_INSTANCE] = sock; }

CONNECTION_TYPE_INSTANCE

@ CONNECTION_TYPE_INSTANCE

Definition: Opcodes.h:31

Here is the caller graph for this function:

◆ AddQueryHolderCallback()

SQLQueryHolderCallback & WorldSession::AddQueryHolderCallback ( SQLQueryHolderCallback && callback )

{
 return _queryHolderProcessor.AddCallback(std::move(callback));
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AddTransactionCallback()

TransactionCallback & WorldSession::AddTransactionCallback ( TransactionCallback && callback )

{
 return _transactionCallbacks.AddCallback(std::move(callback));
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AdjustClientMovementTime()

uint32 WorldSession::AdjustClientMovementTime ( uint32 time ) const

{
 int64 movementTime = int64(time) + _timeSyncClockDelta;
 if (_timeSyncClockDelta == 0 || movementTime < 0 || movementTime > 0xFFFFFFFF)
 {
 TC_LOG_WARN("misc", "The computed movement time using clockDelta is erronous. Using fallback instead");
 return GameTime::GetGameTimeMS();
 }
 else
 return uint32(movementTime);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BuildNameQueryData()

void WorldSession::BuildNameQueryData	(	ObjectGuid	guid,
		WorldPackets::Query::NameCacheLookupResult &	lookupData
	)

{
 Player* player = ObjectAccessor::FindConnectedPlayer(guid);
 
 lookupData.Player = guid;
 
 lookupData.Data.emplace();
 if (lookupData.Data->Initialize(guid, player))
 lookupData.Result = RESPONSE_SUCCESS; // name known
 else
 lookupData.Result = RESPONSE_FAILURE; // name unknown
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CanAccessAlliedRaces()

bool WorldSession::CanAccessAlliedRaces ( ) const

{
 return GetAccountExpansion() >= EXPANSION_BATTLE_FOR_AZEROTH;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CanOpenMailBox()

bool WorldSession::CanOpenMailBox ( ObjectGuid guid )

{
 if (guid == _player->GetGUID())
 {
 if (!HasPermission(rbac::RBAC_PERM_COMMAND_MAILBOX))
 {
 TC_LOG_WARN("cheat", "{} attempted to open mailbox by using a cheat.", _player->GetName());
 return false;
 }
 }
 else if (guid.IsGameObject())
 {
 if (!_player->GetGameObjectIfCanInteractWith(guid, GAMEOBJECT_TYPE_MAILBOX))
 return false;
 }
 else if (guid.IsAnyTypeCreature())
 {
 if (!_player->GetNPCIfCanInteractWith(guid, UNIT_NPC_FLAG_MAILBOX, UNIT_NPC_FLAG_2_NONE))
 return false;
 }
 else
 return false;
 
 return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CanSpeak()

bool WorldSession::CanSpeak ( ) const

{
 return m_muteTime <= GameTime::GetGameTime();
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CanUseBank()

bool WorldSession::CanUseBank ( ObjectGuid bankerGUID = ObjectGuid::Empty ) const

private

{
 // bankerGUID parameter is optional, set to 0 by default.
 if (!bankerGUID)
 bankerGUID = _player->PlayerTalkClass->GetInteractionData().SourceGuid;
 
 bool isUsingBankCommand = (bankerGUID == GetPlayer()->GetGUID() && bankerGUID == _player->PlayerTalkClass->GetInteractionData().SourceGuid);
 
 if (!isUsingBankCommand)
 {
 Creature* creature = GetPlayer()->GetNPCIfCanInteractWith(bankerGUID, UNIT_NPC_FLAG_BANKER, UNIT_NPC_FLAG_2_NONE);
 if (!creature)
 return false;
 }
 
 return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CheckStableMaster()

bool WorldSession::CheckStableMaster ( ObjectGuid guid )

{
 // spell case or GM
 if (guid == GetPlayer()->GetGUID())
 {
 if (!GetPlayer()->IsGameMaster() && !GetPlayer()->HasAuraType(SPELL_AURA_OPEN_STABLE))
 {
 TC_LOG_DEBUG("entities.player.cheat", "{} attempt open stable in cheating way.", guid.ToString());
 return false;
 }
 }
 // stable master case
 else
 {
 if (!GetPlayer()->GetNPCIfCanInteractWith(guid, UNIT_NPC_FLAG_STABLEMASTER, UNIT_NPC_FLAG_2_NONE))
 {
 TC_LOG_DEBUG("entities.player", "Stablemaster {} not found or you can't interact with him.", guid.ToString());
 return false;
 }
 }
 return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ComputeNewClockDelta()

void WorldSession::ComputeNewClockDelta ( )

private

{
 // implementation of the technique described here: https://web.archive.org/web/20180430214420/http://www.mine-control.com/zack/timesync/timesync.html
 // to reduce the skew induced by dropped TCP packets that get resent.
 
 using namespace boost::accumulators;
 
 accumulator_set<uint32, features<tag::mean, tag::median, tag::variance(lazy)> > latencyAccumulator;
 
 for (auto [_, roundTripDuration] : *_timeSyncClockDeltaQueue)
 latencyAccumulator(roundTripDuration);
 
 uint32 latencyMedian = static_cast<uint32>(std::round(median(latencyAccumulator)));
 uint32 latencyStandardDeviation = static_cast<uint32>(std::round(sqrt(variance(latencyAccumulator))));
 
 accumulator_set<int64, features<tag::mean> > clockDeltasAfterFiltering;
 uint32 sampleSizeAfterFiltering = 0;
 for (auto [clockDelta, roundTripDuration] : *_timeSyncClockDeltaQueue)
 {
 if (roundTripDuration < latencyStandardDeviation + latencyMedian) {
 clockDeltasAfterFiltering(clockDelta);
 sampleSizeAfterFiltering++;
 }
 }
 
 if (sampleSizeAfterFiltering != 0)
 {
 int64 meanClockDelta = static_cast<int64>(std::round(mean(clockDeltasAfterFiltering)));
 if (std::abs(meanClockDelta - _timeSyncClockDelta) > 25)
 _timeSyncClockDelta = meanClockDelta;
 }
 else if (_timeSyncClockDelta == 0)
 _timeSyncClockDelta = _timeSyncClockDeltaQueue->back().first;
}

Here is the caller graph for this function:

◆ DisallowHyperlinksAndMaybeKick()

bool WorldSession::DisallowHyperlinksAndMaybeKick ( std::string const & str )

{
 if (str.find('|') == std::string::npos)
 return true;
 
 TC_LOG_ERROR("network", "Player {} {} sent a message which illegally contained a hyperlink:\n{}", GetPlayer()->GetName(),
 GetPlayer()->GetGUID().ToString(), str);
 
 if (sWorld->getIntConfig(CONFIG_CHAT_STRICT_LINK_CHECKING_KICK))
 KickPlayer("WorldSession::DisallowHyperlinksAndMaybeKick Illegal chat link");
 
 return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DoLootRelease()

void WorldSession::DoLootRelease ( Loot * loot )

{
 ObjectGuid lguid = loot->GetOwnerGUID();
 Player *player = GetPlayer();
 
 if (player->GetLootGUID() == lguid)
 player->SetLootGUID(ObjectGuid::Empty);
 
 //Player is not looking at loot list, he doesn't need to see updates on the loot list
 loot->RemoveLooter(player->GetGUID());
 player->SendLootRelease(lguid);
 player->m_AELootView.erase(loot->GetGUID());
 
 if (player->GetAELootView().empty())
 player->RemoveUnitFlag(UNIT_FLAG_LOOTING);
 
 if (!player->IsInWorld())
 return;
 
 if (lguid.IsGameObject())
 {
 GameObject* go = GetPlayer()->GetMap()->GetGameObject(lguid);
 
 // not check distance for GO in case owned GO (fishing bobber case, for example) or Fishing hole GO
 if (!go || ((go->GetOwnerGUID() != player->GetGUID() && go->GetGoType() != GAMEOBJECT_TYPE_FISHINGHOLE) && !go->IsWithinDistInMap(player)))
 return;
 
 if (loot->isLooted() || go->GetGoType() == GAMEOBJECT_TYPE_FISHINGNODE || go->GetGoType() == GAMEOBJECT_TYPE_FISHINGHOLE)
 {
 if (go->GetGoType() == GAMEOBJECT_TYPE_FISHINGNODE)
 {
 go->SetLootState(GO_JUST_DEACTIVATED);
 }
 else if (go->GetGoType() == GAMEOBJECT_TYPE_FISHINGHOLE)
 { // The fishing hole used once more
 go->AddUse(); // if the max usage is reached, will be despawned in next tick
 if (go->GetUseCount() >= go->GetGOValue()->FishingHole.MaxOpens)
 go->SetLootState(GO_JUST_DEACTIVATED);
 else
 go->SetLootState(GO_READY);
 }
 else if (go->GetGoType() != GAMEOBJECT_TYPE_GATHERING_NODE && go->IsFullyLooted())
 go->SetLootState(GO_JUST_DEACTIVATED);
 
 go->OnLootRelease(player);
 }
 else
 {
 // not fully looted object
 go->SetLootState(GO_ACTIVATED, player);
 }
 }
 else if (lguid.IsCorpse()) // ONLY remove insignia at BG
 {
 Corpse* corpse = ObjectAccessor::GetCorpse(*player, lguid);
 if (!corpse || !corpse->IsWithinDistInMap(player, INTERACTION_DISTANCE))
 return;
 
 if (loot->isLooted())
 {
 corpse->m_loot = nullptr;
 corpse->RemoveCorpseDynamicFlag(CORPSE_DYNFLAG_LOOTABLE);
 }
 }
 else if (lguid.IsItem())
 {
 Item* pItem = player->GetItemByGuid(lguid);
 if (!pItem)
 return;
 
 ItemTemplate const* proto = pItem->GetTemplate();
 
 // destroy only 5 items from stack in case prospecting and milling
 if (loot->loot_type == LOOT_PROSPECTING || loot->loot_type == LOOT_MILLING)
 {
 pItem->m_lootGenerated = false;
 pItem->m_loot = nullptr;
 
 uint32 count = pItem->GetCount();
 
 // >=5 checked in spell code, but will work for cheating cases also with removing from another stacks.
 if (count > 5)
 count = 5;
 
 player->DestroyItemCount(pItem, count, true);
 }
 else
 {
 // Only delete item if no loot or money (unlooted loot is saved to db) or if it isn't an openable item
 if (loot->isLooted() || !proto->HasFlag(ITEM_FLAG_HAS_LOOT))
 player->DestroyItem(pItem->GetBagSlot(), pItem->GetSlot(), true);
 }
 return; // item can be looted only single player
 }
 else
 {
 Creature* creature = GetPlayer()->GetMap()->GetCreature(lguid);
 if (!creature)
 return;
 
 if (loot->isLooted())
 {
 if (creature->IsFullyLooted())
 {
 creature->RemoveDynamicFlag(UNIT_DYNFLAG_LOOTABLE);
 
 // skip pickpocketing loot for speed, skinning timer reduction is no-op in fact
 if (!creature->IsAlive())
 creature->AllLootRemovedFromCorpse();
 }
 }
 else
 {
 // if the round robin player release, reset it.
 if (player->GetGUID() == loot->roundRobinPlayer)
 {
 loot->roundRobinPlayer.Clear();
 loot->NotifyLootList(creature->GetMap());
 }
 }
 // force dynflag update to update looter and lootable info
 creature->ForceUpdateFieldChange(creature->m_values.ModifyValue(&Object::m_objectData).ModifyValue(&UF::ObjectData::DynamicFlags));
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DoLootReleaseAll()

void WorldSession::DoLootReleaseAll ( )

{
 std::unordered_map<ObjectGuid, Loot*> lootView = _player->GetAELootView();
 for (auto const& [lootGuid, loot] : lootView)
 DoLootRelease(loot);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetAccountData()

AccountData const * WorldSession::GetAccountData ( AccountDataType type ) const

inline

1076{ return &_accountData[type]; }

WorldSession::_accountData

AccountData _accountData[NUM_ACCOUNT_DATA_TYPES]

Definition: WorldSession.h:1931

Here is the caller graph for this function:

◆ GetAccountExpansion()

uint8 WorldSession::GetAccountExpansion ( ) const

inline

1002{ return m_accountExpansion; }

Here is the caller graph for this function:

◆ GetAccountGUID()

ObjectGuid WorldSession::GetAccountGUID ( ) const

inline

991{ return ObjectGuid::Create<HighGuid::WowAccount>(GetAccountId()); }

Here is the caller graph for this function:

◆ GetAccountId()

uint32 WorldSession::GetAccountId ( ) const

inline

990{ return _accountId; }

Here is the caller graph for this function:

◆ GetAccountName()

std::string const & WorldSession::GetAccountName ( ) const

inline

992{ return _accountName; }

Here is the caller graph for this function:

◆ GetBattlenetAccountGUID()

ObjectGuid WorldSession::GetBattlenetAccountGUID ( ) const

inline

994{ return ObjectGuid::Create<HighGuid::BNetAccount>(GetBattlenetAccountId()); }

WorldSession::GetBattlenetAccountId

uint32 GetBattlenetAccountId() const

Definition: WorldSession.h:993

Here is the caller graph for this function:

◆ GetBattlenetAccountId()

uint32 WorldSession::GetBattlenetAccountId ( ) const

inline

993{ return _battlenetAccountId; }

Here is the caller graph for this function:

◆ GetBattlePetMgr()

BattlePets::BattlePetMgr * WorldSession::GetBattlePetMgr ( ) const

inline

1165{ return _battlePetMgr.get(); }

Here is the caller graph for this function:

◆ GetCalendarEventCreationCooldown()

time_t WorldSession::GetCalendarEventCreationCooldown ( ) const

inline

1161{ return _calendarEventCreationCooldown; }

Here is the caller graph for this function:

◆ GetCollectionMgr()

CollectionMgr * WorldSession::GetCollectionMgr ( ) const

inline

1167{ return _collectionMgr.get(); }

Here is the caller graph for this function:

◆ GetConnectToInstanceKey()

uint64 WorldSession::GetConnectToInstanceKey ( ) const

inline

1837{ return _instanceConnectKey.Raw; }

Here is the caller graph for this function:

◆ GetExpansion()

uint8 WorldSession::GetExpansion ( ) const

inline

1003{ return m_expansion; }

Here is the caller graph for this function:

◆ GetLatency()

uint32 WorldSession::GetLatency ( ) const

inline

1142{ return m_latency; }

Here is the caller graph for this function:

◆ GetOS()

std::string const & WorldSession::GetOS ( ) const

inline

1004{ return _os; }

◆ GetPlayer()

Player * WorldSession::GetPlayer ( ) const

inline

995{ return _player; }

◆ GetPlayerInfo()

std::string WorldSession::GetPlayerInfo ( ) const

{
 std::ostringstream ss;
 
 ss << "[Player: ";
 if (!m_playerLoading.IsEmpty())
 ss << "Logging in: " << m_playerLoading.ToString() << ", ";
 else if (_player)
 ss << _player->GetName() << ' ' << _player->GetGUID().ToString() << ", ";
 
 ss << "Account: " << GetAccountId() << "]";
 
 return ss.str();
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetPlayerName()

std::string const & WorldSession::GetPlayerName ( ) const

{
 return _player != nullptr ? _player->GetName() : DefaultPlayerName;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetQueryProcessor()

QueryCallbackProcessor & WorldSession::GetQueryProcessor ( )

inline

1840{ return _queryProcessor; }

WorldSession::_queryProcessor

QueryCallbackProcessor _queryProcessor

Definition: WorldSession.h:1847

Here is the caller graph for this function:

◆ GetRBACData()

rbac::RBACData * WorldSession::GetRBACData ( )

{
 return _RBACData;
}

Here is the caller graph for this function:

◆ GetRealmCharacterCounts()

std::unordered_map< uint32, uint8 > const & WorldSession::GetRealmCharacterCounts ( ) const

inline

1802{ return _realmCharacterCounts; }

WorldSession::_realmCharacterCounts

std::unordered_map< uint32, uint8 > _realmCharacterCounts

Definition: WorldSession.h:1915

◆ GetRealmListSecret()

std::array< uint8, 32 > const & WorldSession::GetRealmListSecret ( ) const

inline

1799{ return _realmListSecret; }

WorldSession::_realmListSecret

std::array< uint8, 32 > _realmListSecret

Definition: WorldSession.h:1914

◆ GetRecruiterId()

uint32 WorldSession::GetRecruiterId ( ) const

inline

1152{ return recruiterId; }

Here is the caller graph for this function:

◆ GetRemoteAddress()

std::string const & WorldSession::GetRemoteAddress ( ) const

inline

1000{ return m_Address; }

Here is the caller graph for this function:

◆ GetSecurity()

AccountTypes WorldSession::GetSecurity ( ) const

inline

989{ return _security; }

Here is the caller graph for this function:

◆ GetSessionDbcLocale()

LocaleConstant WorldSession::GetSessionDbcLocale ( ) const

inline

1138{ return m_sessionDbcLocale; }

Here is the caller graph for this function:

◆ GetSessionDbLocaleIndex()

LocaleConstant WorldSession::GetSessionDbLocaleIndex ( ) const

inline

1139{ return m_sessionDbLocaleIndex; }

Here is the caller graph for this function:

◆ GetTrinityString()

char const * WorldSession::GetTrinityString ( uint32 entry ) const

{
 return sObjectMgr->GetTrinityString(entry, GetSessionDbLocaleIndex());
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetTutorialInt()

uint32 WorldSession::GetTutorialInt ( uint8 index ) const

inline

1084{ return _tutorials[index]; }

Here is the caller graph for this function:

◆ GetWarden() [1/2]

Warden * WorldSession::GetWarden ( )

inline

1007{ return _warden.get(); }

WorldSession::_warden

std::unique_ptr< Warden > _warden

Definition: WorldSession.h:1920

Here is the caller graph for this function:

◆ GetWarden() [2/2]

Warden const * WorldSession::GetWarden ( ) const

inline

1008{ return _warden.get(); }

◆ Handle_EarlyProccess()

void WorldSession::Handle_EarlyProccess ( WorldPackets::Null & null )

{
 TC_LOG_ERROR("network.opcode", "Received opcode {} that must be processed in WorldSocket::ReadDataHandler from {}"
 , GetOpcodeNameForLogging(null.GetOpcode()), GetPlayerInfo());
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Handle_NULL()

void WorldSession::Handle_NULL ( WorldPackets::Null & null )

{
 TC_LOG_ERROR("network.opcode", "Received unhandled opcode {} from {}", GetOpcodeNameForLogging(null.GetOpcode()), GetPlayerInfo());
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HandleAcceptTradeOpcode()

void WorldSession::HandleAcceptTradeOpcode ( WorldPackets::Trade::AcceptTrade & acceptTrade )

{
 TradeData* my_trade = _player->m_trade;
 if (!my_trade)
 return;
 
 Player* trader = my_trade->GetTrader();
 
 TradeData* his_trade = trader->m_trade;
 if (!his_trade)
 return;
 
 Item* myItems[TRADE_SLOT_TRADED_COUNT] = { };
 Item* hisItems[TRADE_SLOT_TRADED_COUNT] = { };
 
 // set before checks for propertly undo at problems (it already set in to client)
 my_trade->SetAccepted(true);
 
 WorldPackets::Trade::TradeStatus info;
 if (his_trade->GetServerStateIndex() != acceptTrade.StateIndex)
 {
 info.Status = TRADE_STATUS_STATE_CHANGED;
 SendTradeStatus(info);
 my_trade->SetAccepted(false);
 return;
 }
 
 if (!_player->IsWithinDistInMap(trader, TRADE_DISTANCE, false))
 {
 info.Status = TRADE_STATUS_TOO_FAR_AWAY;
 SendTradeStatus(info);
 my_trade->SetAccepted(false);
 return;
 }
 
 // not accept case incorrect money amount
 if (!_player->HasEnoughMoney(my_trade->GetMoney()))
 {
 info.Status = TRADE_STATUS_FAILED;
 info.BagResult = EQUIP_ERR_NOT_ENOUGH_MONEY;
 SendTradeStatus(info);
 my_trade->SetAccepted(false, true);
 return;
 }
 
 // not accept case incorrect money amount
 if (!trader->HasEnoughMoney(his_trade->GetMoney()))
 {
 info.Status = TRADE_STATUS_FAILED;
 info.BagResult = EQUIP_ERR_NOT_ENOUGH_MONEY;
 trader->GetSession()->SendTradeStatus(info);
 his_trade->SetAccepted(false, true);
 return;
 }
 
 if (_player->GetMoney() > MAX_MONEY_AMOUNT - his_trade->GetMoney())
 {
 info.Status = TRADE_STATUS_FAILED;
 info.BagResult = EQUIP_ERR_TOO_MUCH_GOLD;
 SendTradeStatus(info);
 my_trade->SetAccepted(false, true);
 return;
 }
 
 if (trader->GetMoney() > MAX_MONEY_AMOUNT - my_trade->GetMoney())
 {
 info.Status = TRADE_STATUS_FAILED;
 info.BagResult = EQUIP_ERR_TOO_MUCH_GOLD;
 trader->GetSession()->SendTradeStatus(info);
 his_trade->SetAccepted(false, true);
 return;
 }
 
 // not accept if some items now can't be trade (cheating)
 for (uint8 i = 0; i < TRADE_SLOT_TRADED_COUNT; ++i)
 {
 if (Item* item = my_trade->GetItem(TradeSlots(i)))
 {
 if (!item->CanBeTraded(false, true))
 {
 info.Status = TRADE_STATUS_CANCELLED;
 SendTradeStatus(info);
 return;
 }
 
 if (item->IsBindedNotWith(trader))
 {
 info.Status = TRADE_STATUS_FAILED;
 info.BagResult = EQUIP_ERR_TRADE_BOUND_ITEM;
 SendTradeStatus(info);
 return;
 }
 }
 
 if (Item* item = his_trade->GetItem(TradeSlots(i)))
 {
 if (!item->CanBeTraded(false, true))
 {
 info.Status = TRADE_STATUS_CANCELLED;
 SendTradeStatus(info);
 return;
 }
 //if (item->IsBindedNotWith(_player)) // dont mark as invalid when his item isnt good (not exploitable because if item is invalid trade will fail anyway later on the same check)
 //{
 // SendTradeStatus(TRADE_STATUS_NOT_ELIGIBLE);
 // his_trade->SetAccepted(false, true);
 // return;
 //}
 }
 }
 
 if (his_trade->IsAccepted())
 {
 setAcceptTradeMode(my_trade, his_trade, myItems, hisItems);
 
 Spell* my_spell = nullptr;
 SpellCastTargets my_targets;
 
 Spell* his_spell = nullptr;
 SpellCastTargets his_targets;
 
 // not accept if spell can't be cast now (cheating)
 if (uint32 my_spell_id = my_trade->GetSpell())
 {
 SpellInfo const* spellEntry = sSpellMgr->GetSpellInfo(my_spell_id, _player->GetMap()->GetDifficultyID());
 Item* castItem = my_trade->GetSpellCastItem();
 
 if (!spellEntry || !his_trade->GetItem(TRADE_SLOT_NONTRADED) ||
 (my_trade->HasSpellCastItem() && !castItem))
 {
 clearAcceptTradeMode(my_trade, his_trade);
 clearAcceptTradeMode(myItems, hisItems);
 
 my_trade->SetSpell(0);
 return;
 }
 
 my_spell = new Spell(_player, spellEntry, TRIGGERED_FULL_MASK);
 my_spell->m_CastItem = castItem;
 my_targets.SetTradeItemTarget(_player);
 my_spell->m_targets = my_targets;
 
 SpellCastResult res = my_spell->CheckCast(true);
 if (res != SPELL_CAST_OK)
 {
 my_spell->SendCastResult(res);
 
 clearAcceptTradeMode(my_trade, his_trade);
 clearAcceptTradeMode(myItems, hisItems);
 
 delete my_spell;
 my_trade->SetSpell(0);
 return;
 }
 }
 
 // not accept if spell can't be cast now (cheating)
 if (uint32 his_spell_id = his_trade->GetSpell())
 {
 SpellInfo const* spellEntry = sSpellMgr->GetSpellInfo(his_spell_id, trader->GetMap()->GetDifficultyID());
 Item* castItem = his_trade->GetSpellCastItem();
 
 if (!spellEntry || !my_trade->GetItem(TRADE_SLOT_NONTRADED) || (his_trade->HasSpellCastItem() && !castItem))
 {
 delete my_spell;
 his_trade->SetSpell(0);
 
 clearAcceptTradeMode(my_trade, his_trade);
 clearAcceptTradeMode(myItems, hisItems);
 return;
 }
 
 his_spell = new Spell(trader, spellEntry, TRIGGERED_FULL_MASK);
 his_spell->m_CastItem = castItem;
 his_targets.SetTradeItemTarget(trader);
 his_spell->m_targets = his_targets;
 
 SpellCastResult res = his_spell->CheckCast(true);
 if (res != SPELL_CAST_OK)
 {
 his_spell->SendCastResult(res);
 
 clearAcceptTradeMode(my_trade, his_trade);
 clearAcceptTradeMode(myItems, hisItems);
 
 delete my_spell;
 delete his_spell;
 
 his_trade->SetSpell(0);
 return;
 }
 }
 
 // inform partner client
 info.Status = TRADE_STATUS_ACCEPTED;
 trader->GetSession()->SendTradeStatus(info);
 
 // test if item will fit in each inventory
 WorldPackets::Trade::TradeStatus myCanCompleteInfo, hisCanCompleteInfo;
 hisCanCompleteInfo.BagResult = trader->CanStoreItems(myItems, TRADE_SLOT_TRADED_COUNT, &hisCanCompleteInfo.ItemID);
 myCanCompleteInfo.BagResult = _player->CanStoreItems(hisItems, TRADE_SLOT_TRADED_COUNT, &myCanCompleteInfo.ItemID);
 
 clearAcceptTradeMode(myItems, hisItems);
 
 // in case of missing space report error
 if (myCanCompleteInfo.BagResult != EQUIP_ERR_OK)
 {
 clearAcceptTradeMode(my_trade, his_trade);
 
 myCanCompleteInfo.Status = TRADE_STATUS_FAILED;
 trader->GetSession()->SendTradeStatus(myCanCompleteInfo);
 myCanCompleteInfo.FailureForYou = true;
 SendTradeStatus(myCanCompleteInfo);
 my_trade->SetAccepted(false);
 his_trade->SetAccepted(false);
 delete my_spell;
 delete his_spell;
 return;
 }
 else if (hisCanCompleteInfo.BagResult != EQUIP_ERR_OK)
 {
 clearAcceptTradeMode(my_trade, his_trade);
 
 hisCanCompleteInfo.Status = TRADE_STATUS_FAILED;
 SendTradeStatus(hisCanCompleteInfo);
 hisCanCompleteInfo.FailureForYou = true;
 trader->GetSession()->SendTradeStatus(hisCanCompleteInfo);
 my_trade->SetAccepted(false);
 his_trade->SetAccepted(false);
 delete my_spell;
 delete his_spell;
 return;
 }
 
 // execute trade: 1. remove
 for (uint8 i = 0; i < TRADE_SLOT_TRADED_COUNT; ++i)
 {
 if (myItems[i])
 {
 myItems[i]->SetGiftCreator(_player->GetGUID());
 _player->MoveItemFromInventory(myItems[i]->GetBagSlot(), myItems[i]->GetSlot(), true);
 }
 if (hisItems[i])
 {
 hisItems[i]->SetGiftCreator(trader->GetGUID());
 trader->MoveItemFromInventory(hisItems[i]->GetBagSlot(), hisItems[i]->GetSlot(), true);
 }
 }
 
 // execute trade: 2. store
 moveItems(myItems, hisItems);
 
 // logging money
 if (HasPermission(rbac::RBAC_PERM_LOG_GM_TRADE))
 {
 if (my_trade->GetMoney() > 0)
 {
 sLog->OutCommand(_player->GetSession()->GetAccountId(), "GM {} (Account: {}) give money (Amount: {}) to player: {} (Account: {})",
 _player->GetName(), _player->GetSession()->GetAccountId(),
 my_trade->GetMoney(),
 trader->GetName(), trader->GetSession()->GetAccountId());
 }
 
 if (his_trade->GetMoney() > 0)
 {
 sLog->OutCommand(trader->GetSession()->GetAccountId(), "GM {} (Account: {}) give money (Amount: {}) to player: {} (Account: {})",
 trader->GetName(), trader->GetSession()->GetAccountId(),
 his_trade->GetMoney(),
 _player->GetName(), _player->GetSession()->GetAccountId());
 }
 }
 
 // update money
 _player->ModifyMoney(-int64(my_trade->GetMoney()));
 _player->ModifyMoney(his_trade->GetMoney());
 trader->ModifyMoney(-int64(his_trade->GetMoney()));
 trader->ModifyMoney(my_trade->GetMoney());
 
 if (my_spell)
 my_spell->prepare(my_targets);
 
 if (his_spell)
 his_spell->prepare(his_targets);
 
 // cleanup
 clearAcceptTradeMode(my_trade, his_trade);
 delete _player->m_trade;
 _player->m_trade = nullptr;
 delete trader->m_trade;
 trader->m_trade = nullptr;
 
 // desynchronized with the other saves here (SaveInventoryAndGoldToDB() not have own transaction guards)
 CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
 _player->SaveInventoryAndGoldToDB(trans);
 trader->SaveInventoryAndGoldToDB(trans);
 CharacterDatabase.CommitTransaction(trans);
 
 info.Status = TRADE_STATUS_COMPLETE;
 trader->GetSession()->SendTradeStatus(info);
 SendTradeStatus(info);
 }
 else
 {
 info.Status = TRADE_STATUS_ACCEPTED;
 trader->GetSession()->SendTradeStatus(info);
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HandleActivateTaxiOpcode()

void WorldSession::HandleActivateTaxiOpcode ( WorldPackets::Taxi::ActivateTaxi & activateTaxi )

{
 Creature* unit = GetPlayer()->GetNPCIfCanInteractWith(activateTaxi.Vendor, UNIT_NPC_FLAG_FLIGHTMASTER, UNIT_NPC_FLAG_2_NONE);
 if (!unit)
 {
 TC_LOG_DEBUG("network", "WORLD: HandleActivateTaxiOpcode - {} not found or you can't interact with it.", activateTaxi.Vendor.ToString());
 SendActivateTaxiReply(ERR_TAXITOOFARAWAY);
 return;
 }
 
 uint32 curloc = sObjectMgr->GetNearestTaxiNode(unit->GetPositionX(), unit->GetPositionY(), unit->GetPositionZ(), unit->GetMapId(), GetPlayer()->GetTeam());
 if (!curloc)
 return;
 
 TaxiNodesEntry const* from = sTaxiNodesStore.LookupEntry(curloc);
 TaxiNodesEntry const* to = sTaxiNodesStore.LookupEntry(activateTaxi.Node);
 if (!to)
 return;
 
 if (!GetPlayer()->isTaxiCheater())
 {
 if (!GetPlayer()->m_taxi.IsTaximaskNodeKnown(curloc) || !GetPlayer()->m_taxi.IsTaximaskNodeKnown(activateTaxi.Node))
 {
 SendActivateTaxiReply(ERR_TAXINOTVISITED);
 return;
 }
 }
 
 uint32 preferredMountDisplay = 0;
 if (MountEntry const* mount = sMountStore.LookupEntry(activateTaxi.FlyingMountID))
 {
 if (GetPlayer()->HasSpell(mount->SourceSpellID))
 {
 if (DB2Manager::MountXDisplayContainer const* mountDisplays = sDB2Manager.GetMountDisplays(mount->ID))
 {
 DB2Manager::MountXDisplayContainer usableDisplays;
 std::copy_if(mountDisplays->begin(), mountDisplays->end(), std::back_inserter(usableDisplays), [this](MountXDisplayEntry const* mountDisplay)
 {
 if (PlayerConditionEntry const* playerCondition = sPlayerConditionStore.LookupEntry(mountDisplay->PlayerConditionID))
 return sConditionMgr->IsPlayerMeetingCondition(GetPlayer(), playerCondition);
 
 return true;
 });
 
 if (!usableDisplays.empty())
 preferredMountDisplay = Trinity::Containers::SelectRandomContainerElement(usableDisplays)->CreatureDisplayInfoID;
 }
 }
 }
 
 std::vector<uint32> nodes;
 TaxiPathGraph::GetCompleteNodeRoute(from, to, GetPlayer(), nodes);
 GetPlayer()->ActivateTaxiPathTo(nodes, unit, 0, preferredMountDisplay);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HandleAddFriendOpcode()

void WorldSession::HandleAddFriendOpcode ( WorldPackets::Social::AddFriend & packet )

{
 if (!normalizePlayerName(packet.Name))
 return;
 
 TC_LOG_DEBUG("network", "WorldSession::HandleAddFriendOpcode: {} asked to add friend: {}",
 GetPlayerInfo(), packet.Name);
 
 CharacterCacheEntry const* friendCharacterInfo = sCharacterCache->GetCharacterCacheByName(packet.Name);
 if (!friendCharacterInfo)
 {
 sSocialMgr->SendFriendStatus(GetPlayer(), FRIEND_NOT_FOUND, ObjectGuid::Empty);
 return;
 }
 
 auto processFriendRequest = [this,
 playerGuid = _player->GetGUID(),
 friendGuid = friendCharacterInfo->Guid,
 friendAccountGuid = ObjectGuid::Create<HighGuid::WowAccount>(friendCharacterInfo->AccountId),
 team = Player::TeamForRace(friendCharacterInfo->Race),
 friendNote = std::move(packet.Notes)]()
 {
 if (playerGuid.GetCounter() != m_GUIDLow)
 return; // not the player initiating request, do nothing
 
 FriendsResult friendResult = FRIEND_NOT_FOUND;
 if (friendGuid == GetPlayer()->GetGUID())
 friendResult = FRIEND_SELF;
 else if (GetPlayer()->GetTeam() != team && !HasPermission(rbac::RBAC_PERM_TWO_SIDE_ADD_FRIEND))
 friendResult = FRIEND_ENEMY;
 else if (GetPlayer()->GetSocial()->HasFriend(friendGuid))
 friendResult = FRIEND_ALREADY;
 else
 {
 Player* pFriend = ObjectAccessor::FindPlayer(friendGuid);
 if (pFriend && pFriend->IsVisibleGloballyFor(GetPlayer()))
 friendResult = FRIEND_ADDED_ONLINE;
 else
 friendResult = FRIEND_ADDED_OFFLINE;
 if (GetPlayer()->GetSocial()->AddToSocialList(friendGuid, friendAccountGuid, SOCIAL_FLAG_FRIEND))
 GetPlayer()->GetSocial()->SetFriendNote(friendGuid, friendNote);
 else
 friendResult = FRIEND_LIST_FULL;
 }
 
 sSocialMgr->SendFriendStatus(GetPlayer(), friendResult, friendGuid);
 };
 
 if (HasPermission(rbac::RBAC_PERM_ALLOW_GM_FRIEND))
 {
 processFriendRequest();
 return;
 }
 
 // First try looking up friend candidate security from online object
 if (Player* friendPlayer = ObjectAccessor::FindPlayer(friendCharacterInfo->Guid))
 {
  if (!AccountMgr::IsPlayerAccount(friendPlayer->GetSession()->GetSecurity()))
 {
 sSocialMgr->SendFriendStatus(GetPlayer(), FRIEND_NOT_FOUND, ObjectGuid::Empty);
 return;
 }
 
 processFriendRequest();
 return;
 }
 
 // When not found, consult database
 GetQueryProcessor().AddCallback(AccountMgr::GetSecurityAsync(friendCharacterInfo->AccountId, realm.Id.Realm,
 [this, continuation = std::move(processFriendRequest)](uint32 friendSecurity)
 {
 if (!AccountMgr::IsPlayerAccount(friendSecurity))
 {
 sSocialMgr->SendFriendStatus(GetPlayer(), FRIEND_NOT_FOUND, ObjectGuid::Empty);
 return;
 }
 
 continuation();
 }));
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HandleAddIgnoreOpcode()

void WorldSession::HandleAddIgnoreOpcode ( WorldPackets::Social::AddIgnore & packet )

{
 if (!normalizePlayerName(packet.Name))
 return;
 
 TC_LOG_DEBUG("network", "WorldSession::HandleAddIgnoreOpcode: {} asked to Ignore: {}",
 GetPlayer()->GetName(), packet.Name);
 
 ObjectGuid ignoreGuid;
 FriendsResult ignoreResult = FRIEND_IGNORE_NOT_FOUND;
 
 if (CharacterCacheEntry const* characterInfo = sCharacterCache->GetCharacterCacheByName(packet.Name))
 {
 ignoreGuid = characterInfo->Guid;
 ObjectGuid ignoreAccountGuid = ObjectGuid::Create<HighGuid::WowAccount>(characterInfo->AccountId);
 if (ignoreGuid == GetPlayer()->GetGUID()) //not add yourself
 ignoreResult = FRIEND_IGNORE_SELF;
 else if (GetPlayer()->GetSocial()->HasIgnore(ignoreGuid, ignoreAccountGuid))
 ignoreResult = FRIEND_IGNORE_ALREADY;
 else
 {
 ignoreResult = FRIEND_IGNORE_ADDED;
 
 // ignore list full
 if (!GetPlayer()->GetSocial()->AddToSocialList(ignoreGuid, ignoreAccountGuid, SOCIAL_FLAG_IGNORED))
 ignoreResult = FRIEND_IGNORE_FULL;
 }
 }
 
 sSocialMgr->SendFriendStatus(GetPlayer(), ignoreResult, ignoreGuid);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HandleAddonRegisteredPrefixesOpcode()

void WorldSession::HandleAddonRegisteredPrefixesOpcode ( WorldPackets::Chat::ChatRegisterAddonPrefixes & packet )

{
 // This is always sent after CMSG_CHAT_UNREGISTER_ALL_ADDON_PREFIXES
 _registeredAddonPrefixes.insert(_registeredAddonPrefixes.end(), packet.Prefixes.begin(), packet.Prefixes.end());
 if (_registeredAddonPrefixes.size() > WorldPackets::Chat::ChatRegisterAddonPrefixes::MAX_PREFIXES)
 {
 _filterAddonMessages = false;
 return;
 }
 
 _filterAddonMessages = true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HandleAddToy()

void WorldSession::HandleAddToy ( WorldPackets::Toy::AddToy & packet )

{
 if (!packet.Guid)
 return;
 
 Item* item = _player->GetItemByGuid(packet.Guid);
 if (!item)
 {
 _player->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, nullptr, nullptr);
 return;
 }
 
 if (!sDB2Manager.IsToyItem(item->GetEntry()))
 return;
 
 InventoryResult msg = _player->CanUseItem(item);
 if (msg != EQUIP_ERR_OK)
 {
 _player->SendEquipError(msg, item, nullptr);
 return;
 }
 
 if (_collectionMgr->AddToy(item->GetEntry(), false, false))
 _player->DestroyItem(item->GetBagSlot(), item->GetSlot(), true);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HandleAdventureJournalOpenQuest()

void WorldSession::HandleAdventureJournalOpenQuest ( WorldPackets::AdventureJournal::AdventureJournalOpenQuest & openQuest )

{
 if (ChrClassUIDisplayEntry const* uiDisplay = sDB2Manager.GetUiDisplayForClass(Classes(_player->GetClass())))
 if (!_player->MeetPlayerCondition(uiDisplay->AdvGuidePlayerConditionID))
 return;
 
 AdventureJournalEntry const* adventureJournal = sAdventureJournalStore.LookupEntry(openQuest.AdventureJournalID);
 if (!adventureJournal)
 return;
 
 if (!_player->MeetPlayerCondition(adventureJournal->PlayerConditionID))
 return;
 
 Quest const* quest = sObjectMgr->GetQuestTemplate(adventureJournal->QuestID);
 if (!quest)
 return;
 
 if (_player->CanTakeQuest(quest, true))
 _player->PlayerTalkClass->SendQuestGiverQuestDetails(quest, _player->GetGUID(), true, false);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HandleAdventureJournalUpdateSuggestions()

void WorldSession::HandleAdventureJournalUpdateSuggestions ( WorldPackets::AdventureJournal::AdventureJournalUpdateSuggestions & updateSuggestions )

{
 if (ChrClassUIDisplayEntry const* uiDisplay = sDB2Manager.GetUiDisplayForClass(Classes(_player->GetClass())))
 if (!_player->MeetPlayerCondition(uiDisplay->AdvGuidePlayerConditionID))
 return;
 
 WorldPackets::AdventureJournal::AdventureJournalDataResponse response;
 response.OnLevelUp = updateSuggestions.OnLevelUp;
 
 for (AdventureJournalEntry const* adventureJournal : sAdventureJournalStore)
 {
 if (_player->MeetPlayerCondition(adventureJournal->PlayerConditionID))
 {
 WorldPackets::AdventureJournal::AdventureJournalEntry adventureJournalData;
 adventureJournalData.AdventureJournalID = int32(adventureJournal->ID);
 adventureJournalData.Priority = int32(adventureJournal->PriorityMax);
 response.Entries.push_back(adventureJournalData);
 }
 }
 
 SendPacket(response.Write());
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HandleAdventureMapStartQuest()

void WorldSession::HandleAdventureMapStartQuest ( WorldPackets::AdventureMap::AdventureMapStartQuest & startQuest )

{
 Quest const* quest = sObjectMgr->GetQuestTemplate(startQuest.QuestID);
 if (!quest)
 return;
 
 auto itr = std::find_if(sAdventureMapPOIStore.begin(), sAdventureMapPOIStore.end(), [&](AdventureMapPOIEntry const* adventureMap)
 {
 return adventureMap->QuestID == uint32(startQuest.QuestID) && _player->MeetPlayerCondition(adventureMap->PlayerConditionID);
 });
 
 if (itr == sAdventureMapPOIStore.end())
 return;
 
 if (_player->CanTakeQuest(quest, true))
 _player->AddQuestAndCheckCompletion(quest, _player);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HandleAlterAppearance()

void WorldSession::HandleAlterAppearance ( WorldPackets::Character::AlterApperance & packet )

{
 if (!ValidateAppearance(Races(_player->GetRace()), Classes(_player->GetClass()), Gender(packet.NewSex), MakeChrCustomizationChoiceRange(packet.Customizations)))
 return;
 
 GameObject* go = _player->FindNearestGameObjectOfType(GAMEOBJECT_TYPE_BARBER_CHAIR, 5.0f);
 if (!go)
 {
 SendPacket(WorldPackets::Character::BarberShopResult(WorldPackets::Character::BarberShopResult::ResultEnum::NotOnChair).Write());
 return;
 }
 
 if (_player->GetStandState() != UnitStandStateType(UNIT_STAND_STATE_SIT_LOW_CHAIR + go->GetGOInfo()->barberChair.chairheight))
 {
 SendPacket(WorldPackets::Character::BarberShopResult(WorldPackets::Character::BarberShopResult::ResultEnum::NotOnChair).Write());
 return;
 }
 
 int64 cost = _player->GetBarberShopCost(MakeChrCustomizationChoiceRange(packet.Customizations));
 
 // 0 - ok
 // 1, 3 - not enough money
 // 2 - you have to sit on barber chair
 if (!_player->HasEnoughMoney(cost))
 {
 SendPacket(WorldPackets::Character::BarberShopResult(WorldPackets::Character::BarberShopResult::ResultEnum::NoMoney).Write());
 return;
 }
 
 SendPacket(WorldPackets::Character::BarberShopResult(WorldPackets::Character::BarberShopResult::ResultEnum::Success).Write());
 
 _player->ModifyMoney(-cost); // it isn't free
 _player->UpdateCriteria(CriteriaType::MoneySpentAtBarberShop, cost);
 
 if (_player->GetNativeGender() != packet.NewSex)
 {
 _player->SetNativeGender(Gender(packet.NewSex));
 _player->InitDisplayIds();
 _player->RestoreDisplayId(false);
 }
 
 _player->SetCustomizations(Trinity::Containers::MakeIteratorPair(packet.Customizations.begin(), packet.Customizations.end()));
 
 _player->UpdateCriteria(CriteriaType::GotHaircut, 1);
 
 _player->SetStandState(UNIT_STAND_STATE_STAND);
 
 sCharacterCache->UpdateCharacterGender(_player->GetGUID(), packet.NewSex);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HandleAreaSpiritHealerQueryOpcode()

void WorldSession::HandleAreaSpiritHealerQueryOpcode ( WorldPackets::Battleground::AreaSpiritHealerQuery & areaSpiritHealerQuery )

{
 Creature* unit = ObjectAccessor::GetCreature(*GetPlayer(), areaSpiritHealerQuery.HealerGuid);
 if (!unit)
 return;
 
 if (!unit->IsSpiritService()) // it's not spirit service
 return;
 
 if (Battleground* bg = _player->GetBattleground())
 sBattlegroundMgr->SendAreaSpiritHealerQueryOpcode(_player, bg, areaSpiritHealerQuery.HealerGuid);
 
 if (Battlefield* bf = sBattlefieldMgr->GetBattlefieldToZoneId(_player->GetMap(), _player->GetZoneId()))
 bf->SendAreaSpiritHealerQueryOpcode(_player, areaSpiritHealerQuery.HealerGuid);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HandleAreaSpiritHealerQueueOpcode()

void WorldSession::HandleAreaSpiritHealerQueueOpcode ( WorldPackets::Battleground::AreaSpiritHealerQueue & areaSpiritHealerQueue )

{
 Creature* unit = ObjectAccessor::GetCreature(*GetPlayer(), areaSpiritHealerQueue.HealerGuid);
 if (!unit)
 return;
 
 if (!unit->IsSpiritService()) // it's not spirit service
 return;
 
 if (Battleground* bg = _player->GetBattleground())
 bg->AddPlayerToResurrectQueue(areaSpiritHealerQueue.HealerGuid, _player->GetGUID());
 
 if (Battlefield* bf = sBattlefieldMgr->GetBattlefieldToZoneId(_player->GetMap(), _player->GetZoneId()))
 bf->AddPlayerToResurrectQueue(areaSpiritHealerQueue.HealerGuid, _player->GetGUID());
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HandleAreaTriggerOpcode()

void WorldSession::HandleAreaTriggerOpcode ( WorldPackets::AreaTrigger::AreaTrigger & packet )

{
 Player* player = GetPlayer();
 if (player->IsInFlight())
 {
 TC_LOG_DEBUG("network", "HandleAreaTriggerOpcode: Player '{}' {} in flight, ignore Area Trigger ID:{}",
 player->GetName(), player->GetGUID().ToString(), packet.AreaTriggerID);
 return;
 }
 
 AreaTriggerEntry const* atEntry = sAreaTriggerStore.LookupEntry(packet.AreaTriggerID);
 if (!atEntry)
 {
 TC_LOG_DEBUG("network", "HandleAreaTriggerOpcode: Player '{}' {} send unknown (by DBC) Area Trigger ID:{}",
 player->GetName(), player->GetGUID().ToString(), packet.AreaTriggerID);
 return;
 }
 
 if (packet.Entered && !player->IsInAreaTriggerRadius(atEntry))
 {
 TC_LOG_DEBUG("network", "HandleAreaTriggerOpcode: Player '{}' {} too far, ignore Area Trigger ID: {}",
 player->GetName(), player->GetGUID().ToString(), packet.AreaTriggerID);
 return;
 }
 
 if (player->isDebugAreaTriggers)
 ChatHandler(player->GetSession()).PSendSysMessage(packet.Entered ? LANG_DEBUG_AREATRIGGER_ENTERED : LANG_DEBUG_AREATRIGGER_LEFT, packet.AreaTriggerID);
 
 if (!sConditionMgr->IsObjectMeetingNotGroupedConditions(CONDITION_SOURCE_TYPE_AREATRIGGER_CLIENT_TRIGGERED, atEntry->ID, player))
 return;
 
 if (sScriptMgr->OnAreaTrigger(player, atEntry, packet.Entered))
 return;
 
 if (player->IsAlive())
 {
 // not using Player::UpdateQuestObjectiveProgress, ObjectID in quest_objectives can be set to -1, areatrigger_involvedrelation then holds correct id
 if (std::unordered_set<uint32> const* quests = sObjectMgr->GetQuestsForAreaTrigger(packet.AreaTriggerID))
 {
 bool anyObjectiveChangedCompletionState = false;
 for (uint32 questId : *quests)
 {
 Quest const* qInfo = sObjectMgr->GetQuestTemplate(questId);
 uint16 slot = player->FindQuestSlot(questId);
 if (qInfo && slot < MAX_QUEST_LOG_SIZE && player->GetQuestStatus(questId) == QUEST_STATUS_INCOMPLETE)
 {
 for (QuestObjective const& obj : qInfo->Objectives)
 {
 if (obj.Type != QUEST_OBJECTIVE_AREATRIGGER)
 continue;
 
 if (!player->IsQuestObjectiveCompletable(slot, qInfo, obj))
 continue;
 
 if (player->IsQuestObjectiveComplete(slot, qInfo, obj))
 continue;
 
  if (obj.ObjectID != -1 && obj.ObjectID != packet.AreaTriggerID)
 continue;
 
 player->SetQuestObjectiveData(obj, 1);
 player->SendQuestUpdateAddCreditSimple(obj);
 anyObjectiveChangedCompletionState = true;
 break;
 }
 
 if (player->CanCompleteQuest(questId))
 player->CompleteQuest(questId);
 }
 }
 
 if (anyObjectiveChangedCompletionState)
 player->UpdateVisibleGameobjectsOrSpellClicks();
 }
 }
 
 if (sObjectMgr->IsTavernAreaTrigger(packet.AreaTriggerID))
 {
 // set resting flag we are in the inn
 player->GetRestMgr().SetRestFlag(REST_FLAG_IN_TAVERN, atEntry->ID);
 
 if (sWorld->IsFFAPvPRealm())
 player->RemovePvpFlag(UNIT_BYTE2_FLAG_FFA_PVP);
 
 return;
 }
 
 if (Battleground* bg = player->GetBattleground())
 bg->HandleAreaTrigger(player, packet.AreaTriggerID, packet.Entered);
 
 if (OutdoorPvP* pvp = player->GetOutdoorPvP())
 if (pvp->HandleAreaTrigger(_player, packet.AreaTriggerID, packet.Entered))
 return;
 
 AreaTriggerStruct const* at = sObjectMgr->GetAreaTrigger(packet.AreaTriggerID);
 if (!at)
 return;
 
 bool teleported = false;
 if (player->GetMapId() != at->target_mapId)
 {
 if (!player->IsAlive())
 {
 if (player->HasCorpse())
 {
 // let enter in ghost mode in instance that connected to inner instance with corpse
 uint32 corpseMap = player->GetCorpseLocation().GetMapId();
 do
 {
 if (corpseMap == at->target_mapId)
 break;
 
 InstanceTemplate const* corpseInstance = sObjectMgr->GetInstanceTemplate(corpseMap);
 corpseMap = corpseInstance ? corpseInstance->Parent : 0;
 } while (corpseMap);
 
 if (!corpseMap)
 {
 SendPacket(WorldPackets::AreaTrigger::AreaTriggerNoCorpse().Write());
 return;
 }
 
 TC_LOG_DEBUG("maps", "MAP: Player '{}' has corpse in instance {} and can enter.", player->GetName(), at->target_mapId);
 }
 else
 TC_LOG_DEBUG("maps", "Map::CanPlayerEnter - player '{}' is dead but does not have a corpse!", player->GetName());
 }
 
 if (TransferAbortParams denyReason = Map::PlayerCannotEnter(at->target_mapId, player))
 {
 switch (denyReason.Reason)
 {
 case TRANSFER_ABORT_MAP_NOT_ALLOWED:
 TC_LOG_DEBUG("maps", "MAP: Player '{}' attempted to enter map with id {} which has no entry", player->GetName(), at->target_mapId);
 break;
 case TRANSFER_ABORT_DIFFICULTY:
 TC_LOG_DEBUG("maps", "MAP: Player '{}' attempted to enter instance map {} but the requested difficulty was not found", player->GetName(), at->target_mapId);
 break;
 case TRANSFER_ABORT_NEED_GROUP:
 TC_LOG_DEBUG("maps", "MAP: Player '{}' must be in a raid group to enter map {}", player->GetName(), at->target_mapId);
 player->SendRaidGroupOnlyMessage(RAID_GROUP_ERR_ONLY, 0);
 break;
 case TRANSFER_ABORT_LOCKED_TO_DIFFERENT_INSTANCE:
 TC_LOG_DEBUG("maps", "MAP: Player '{}' cannot enter instance map {} because their permanent bind is incompatible with their group's", player->GetName(), at->target_mapId);
 break;
 case TRANSFER_ABORT_ALREADY_COMPLETED_ENCOUNTER:
 TC_LOG_DEBUG("maps", "MAP: Player '{}' cannot enter instance map {} because their permanent bind is incompatible with their group's", player->GetName(), at->target_mapId);
 break;
 case TRANSFER_ABORT_TOO_MANY_INSTANCES:
 TC_LOG_DEBUG("maps", "MAP: Player '{}' cannot enter instance map {} because he has exceeded the maximum number of instances per hour.", player->GetName(), at->target_mapId);
 break;
 case TRANSFER_ABORT_MAX_PLAYERS:
 break;
 case TRANSFER_ABORT_ZONE_IN_COMBAT:
 break;
 case TRANSFER_ABORT_NOT_FOUND:
 TC_LOG_DEBUG("maps", "MAP: Player '{}' cannot enter instance map {} because instance is resetting.", player->GetName(), at->target_mapId);
 break;
 default:
 break;
 }
 
 if (denyReason.Reason != TRANSFER_ABORT_NEED_GROUP)
 player->SendTransferAborted(at->target_mapId, denyReason.Reason, denyReason.Arg, denyReason.MapDifficultyXConditionId);
 
 if (!player->IsAlive() && player->HasCorpse())
 {
 if (player->GetCorpseLocation().GetMapId() == at->target_mapId)
 {
 player->ResurrectPlayer(0.5f);
 player->SpawnCorpseBones();
 }
 }
 
 return;
 }
 
 if (Group* group = player->GetGroup())
 if (group->isLFGGroup() && player->GetMap()->IsDungeon())
 teleported = player->TeleportToBGEntryPoint();
 }
 
 if (!teleported)
 {
 WorldSafeLocsEntry const* entranceLocation = nullptr;
 MapEntry const* mapEntry = sMapStore.AssertEntry(at->target_mapId);
 if (mapEntry->Instanceable())
 {
 // Check if we can contact the instancescript of the instance for an updated entrance location
 if (uint32 targetInstanceId = sMapMgr->FindInstanceIdForPlayer(at->target_mapId, _player))
 if (Map* map = sMapMgr->FindMap(at->target_mapId, targetInstanceId))
 if (InstanceMap* instanceMap = map->ToInstanceMap())
 if (InstanceScript* instanceScript = instanceMap->GetInstanceScript())
 entranceLocation = sObjectMgr->GetWorldSafeLoc(instanceScript->GetEntranceLocation());
 
 // Finally check with the instancesave for an entrance location if we did not get a valid one from the instancescript
 if (!entranceLocation)
 {
 Group* group = player->GetGroup();
 Difficulty difficulty = group ? group->GetDifficultyID(mapEntry) : player->GetDifficultyID(mapEntry);
 ObjectGuid instanceOwnerGuid = group ? group->GetRecentInstanceOwner(at->target_mapId) : player->GetGUID();
 if (InstanceLock const* instanceLock = sInstanceLockMgr.FindActiveInstanceLock(instanceOwnerGuid, { mapEntry, sDB2Manager.GetDownscaledMapDifficultyData(at->target_mapId, difficulty) }))
 entranceLocation = sObjectMgr->GetWorldSafeLoc(instanceLock->GetData()->EntranceWorldSafeLocId);
 }
 }
 
 if (entranceLocation)
 player->TeleportTo(entranceLocation->Loc, TELE_TO_NOT_LEAVE_TRANSPORT);
 else
 player->TeleportTo(at->target_mapId, at->target_X, at->target_Y, at->target_Z, at->target_Orientation, TELE_TO_NOT_LEAVE_TRANSPORT);
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HandleArtifactAddPower()

void WorldSession::HandleArtifactAddPower ( WorldPackets::Artifact::ArtifactAddPower & artifactAddPower )

{
 if (!_player->GetGameObjectIfCanInteractWith(artifactAddPower.ForgeGUID, GAMEOBJECT_TYPE_ITEM_FORGE))
 return;
 
 Item* artifact = _player->GetItemByGuid(artifactAddPower.ArtifactGUID);
 if (!artifact || artifact->IsArtifactDisabled())
 return;
 
 uint32 currentArtifactTier = artifact->GetModifier(ITEM_MODIFIER_ARTIFACT_TIER);
 
 uint64 xpCost = 0;
 if (GtArtifactLevelXPEntry const* cost = sArtifactLevelXPGameTable.GetRow(artifact->GetTotalPurchasedArtifactPowers() + 1))
 xpCost = uint64(currentArtifactTier == MAX_ARTIFACT_TIER ? cost->XP2 : cost->XP);
 
 if (xpCost > artifact->m_itemData->ArtifactXP)
 return;
 
 if (artifactAddPower.PowerChoices.empty())
 return;
 
 UF::ArtifactPower const* artifactPower = artifact->GetArtifactPower(artifactAddPower.PowerChoices[0].ArtifactPowerID);
 if (!artifactPower)
 return;
 
 ArtifactPowerEntry const* artifactPowerEntry = sArtifactPowerStore.LookupEntry(artifactPower->ArtifactPowerID);
 if (!artifactPowerEntry)
 return;
 
 if (artifactPowerEntry->Tier > currentArtifactTier)
 return;
 
 uint32 maxRank = artifactPowerEntry->MaxPurchasableRank;
 if (artifactPowerEntry->Tier < currentArtifactTier)
 {
 if (artifactPowerEntry->Flags & ARTIFACT_POWER_FLAG_FINAL)
 maxRank = 1;
 else if (artifactPowerEntry->Flags & ARTIFACT_POWER_FLAG_MAX_RANK_WITH_TIER)
 maxRank += currentArtifactTier - artifactPowerEntry->Tier;
 }
 
 if (artifactAddPower.PowerChoices[0].Rank != artifactPower->PurchasedRank + 1 ||
 artifactAddPower.PowerChoices[0].Rank > maxRank)
 return;
 
 if (!(artifactPowerEntry->Flags & ARTIFACT_POWER_FLAG_NO_LINK_REQUIRED))
 {
 if (std::vector<uint32> const* artifactPowerLinks = sDB2Manager.GetArtifactPowerLinks(artifactPower->ArtifactPowerID))
 {
 bool hasAnyLink = false;
 for (uint32 artifactPowerLinkId : *artifactPowerLinks)
 {
 ArtifactPowerEntry const* artifactPowerLink = sArtifactPowerStore.LookupEntry(artifactPowerLinkId);
 if (!artifactPowerLink)
 continue;
 
 UF::ArtifactPower const* artifactPowerLinkLearned = artifact->GetArtifactPower(artifactPowerLinkId);
 if (!artifactPowerLinkLearned)
 continue;
 
 if (artifactPowerLinkLearned->PurchasedRank >= artifactPowerLink->MaxPurchasableRank)
 {
 hasAnyLink = true;
 break;
 }
 }
 
 if (!hasAnyLink)
 return;
 }
 }
 
 ArtifactPowerRankEntry const* artifactPowerRank = sDB2Manager.GetArtifactPowerRank(artifactPower->ArtifactPowerID, artifactPower->CurrentRankWithBonus + 1 - 1); // need data for next rank, but -1 because of how db2 data is structured
 if (!artifactPowerRank)
 return;
 
 artifact->SetArtifactPower(artifactPower->ArtifactPowerID, artifactPower->PurchasedRank + 1, artifactPower->CurrentRankWithBonus + 1);
 
 if (artifact->IsEquipped())
 {
 _player->ApplyArtifactPowerRank(artifact, artifactPowerRank, true);
 
 for (UF::ArtifactPower const& power : artifact->m_itemData->ArtifactPowers)
 {
 ArtifactPowerEntry const* scaledArtifactPowerEntry = sArtifactPowerStore.AssertEntry(power.ArtifactPowerID);
 if (!(scaledArtifactPowerEntry->Flags & ARTIFACT_POWER_FLAG_SCALES_WITH_NUM_POWERS))
 continue;
 
 ArtifactPowerRankEntry const* scaledArtifactPowerRank = sDB2Manager.GetArtifactPowerRank(scaledArtifactPowerEntry->ID, 0);
 if (!scaledArtifactPowerRank)
 continue;
 
 artifact->SetArtifactPower(power.ArtifactPowerID, power.PurchasedRank, power.CurrentRankWithBonus + 1);
 
 _player->ApplyArtifactPowerRank(artifact, scaledArtifactPowerRank, false);
 _player->ApplyArtifactPowerRank(artifact, scaledArtifactPowerRank, true);
 }
 }
 
 artifact->SetArtifactXP(artifact->m_itemData->ArtifactXP - xpCost);
 artifact->SetState(ITEM_CHANGED, _player);
 
 uint32 totalPurchasedArtifactPower = artifact->GetTotalPurchasedArtifactPowers();
 uint32 artifactTier = 0;
 
 for (ArtifactTierEntry const* tier : sArtifactTierStore)
 {
 if (artifactPowerEntry->Flags & ARTIFACT_POWER_FLAG_FINAL && artifactPowerEntry->Tier < MAX_ARTIFACT_TIER)
 {
 artifactTier = artifactPowerEntry->Tier + 1;
 break;
 }
 
 if (totalPurchasedArtifactPower < tier->MaxNumTraits)
 {
 artifactTier = tier->ArtifactTier;
 break;
 }
 }
 
 artifactTier = std::max(artifactTier, currentArtifactTier);
 
 for (uint32 i = currentArtifactTier; i <= artifactTier; ++i)
 artifact->InitArtifactPowers(artifact->GetTemplate()->GetArtifactID(), uint8(i));
 
 artifact->SetModifier(ITEM_MODIFIER_ARTIFACT_TIER, artifactTier);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HandleArtifactSetAppearance()

void WorldSession::HandleArtifactSetAppearance ( WorldPackets::Artifact::ArtifactSetAppearance & artifactSetAppearance )

{
 if (!_player->GetGameObjectIfCanInteractWith(artifactSetAppearance.ForgeGUID, GAMEOBJECT_TYPE_ITEM_FORGE))
 return;
 
 ArtifactAppearanceEntry const* artifactAppearance = sArtifactAppearanceStore.LookupEntry(artifactSetAppearance.ArtifactAppearanceID);
 if (!artifactAppearance)
 return;
 
 Item* artifact = _player->GetItemByGuid(artifactSetAppearance.ArtifactGUID);
 if (!artifact)
 return;
 
 ArtifactAppearanceSetEntry const* artifactAppearanceSet = sArtifactAppearanceSetStore.LookupEntry(artifactAppearance->ArtifactAppearanceSetID);
 if (!artifactAppearanceSet || artifactAppearanceSet->ArtifactID != artifact->GetTemplate()->GetArtifactID())
 return;
 
 if (PlayerConditionEntry const* playerCondition = sPlayerConditionStore.LookupEntry(artifactAppearance->UnlockPlayerConditionID))
 if (!sConditionMgr->IsPlayerMeetingCondition(_player, playerCondition))
 return;
 
 artifact->SetAppearanceModId(artifactAppearance->ItemAppearanceModifierID);
 artifact->SetModifier(ITEM_MODIFIER_ARTIFACT_APPEARANCE_ID, artifactAppearance->ID);
 artifact->SetState(ITEM_CHANGED, _player);
 Item* childItem = _player->GetChildItemByGuid(artifact->GetChildItem());
 if (childItem)
 {
 childItem->SetAppearanceModId(artifactAppearance->ItemAppearanceModifierID);
 childItem->SetState(ITEM_CHANGED, _player);
 }
 
 if (artifact->IsEquipped())
 {
 // change weapon appearance
 _player->SetVisibleItemSlot(artifact->GetSlot(), artifact);
 if (childItem)
 _player->SetVisibleItemSlot(childItem->GetSlot(), childItem);
 
 // change druid form appearance
 if (artifactAppearance->OverrideShapeshiftDisplayID && artifactAppearance->OverrideShapeshiftFormID && _player->GetShapeshiftForm() == ShapeshiftForm(artifactAppearance->OverrideShapeshiftFormID))
 _player->RestoreDisplayId(_player->IsMounted());
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HandleAttackStopOpcode()

void WorldSession::HandleAttackStopOpcode ( WorldPackets::Combat::AttackStop & packet )

{
 GetPlayer()->AttackStop();
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HandleAttackSwingOpcode()

void WorldSession::HandleAttackSwingOpcode ( WorldPackets::Combat::AttackSwing & packet )

Client explicitly checks the following before sending CMSG_ATTACK_SWING packet, so we'll place the same check here. Note that it might be possible to reuse this snippet in other places as well.

{
 Unit* enemy = ObjectAccessor::GetUnit(*_player, packet.Victim);
 
 if (!enemy)
 {
 // stop attack state at client
 SendAttackStop(nullptr);
 return;
 }
 
 if (!_player->IsValidAttackTarget(enemy))
 {
 // stop attack state at client
 SendAttackStop(enemy);
 return;
 }
 
 if (Vehicle* vehicle = _player->GetVehicle())
 {
 VehicleSeatEntry const* seat = vehicle->GetSeatForPassenger(_player);
 ASSERT(seat);
 if (!(seat->Flags & VEHICLE_SEAT_FLAG_CAN_ATTACK))
 {
 SendAttackStop(enemy);
  return;
 }
 }
 
 _player->Attack(enemy, true);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HandleAuctionBrowseQuery()

void WorldSession::HandleAuctionBrowseQuery ( WorldPackets::AuctionHouse::AuctionBrowseQuery & browseQuery )

{
 AuctionThrottleResult throttle = sAuctionMgr->CheckThrottle(_player, browseQuery.TaintedBy.has_value());
 if (throttle.Throttled)
 return;
 
 Creature* creature = GetPlayer()->GetNPCIfCanInteractWith(browseQuery.Auctioneer, UNIT_NPC_FLAG_AUCTIONEER, UNIT_NPC_FLAG_2_NONE);
 if (!creature)
 {
 TC_LOG_DEBUG("network", "WORLD: HandleAuctionListItems - {} not found or you can't interact with him.", browseQuery.Auctioneer.ToString());
 return;
 }
 
 // remove fake death
 if (GetPlayer()->HasUnitState(UNIT_STATE_DIED))
 GetPlayer()->RemoveAurasByType(SPELL_AURA_FEIGN_DEATH);
 
 AuctionHouseObject* auctionHouse = sAuctionMgr->GetAuctionsMap(creature->GetFaction());
 
 TC_LOG_DEBUG("auctionHouse", "Auctionhouse search {}, searchedname: {}, levelmin: {}, levelmax: {}, filters: {}",
 browseQuery.Auctioneer.ToString(), browseQuery.Name, browseQuery.MinLevel, browseQuery.MaxLevel, AsUnderlyingType(browseQuery.Filters));
 
 std::wstring name;
 if (!Utf8toWStr(browseQuery.Name, name))
 return;
 
 Optional<AuctionSearchClassFilters> classFilters;
 
 WorldPackets::AuctionHouse::AuctionListBucketsResult listBucketsResult;
 if (!browseQuery.ItemClassFilters.empty())
 {
 classFilters.emplace();
 
 for (auto const& classFilter : browseQuery.ItemClassFilters)
 {
 if (!classFilter.SubClassFilters.empty())
 {
 for (auto const& subClassFilter : classFilter.SubClassFilters)
 {
 if (classFilter.ItemClass < MAX_ITEM_CLASS)
 {
 classFilters->Classes[classFilter.ItemClass].SubclassMask |= 1 << subClassFilter.ItemSubclass;
 if (subClassFilter.ItemSubclass < MAX_ITEM_SUBCLASS_TOTAL)
 classFilters->Classes[classFilter.ItemClass].InvTypes[subClassFilter.ItemSubclass] = subClassFilter.InvTypeMask;
 }
 }
 }
 else
 classFilters->Classes[classFilter.ItemClass].SubclassMask = AuctionSearchClassFilters::FILTER_SKIP_SUBCLASS;
 }
 }
 
 auctionHouse->BuildListBuckets(listBucketsResult, _player,
 name, browseQuery.MinLevel, browseQuery.MaxLevel, browseQuery.Filters, classFilters,
 browseQuery.KnownPets.data(), browseQuery.KnownPets.size(), browseQuery.MaxPetLevel,
 browseQuery.Offset, browseQuery.Sorts.data(), browseQuery.Sorts.size());
 
 listBucketsResult.BrowseMode = AuctionHouseBrowseMode::Search;
 listBucketsResult.DesiredDelay = uint32(throttle.DelayUntilNext.count());
 SendPacket(listBucketsResult.Write());
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HandleAuctionCancelCommoditiesPurchase()

void WorldSession::HandleAuctionCancelCommoditiesPurchase ( WorldPackets::AuctionHouse::AuctionCancelCommoditiesPurchase & cancelCommoditiesPurchase )

{
 AuctionThrottleResult throttle = sAuctionMgr->CheckThrottle(_player, cancelCommoditiesPurchase.TaintedBy.has_value(), AuctionCommand::PlaceBid);
 if (throttle.Throttled)
 return;
 
 Creature* creature = GetPlayer()->GetNPCIfCanInteractWith(cancelCommoditiesPurchase.Auctioneer, UNIT_NPC_FLAG_AUCTIONEER, UNIT_NPC_FLAG_2_NONE);
 if (!creature)
 {
 TC_LOG_DEBUG("network", "WORLD: HandleAuctionCancelCommoditiesPurchase - {} not found or you can't interact with him.",
 cancelCommoditiesPurchase.Auctioneer.ToString());
 return;
 }
 
 // remove fake death
 if (GetPlayer()->HasUnitState(UNIT_STATE_DIED))
 GetPlayer()->RemoveAurasByType(SPELL_AURA_FEIGN_DEATH);
 
 AuctionHouseObject* auctionHouse = sAuctionMgr->GetAuctionsMap(creature->GetFaction());
 auctionHouse->CancelCommodityQuote(_player->GetGUID());
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HandleAuctionConfirmCommoditiesPurchase()

void WorldSession::HandleAuctionConfirmCommoditiesPurchase ( WorldPackets::AuctionHouse::AuctionConfirmCommoditiesPurchase & confirmCommoditiesPurchase )

{
 AuctionThrottleResult throttle = sAuctionMgr->CheckThrottle(_player, confirmCommoditiesPurchase.TaintedBy.has_value(), AuctionCommand::PlaceBid);
 if (throttle.Throttled)
 return;
 
 Creature* creature = GetPlayer()->GetNPCIfCanInteractWith(confirmCommoditiesPurchase.Auctioneer, UNIT_NPC_FLAG_AUCTIONEER, UNIT_NPC_FLAG_2_NONE);
 if (!creature)
 {
 TC_LOG_DEBUG("network", "WORLD: HandleAuctionConfirmCommoditiesPurchase - {} not found or you can't interact with him.", confirmCommoditiesPurchase.Auctioneer.ToString());
 return;
 }
 
 // remove fake death
 if (GetPlayer()->HasUnitState(UNIT_STATE_DIED))
 GetPlayer()->RemoveAurasByType(SPELL_AURA_FEIGN_DEATH);
 
 AuctionHouseObject* auctionHouse = sAuctionMgr->GetAuctionsMap(creature->GetFaction());
 
 CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
 if (auctionHouse->BuyCommodity(trans, _player, confirmCommoditiesPurchase.ItemID, confirmCommoditiesPurchase.Quantity, throttle.DelayUntilNext))
 {
 AddTransactionCallback(CharacterDatabase.AsyncCommitTransaction(trans)).AfterComplete([this, buyerGuid = _player->GetGUID(), throttle](bool success)
 {
 if (GetPlayer() && GetPlayer()->GetGUID() == buyerGuid)
 {
 if (success)
 {
 GetPlayer()->UpdateCriteria(CriteriaType::AuctionsWon, 1);
 SendAuctionCommandResult(0, AuctionCommand::PlaceBid, AuctionResult::Ok, throttle.DelayUntilNext);
 }
 else
 SendAuctionCommandResult(0, AuctionCommand::PlaceBid, AuctionResult::CommodityPurchaseFailed, throttle.DelayUntilNext);
 }
 });
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HandleAuctionGetCommodityQuote()

void WorldSession::HandleAuctionGetCommodityQuote ( WorldPackets::AuctionHouse::AuctionGetCommodityQuote & startCommoditiesPurchase )

{
 AuctionThrottleResult throttle = sAuctionMgr->CheckThrottle(_player, getCommodityQuote.TaintedBy.has_value(), AuctionCommand::PlaceBid);

Classes

Public Member Functions

Public Attributes

Protected Attributes

Private Member Functions

Private Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

◆ WorldSession() [1/2]

◆ ~WorldSession()

◆ WorldSession() [2/2]

Member Function Documentation

◆ AbortLogin()

◆ AddInstanceConnection()

◆ AddQueryHolderCallback()

◆ AddTransactionCallback()

◆ AdjustClientMovementTime()

◆ BuildNameQueryData()

◆ CanAccessAlliedRaces()

◆ CanOpenMailBox()

◆ CanSpeak()

◆ CanUseBank()

◆ CheckStableMaster()

◆ ComputeNewClockDelta()

◆ DisallowHyperlinksAndMaybeKick()

◆ DoLootRelease()

◆ DoLootReleaseAll()

◆ GetAccountData()

◆ GetAccountExpansion()

◆ GetAccountGUID()

◆ GetAccountId()

◆ GetAccountName()

◆ GetBattlenetAccountGUID()

◆ GetBattlenetAccountId()

◆ GetBattlePetMgr()

◆ GetCalendarEventCreationCooldown()

◆ GetCollectionMgr()

◆ GetConnectToInstanceKey()

◆ GetExpansion()

◆ GetLatency()

◆ GetOS()

◆ GetPlayer()

◆ GetPlayerInfo()

◆ GetPlayerName()

◆ GetQueryProcessor()

◆ GetRBACData()

◆ GetRealmCharacterCounts()

◆ GetRealmListSecret()

◆ GetRecruiterId()

◆ GetRemoteAddress()

◆ GetSecurity()

◆ GetSessionDbcLocale()

◆ GetSessionDbLocaleIndex()

◆ GetTrinityString()

◆ GetTutorialInt()

◆ GetWarden() [1/2]

◆ GetWarden() [2/2]

◆ Handle_EarlyProccess()

◆ Handle_NULL()

◆ HandleAcceptTradeOpcode()

◆ HandleActivateTaxiOpcode()

◆ HandleAddFriendOpcode()

◆ HandleAddIgnoreOpcode()

◆ HandleAddonRegisteredPrefixesOpcode()

◆ HandleAddToy()

◆ HandleAdventureJournalOpenQuest()

◆ HandleAdventureJournalUpdateSuggestions()

◆ HandleAdventureMapStartQuest()

◆ HandleAlterAppearance()

◆ HandleAreaSpiritHealerQueryOpcode()

◆ HandleAreaSpiritHealerQueueOpcode()

◆ HandleAreaTriggerOpcode()

◆ HandleArtifactAddPower()

◆ HandleArtifactSetAppearance()

◆ HandleAttackStopOpcode()

◆ HandleAttackSwingOpcode()

◆ HandleAuctionBrowseQuery()

◆ HandleAuctionCancelCommoditiesPurchase()

◆ HandleAuctionConfirmCommoditiesPurchase()