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

void	ReadAddonsInfo (ByteBuffer &data)

void	SendAddonsInfo ()

bool	IsAddonRegistered (const std::string &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, DeclinedName *declinedName)

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

void	SendSetPhaseShift (std::set< uint32 > const &phaseIds, std::set< uint32 > const &terrainswaps, std::set< uint32 > const &worldMapAreaSwaps)

void	SendQueryTimeResponse ()

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

void	SendClientCacheVersion (uint32 version)

void	InitializeSession ()

void	InitializeSessionCallback (SQLQueryHolder realmHolder, SQLQueryHolder holder)

rbac::RBACData *	GetRBACData ()

bool	HasPermission (uint32 permissionId)

void	LoadPermissions ()

PreparedQueryResultFuture	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	GetExpansion () const

std::string const &	GetOS () const

void	InitWarden (BigNumber *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 ()
	Kick a player out of the World. More...

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	SendAuthWaitQue (uint32 position)
	Handle the authentication waiting queue (to be completed) More...

void	SendSetTimeZoneInformation ()

void	SendFeatureSystemStatus ()

void	SendFeatureSystemStatusGlueScreen ()

void	SendNameQueryOpcode (ObjectGuid guid)

void	SendTrainerList (ObjectGuid guid)

void	SendTrainerList (ObjectGuid guid, std::string const &strTitle)

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	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	SendStablePetCallback (PreparedQueryResult result, ObjectGuid guid)

void	SendPetStableResult (uint8 guid)

bool	CheckStableMaster (ObjectGuid guid)

AccountData const *	GetAccountData (AccountDataType type) const

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

void	LoadAccountData (PreparedQueryResult result, uint32 mask)

void	LoadTutorialsData (PreparedQueryResult result)

void	SendTutorialsData ()

void	SaveTutorialsData (SQLTransaction &trans)

uint32	GetTutorialInt (uint8 index) const

void	SetTutorialInt (uint8 index, uint32 value)

bool	SendItemInfo (uint32 itemid, WorldPacket data)

void	SendAuctionHello (ObjectGuid guid, Creature *unit)

void	SendAuctionCommandResult (AuctionEntry *auction, uint32 Action, uint32 ErrorCode, uint32 bidError=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	SendAuctionOutBidNotification (AuctionEntry const auction, Item const item)

void	SendAuctionClosedNotification (AuctionEntry const auction, float mailDelay, bool sold, Item const item)

void	SendAuctionWonNotification (AuctionEntry const auction, Item const item)

void	SendAuctionOwnerBidNotification (AuctionEntry const auction, Item const item)

void	SendBlackMarketOpenResult (ObjectGuid guid, Creature *auctioneer)

void	SendEnchantmentLog (ObjectGuid target, ObjectGuid caster, uint32 itemId, uint32 enchantId)

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	SendNotInArenaTeamPacket (uint8 type)

void	SendPetitionShowList (ObjectGuid guid)

void	DoLootRelease (ObjectGuid lguid)

LocaleConstant	GetSessionDbcLocale () const

LocaleConstant	GetSessionDbLocaleIndex () const

char const *	GetTrinityString (uint32 entry) const

uint32	GetLatency () const

void	SetLatency (uint32 latency)

void	ResetClientTimeDelay ()

void	UpdateTimeOutTime (uint32 diff)

void	ResetTimeOutTime ()

bool	IsConnectionIdle () const

uint32	GetRecruiterId () const

bool	IsARecruiter () const

BattlePetMgr *	GetBattlePetMgr () const

CollectionMgr *	GetCollectionMgr () const

void	Handle_NULL (WorldPackets::Null &null)

void	Handle_EarlyProccess (WorldPacket &recvPacket)

void	HandleCharEnum (PreparedQueryResult result)

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

void	HandleCharUndeleteEnum (PreparedQueryResult result)

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

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

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

void	HandleCharCreateCallback (PreparedQueryResult result, WorldPackets::Character::CharacterCreateInfo *createInfo)

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 *holder)

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

void	HandleCharRenameCallBack (PreparedQueryResult result, WorldPackets::Character::CharacterRenameInfo *renameInfo)

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

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

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

void	HandleCharCustomizeCallback (PreparedQueryResult result, WorldPackets::Character::CharCustomizeInfo *customizeInfo)

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

void	HandleCharRaceOrFactionChangeCallback (PreparedQueryResult result, WorldPackets::Character::CharRaceOrFactionChangeInfo *factionChangeInfo)

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)

void	HandleCharUndeleteCallback (PreparedQueryResult result, WorldPackets::Character::CharacterUndeleteInfo *undeleteInfo)

void	SendCharCreate (ResponseCodes result)

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	SendBarberShopResult (BarberShopResult result)

void	SendUndeleteCooldownStatusResponse (uint32 currentCooldown, uint32 maxCooldown)

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

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

void	HandleLookingForGroup (WorldPacket &recvPacket)

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

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

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

void	HandleRequestHonorStatsOpcode (WorldPackets::Inspect::RequestHonorStats &request)

void	HandleInspectPVP (WorldPackets::Inspect::InspectPVPRequest &request)

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

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

void	HandleShowingHelmOpcode (WorldPackets::Character::ShowingHelm &packet)

void	HandleShowingCloakOpcode (WorldPackets::Character::ShowingCloak &packet)

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

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

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

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

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

void	HandlePingOpcode (WorldPacket &recvPacket)

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 (WorldPacket &recvPacket)

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	HandleSupportTicketSubmitBug (WorldPackets::Ticket::SupportTicketSubmitBug &packet)

void	HandleSupportTicketSubmitSuggestion (WorldPackets::Ticket::SupportTicketSubmitSuggestion &packet)

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	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	HandleAddFriendOpcodeCallBack (PreparedQueryResult result, std::string const &friendNote)

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

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

void	HandleAddIgnoreOpcodeCallBack (PreparedQueryResult result)

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

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

void	HandleAreaTriggerOpcode (WorldPackets::Misc::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	HandleMeetingStoneInfo (WorldPacket &recPacket)

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

void	HandleNameQueryOpcode (WorldPackets::Query::QueryPlayerName &packet)

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

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

void	HandleDBQueryBulk (WorldPackets::Query::DBQueryBulk &packet)

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

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

void	HandleMoveWorldportAckOpcode ()

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

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	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	HandleDeclinePetition (WorldPackets::Petition::DeclinePetition &packet)

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

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

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

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

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

void	HandleSignPetition (WorldPackets::Petition::SignPetition &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	HandleGuildSetAchievementTracking (WorldPackets::Guild::GuildSetAchievementTracking &packet)

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	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	HandleGuildFinderAddRecruit (WorldPackets::GuildFinder::LFGuildAddRecruit &lfGuildAddRecruit)

void	HandleGuildFinderBrowse (WorldPackets::GuildFinder::LFGuildBrowse &lfGuildBrowse)

void	HandleGuildFinderDeclineRecruit (WorldPackets::GuildFinder::LFGuildDeclineRecruit &lfGuildDeclineRecruit)

void	HandleGuildFinderGetApplications (WorldPackets::GuildFinder::LFGuildGetApplications &lfGuildGetApplications)

void	HandleGuildFinderGetGuildPost (WorldPackets::GuildFinder::LFGuildGetGuildPost &lfGuildGetGuildPost)

void	HandleGuildFinderGetRecruits (WorldPackets::GuildFinder::LFGuildGetRecruits &lfGuildGetRecruits)

void	HandleGuildFinderRemoveRecruit (WorldPackets::GuildFinder::LFGuildRemoveRecruit &lfGuildRemoveRecruit)

void	HandleGuildFinderSetGuildPost (WorldPackets::GuildFinder::LFGuildSetGuildPost &lfGuildSetGuildPost)

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	HandleStablePet (WorldPacket &recvPacket)

void	HandleStablePetCallback (PreparedQueryResult result)

void	HandleUnstablePet (WorldPacket &recvPacket)

void	HandleUnstablePetCallback (PreparedQueryResult result, uint32 petId)

void	HandleBuyStableSlot (WorldPacket &recvPacket)

void	HandleStableRevivePet (WorldPacket &recvPacket)

void	HandleStableSwapPet (WorldPacket &recvPacket)

void	HandleStableSwapPetCallback (PreparedQueryResult result, uint32 petId)

void	SendTrainerBuyFailed (ObjectGuid trainerGUID, uint32 spellID, int32 trainerFailedReason)

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

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

void	HandleDuelAccepted ()

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	HandleAuctionHelloOpcode (WorldPackets::AuctionHouse::AuctionHelloRequest &packet)

void	HandleAuctionListItems (WorldPackets::AuctionHouse::AuctionListItems &packet)

void	HandleAuctionListBidderItems (WorldPackets::AuctionHouse::AuctionListBidderItems &packet)

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

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

void	HandleAuctionListOwnerItems (WorldPackets::AuctionHouse::AuctionListOwnerItems &packet)

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

void	HandleAuctionListPendingSales (WorldPackets::AuctionHouse::AuctionListPendingSales &packet)

void	HandleReplicateItems (WorldPackets::AuctionHouse::AuctionReplicateItems &packet)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void	SendItemPageInfo (ItemTemplate *itemProto)

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	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	HandleCancelAutoRepeatSpellOpcode (WorldPackets::Spells::CancelAutoRepeatSpell &cancelAutoRepeatSpell)

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

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

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

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

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

void	HandleSetSpecializationOpcode (WorldPackets::Talent::SetSpecialization &packet)

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

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

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	HandleQuestgiverCancel (WorldPacket &recvData)

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

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

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

void	HandleQuestgiverQuestAutoLaunch (WorldPacket &recvPacket)

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

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

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

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

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

void	HandleChatMessage (ChatMsg type, uint32 lang, std::string msg, std::string target="")

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

void	HandleChatAddonMessageWhisperOpcode (WorldPackets::Chat::ChatAddonMessageWhisper &chatAddonMessageWhisper)

void	HandleChatAddonMessageChannelOpcode (WorldPackets::Chat::ChatAddonMessageChannel &chatAddonMessageChannel)

void	HandleChatAddonMessage (ChatMsg type, std::string prefix, std::string text, std::string target="")

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)

template<void(Channel::)(Player const ) CommandFunction>
void	HandleChannelCommand (WorldPackets::Channel::ChannelPlayerCommand &packet)

template<void(Channel::)(Player const , std::string const &) CommandFunction>
void	HandleChannelPlayerCommand (WorldPackets::Channel::ChannelPlayerCommand &packet)

void	HandleVoiceSessionEnable (WorldPackets::Voice::VoiceSessionEnable &packet)

void	HandleSetActiveVoiceChannel (WorldPackets::Voice::SetActiveVoiceChannel &packet)

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

void	HandleNextCinematicCamera (WorldPackets::Misc::NextCinematicCamera &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, float x, float y, float z)

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	HandleRequestRatedBattlefieldInfo (WorldPackets::Battleground::RequestRatedBattlefieldInfo &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	SendBfInvitePlayerToWar (uint64 queueId, uint32 zoneId, uint32 acceptTime)
	This send to player windows for invite player to join the war. More...

void	SendBfInvitePlayerToQueue (uint64 queueId, int8 battleState)
	This send invitation to player to join the queue. More...

void	SendBfQueueInviteResponse (uint64 queueId, uint32 zoneId, int8 battleStatus, bool canQueue=true, bool loggingIn=false)
	This send packet for inform player that he join queue. More...

void	SendBfEntered (uint64 queueId, bool relocated, bool onOffense)
	This is call when player accept to join war. More...

void	SendBfLeaveMessage (uint64 queueId, int8 battleState, bool relocated, BFLeaveReason reason=BF_LEAVE_REASON_EXITED)
	This is call when player leave battlefield zone. More...

void	HandleBfEntryInviteResponse (WorldPackets::Battlefield::BFMgrEntryInviteResponse &bfMgrEntryInviteResponse)
	Send by client on clicking in accept or refuse of invitation windows for join game. More...

void	HandleBfQueueInviteResponse (WorldPackets::Battlefield::BFMgrQueueInviteResponse &bfMgrQueueInviteResponse)
	Send by client when he click on accept for queue. More...

void	HandleBfQueueExitRequest (WorldPackets::Battlefield::BFMgrQueueExitRequest &bfMgrQueueExitRequest)

void	HandleWorldTeleportOpcode (WorldPackets::Misc::WorldTeleport &worldTeleport)

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 &packet)

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

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

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

void	HandleLfgSetCommentOpcode (WorldPacket &recvData)

void	HandleDFGetSystemInfo (WorldPacket &recvData)

void	SendLfgPlayerLockInfo ()

void	SendLfgPartyLockInfo ()

void	HandleLfgJoinOpcode (WorldPacket &recvData)

void	HandleLfgLeaveOpcode (WorldPacket &recvData)

void	HandleLfgSetRolesOpcode (WorldPacket &recvData)

void	HandleLfgProposalResultOpcode (WorldPacket &recvData)

void	HandleLfgSetBootVoteOpcode (WorldPacket &recvData)

void	HandleLfgTeleportOpcode (WorldPacket &recvData)

void	HandleLfrJoinOpcode (WorldPacket &recvData)

void	HandleLfrLeaveOpcode (WorldPacket &recvData)

void	HandleDFGetJoinStatus (WorldPacket &recvData)

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

void	SendLfgRoleChosen (ObjectGuid guid, uint8 roles)

void	SendLfgRoleCheckUpdate (lfg::LfgRoleCheck const &pRoleCheck)

void	SendLfgLfrList (bool update)

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 (uint8 err)

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

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

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

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	HandleGuildBankSwapItems (WorldPackets::Guild::GuildBankSwapItems &packet)

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	HandleGrantLevel (WorldPackets::RaF::GrantLevel &grantLevel)

void	HandleAcceptGrantLevel (WorldPackets::RaF::AcceptLevelGrant &acceptLevelGrant)

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

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

void	HandleCalendarGuildFilter (WorldPackets::Calendar::CalendarGuildFilter &calendarGuildFilter)

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	HandleCalendarEventInvite (WorldPackets::Calendar::CalendarEventInvite &calendarEventInvite)

void	HandleCalendarEventRsvp (WorldPackets::Calendar::CalendarEventRSVP &calendarEventRSVP)

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

void	HandleCalendarEventStatus (WorldPackets::Calendar::CalendarEventStatus &calendarEventStatus)

void	HandleCalendarEventModeratorStatus (WorldPackets::Calendar::CalendarEventModeratorStatus &calendarEventModeratorStatus)

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

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

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

void	SendCalendarRaidLockout (InstanceSave const *save, bool add)

void	SendCalendarRaidLockoutUpdated (InstanceSave const *save)

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	HandleTransmogrifyItems (WorldPackets::Item::TransmogrifyItems &transmogrifyItems)

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

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

void	HandleRemoveGlyph (WorldPacket &recvData)

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	HandleUITimeRequest (WorldPackets::Misc::UITimeRequest &)

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	HandleAddToy (WorldPackets::Toy::AddToy &packet)

void	HandleToySetFavorite (WorldPackets::Toy::ToySetFavorite &packet)

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

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

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

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

void	HandleUpdateListedAuctionableTokens (WorldPackets::Token::UpdateListedAuctionableTokens &updateListedAuctionableTokens)

void	HandleRequestWowTokenMarketPrice (WorldPackets::Token::RequestWowTokenMarketPrice &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	HandleGarrisonGetBuildingLandmarks (WorldPackets::Garrison::GarrisonGetBuildingLandmarks &garrisonGetBuildingLandmarks)

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

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

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

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

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

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

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

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

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

void	HandleBattlenetRequestRealmListTicket (WorldPackets::Battlenet::RequestRealmListTicket &requestRealmListTicket)

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

uint64	GetConnectToInstanceKey () const

Public Attributes
time_t	m_muteTime

std::atomic< int32 >	m_timeOutTime

Protected Attributes
class WorldSession::DosProtection	AntiDOS

Private Types
typedef std::list< AddonInfo >	AddonsList

Private Member Functions
void	InitializeQueryCallbackParameters ()

void	ProcessQueryCallbacks ()

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

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

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

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

bool	IsLegitCharacterForAccount (ObjectGuid lowGUID)

	WorldSession (WorldSession const &right)=delete

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

Private Attributes
QueryResultHolderFuture	_realmAccountLoginCallback

QueryResultHolderFuture	_accountLoginCallback

PreparedQueryResultFuture	_addIgnoreCallback

PreparedQueryResultFuture	_stablePetCallback

QueryCallback < PreparedQueryResult, bool >	_charEnumCallback

QueryCallback < PreparedQueryResult, std::string >	_addFriendCallback

QueryCallback < PreparedQueryResult, uint32 >	_unstablePetCallback

QueryCallback < PreparedQueryResult, uint32 >	_stableSwapCallback

QueryCallback < PreparedQueryResult, ObjectGuid >	_sendStabledPetCallback

QueryCallback < PreparedQueryResult, std::shared_ptr < WorldPackets::Character::CharacterCreateInfo > , true >	_charCreateCallback

QueryCallback < PreparedQueryResult, std::shared_ptr < WorldPackets::Character::CharacterRenameInfo > >	_charRenameCallback

QueryCallback < PreparedQueryResult, std::shared_ptr < WorldPackets::Character::CharCustomizeInfo > >	_charCustomizeCallback

QueryCallback < PreparedQueryResult, std::shared_ptr < WorldPackets::Character::CharRaceOrFactionChangeInfo > >	_charFactionChangeCallback

QueryCallback < PreparedQueryResult, bool, true >	_undeleteCooldownStatusCallback

QueryCallback < PreparedQueryResult, std::shared_ptr < WorldPackets::Character::CharacterUndeleteInfo > , true >	_charUndeleteCallback

QueryResultHolderFuture	_charLoginCallback

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_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

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

std::atomic< uint32 >	m_clientTimeDelay

AccountData	_accountData [NUM_ACCOUNT_DATA_TYPES]

uint32	_tutorials [MAX_ACCOUNT_TUTORIAL_VALUES]

bool	_tutorialsChanged

AddonsList	m_addonsList

std::vector< std::string >	_registeredAddonPrefixes

bool	_filterAddonMessages

uint32	recruiterId

bool	isRecruiter

LockedQueue< WorldPacket * >	_recvQueue

rbac::RBACData *	_RBACData

uint32	expireTime

bool	forceExit

ObjectGuid	m_currentBankerGUID

std::unique_ptr< BattlePetMgr >	_battlePetMgr

std::unique_ptr< CollectionMgr >	_collectionMgr

ConnectToKey	_instanceConnectKey

Friends
class	World

Detailed Description

Player session in the World.

Member Typedef Documentation

typedef std::list<AddonInfo> WorldSession::AddonsList

private

Constructor & Destructor Documentation

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(NULL),
     _security(sec),
     _accountId(id),
     _accountName(std::move(name)),
     _battlenetAccountId(battlenetAccountId),
     m_expansion(expansion),
     _os(os),
     _warden(NULL),
     _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),
     m_clientTimeDelay(0),
     _tutorialsChanged(false),
     _filterAddonMessages(false),
     recruiterId(recruiter),
     isRecruiter(isARecruiter),
     _RBACData(NULL),
     expireTime(60000), // 1 min after socket loss, session is deleted
     forceExit(false),
     m_currentBankerGUID(),
     _battlePetMgr(Trinity::make_unique<BattlePetMgr>(this)),
     _collectionMgr(Trinity::make_unique<CollectionMgr>(this))
 {
     memset(_tutorials, 0, sizeof(_tutorials));
 
     if (sock)
     {
         m_Address = sock->GetRemoteIpAddress().to_string();
         ResetTimeOutTime();
         LoginDatabase.PExecute("UPDATE account SET online = 1 WHERE id = %u;", GetAccountId());     // One-time query
     }
 
     m_Socket[CONNECTION_TYPE_REALM] = sock;
     _instanceConnectKey.Raw = UI64LIT(0);
 
     InitializeQueryCallbackParameters();
 }

Here is the call graph for this function:

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 _warden;
     delete _RBACData;
 
     WorldPacket* packet = NULL;
     while (_recvQueue.next(packet))
         delete packet;
 
     LoginDatabase.PExecute("UPDATE account SET online = 0 WHERE id = %u;", GetAccountId());     // One-time query
 }

Here is the call graph for this function:

WorldSession::WorldSession ( WorldSession const & right )

privatedelete

Member Function Documentation

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

 {
     if (!PlayerLoading() || GetPlayer())
     {
         KickPlayer();
         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:

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

inline

900 { m_Socket[CONNECTION_TYPE_INSTANCE] = sock; }

WorldSession::m_Socket

std::shared_ptr< WorldSocket > m_Socket[MAX_CONNECTION_TYPES]

Definition: WorldSession.h:1798

CONNECTION_TYPE_INSTANCE

Definition: Opcodes.h:32

Here is the caller graph for this function:

bool WorldSession::CanOpenMailBox ( ObjectGuid guid )

 {
     if (guid == _player->GetGUID())
     {
         if (!HasPermission(rbac::RBAC_PERM_COMMAND_MAILBOX))
         {
             TC_LOG_WARN("cheat", "%s attempt open mailbox in cheating way.", _player->GetName().c_str());
             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))
             return false;
     }
     else
         return false;
 
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

private

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

Here is the call graph for this function:

Here is the caller graph for this function:

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("network", "%s attempt open stable in cheating way.", guid.ToString().c_str());
             return false;
         }
     }
     // stable master case
     else
     {
         if (!GetPlayer()->GetNPCIfCanInteractWith(guid, UNIT_NPC_FLAG_STABLEMASTER))
         {
             TC_LOG_DEBUG("network", "Stablemaster %s not found or you can't interact with him.", guid.ToString().c_str());
             return false;
         }
     }
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::DoLootRelease ( ObjectGuid lguid )

 {
     Player  *player = GetPlayer();
     Loot    *loot;
 
     player->SetLootGUID(ObjectGuid::Empty);
     player->SendLootRelease(lguid);
 
     player->RemoveFlag(UNIT_FIELD_FLAGS, 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, INTERACTION_DISTANCE)))
             return;
 
         loot = &go->loot;
 
         if (go->GetGoType() == GAMEOBJECT_TYPE_DOOR)
         {
             // locked doors are opened with spelleffect openlock, prevent remove its as looted
             go->UseDoorOrButton();
         }
         else if (loot->isLooted() || go->GetGoType() == GAMEOBJECT_TYPE_FISHINGNODE)
         {
             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
                 go->SetLootState(GO_JUST_DEACTIVATED);
 
             loot->clear();
         }
         else
         {
             // not fully looted object
             go->SetLootState(GO_ACTIVATED, player);
 
             // if the round robin player release, reset it.
             if (player->GetGUID() == loot->roundRobinPlayer)
                 loot->roundRobinPlayer.Clear();
         }
     }
     else if (lguid.IsCorpse())        // ONLY remove insignia at BG
     {
         Corpse* corpse = ObjectAccessor::GetCorpse(*player, lguid);
         if (!corpse || !corpse->IsWithinDistInMap(_player, INTERACTION_DISTANCE))
             return;
 
         loot = &corpse->loot;
 
         if (loot->isLooted())
         {
             loot->clear();
             corpse->RemoveFlag(CORPSE_FIELD_DYNAMIC_FLAGS, 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 (proto->GetFlags() & (ITEM_FLAG_PROSPECTABLE | ITEM_FLAG_MILLABLE))
         {
             pItem->m_lootGenerated = false;
             pItem->loot.clear();
 
             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 (pItem->loot.isLooted() || !(proto->GetFlags() & ITEM_FLAG_OPENABLE))
                 player->DestroyItem(pItem->GetBagSlot(), pItem->GetSlot(), true);
         }
         return;                                             // item can be looted only single player
     }
     else
     {
         Creature* creature = GetPlayer()->GetMap()->GetCreature(lguid);
 
         bool lootAllowed = creature && creature->IsAlive() == (player->getClass() == CLASS_ROGUE && creature->loot.loot_type == LOOT_PICKPOCKETING);
         if (!lootAllowed || !creature->IsWithinDistInMap(_player, INTERACTION_DISTANCE))
             return;
 
         loot = &creature->loot;
         if (loot->isLooted())
         {
             creature->RemoveFlag(OBJECT_DYNAMIC_FLAGS, UNIT_DYNFLAG_LOOTABLE);
 
             // skip pickpocketing loot for speed, skinning timer reduction is no-op in fact
             if (!creature->IsAlive())
                 creature->AllLootRemovedFromCorpse();
 
             loot->clear();
         }
         else
         {
             // if the round robin player release, reset it.
             if (player->GetGUID() == loot->roundRobinPlayer)
             {
                 loot->roundRobinPlayer.Clear();
 
                 if (Group* group = player->GetGroup())
                 {
                     group->SendLooter(creature, NULL);
 
                     // force update of dynamic flags, otherwise other group's players still not able to loot.
                     creature->ForceValuesUpdateAtIndex(OBJECT_DYNAMIC_FLAGS);
                 }
             }
         }
     }
 
     //Player is not looking at loot list, he doesn't need to see updates on the loot list
     loot->RemoveLooter(player->GetGUID());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

inline

998 { return &_accountData[type]; }

WorldSession::_accountData

AccountData _accountData[NUM_ACCOUNT_DATA_TYPES]

Definition: WorldSession.h:1829

Here is the caller graph for this function:

ObjectGuid WorldSession::GetAccountGUID ( ) const

inline

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

WorldSession::GetAccountId

uint32 GetAccountId() const

Definition: WorldSession.h:922

Here is the caller graph for this function:

uint32 WorldSession::GetAccountId ( ) const

inline

922 { return _accountId; }

WorldSession::_accountId

uint32 _accountId

Definition: WorldSession.h:1803

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

inline

924 { return _accountName; }

WorldSession::_accountName

std::string _accountName

Definition: WorldSession.h:1804

ObjectGuid WorldSession::GetBattlenetAccountGUID ( ) const

inline

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

WorldSession::GetBattlenetAccountId

uint32 GetBattlenetAccountId() const

Definition: WorldSession.h:925

uint32 WorldSession::GetBattlenetAccountId ( ) const

inline

925 { return _battlenetAccountId; }

WorldSession::_battlenetAccountId

uint32 _battlenetAccountId

Definition: WorldSession.h:1805

Here is the caller graph for this function:

BattlePetMgr* WorldSession::GetBattlePetMgr ( ) const

inline

1089 { return _battlePetMgr.get(); }

WorldSession::_battlePetMgr

std::unique_ptr< BattlePetMgr > _battlePetMgr

Definition: WorldSession.h:1843

Here is the caller graph for this function:

CollectionMgr* WorldSession::GetCollectionMgr ( ) const

inline

1091 { return _collectionMgr.get(); }

WorldSession::_collectionMgr

std::unique_ptr< CollectionMgr > _collectionMgr

Definition: WorldSession.h:1845

uint64 WorldSession::GetConnectToInstanceKey ( ) const

inline

1724 { return _instanceConnectKey.Raw; }

WorldSession::ConnectToKey::Raw

uint64 Raw

Definition: WorldSession.h:1721

WorldSession::_instanceConnectKey

ConnectToKey _instanceConnectKey

Definition: WorldSession.h:1847

Here is the caller graph for this function:

uint8 WorldSession::GetExpansion ( ) const

inline

934 { return m_expansion; }

WorldSession::m_expansion

uint8 m_expansion

Definition: WorldSession.h:1806

Here is the caller graph for this function:

uint32 WorldSession::GetLatency ( ) const

inline

1063 { return m_latency; }

WorldSession::m_latency

std::atomic< uint32 > m_latency

Definition: WorldSession.h:1827

Here is the caller graph for this function:

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

inline

935 { return _os; }

WorldSession::_os

std::string _os

Definition: WorldSession.h:1807

Player* WorldSession::GetPlayer ( ) const

inline

927 { return _player; }

WorldSession::_player

Player * _player

Definition: WorldSession.h:1797

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:

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

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

Here is the caller graph for this function:

rbac::RBACData * WorldSession::GetRBACData ( )

 {
     return _RBACData;
 }

Here is the caller graph for this function:

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

inline

1710 { return _realmCharacterCounts; }

WorldSession::_realmCharacterCounts

std::unordered_map< uint32, uint8 > _realmCharacterCounts

Definition: WorldSession.h:1810

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

inline

1707 { return _realmListSecret; }

WorldSession::_realmListSecret

std::array< uint8, 32 > _realmListSecret

Definition: WorldSession.h:1809

uint32 WorldSession::GetRecruiterId ( ) const

inline

1085 { return recruiterId; }

WorldSession::recruiterId

uint32 recruiterId

Definition: WorldSession.h:1835

Here is the caller graph for this function:

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

inline

932 { return m_Address; }

WorldSession::m_Address

std::string m_Address

Definition: WorldSession.h:1799

Here is the caller graph for this function:

AccountTypes WorldSession::GetSecurity ( ) const

inline

921 { return _security; }

WorldSession::_security

AccountTypes _security

Definition: WorldSession.h:1802

Here is the caller graph for this function:

LocaleConstant WorldSession::GetSessionDbcLocale ( ) const

inline

1059 { return m_sessionDbcLocale; }

WorldSession::m_sessionDbcLocale

LocaleConstant m_sessionDbcLocale

Definition: WorldSession.h:1825

Here is the caller graph for this function:

LocaleConstant WorldSession::GetSessionDbLocaleIndex ( ) const

inline

1060 { return m_sessionDbLocaleIndex; }

WorldSession::m_sessionDbLocaleIndex

LocaleConstant m_sessionDbLocaleIndex

Definition: WorldSession.h:1826

Here is the caller graph for this function:

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:

uint32 WorldSession::GetTutorialInt ( uint8 index ) const

inline

1005 { return _tutorials[index]; }

WorldSession::_tutorials

uint32 _tutorials[MAX_ACCOUNT_TUTORIAL_VALUES]

Definition: WorldSession.h:1830

Here is the caller graph for this function:

void WorldSession::Handle_EarlyProccess ( WorldPacket & recvPacket )

 {
     TC_LOG_ERROR("network.opcode", "Received opcode %s that must be processed in WorldSocket::OnRead from %s"
         , GetOpcodeNameForLogging(static_cast<OpcodeClient>(recvPacket.GetOpcode())).c_str(), GetPlayerInfo().c_str());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleAcceptGrantLevel ( WorldPackets::RaF::AcceptLevelGrant & acceptLevelGrant )

 {
     Player* other = ObjectAccessor::GetPlayer(*_player, acceptLevelGrant.Granter);
     if (!(other && other->GetSession()))
         return;
 
     if (GetAccountId() != other->GetSession()->GetRecruiterId())
         return;
 
     if (other->GetGrantableLevels())
         other->SetGrantableLevels(other->GetGrantableLevels() - 1);
     else
         return;
 
     _player->GiveLevel(_player->getLevel() + 1);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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]  = { NULL, NULL, NULL, NULL, NULL, NULL };
     Item* hisItems[TRADE_SLOT_TRADED_COUNT] = { NULL, NULL, NULL, NULL, NULL, NULL };
 
     // 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() >= uint64(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() >= uint64(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 = NULL;
         SpellCastTargets my_targets;
 
         Spell* his_spell = NULL;
         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);
             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);
             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]->SetGuidValue(ITEM_FIELD_GIFTCREATOR, _player->GetGUID());
                 _player->MoveItemFromInventory(myItems[i]->GetBagSlot(), myItems[i]->GetSlot(), true);
             }
             if (hisItems[i])
             {
                 hisItems[i]->SetGuidValue(ITEM_FIELD_GIFTCREATOR, 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 %s (Account: %u) give money (Amount: " UI64FMTD ") to player: %s (Account: %u)",
                     _player->GetName().c_str(), _player->GetSession()->GetAccountId(),
                     my_trade->GetMoney(),
                     trader->GetName().c_str(), trader->GetSession()->GetAccountId());
             }
 
             if (his_trade->GetMoney() > 0)
             {
                 sLog->outCommand(trader->GetSession()->GetAccountId(), "GM %s (Account: %u) give money (Amount: " UI64FMTD ") to player: %s (Account: %u)",
                     trader->GetName().c_str(), trader->GetSession()->GetAccountId(),
                     his_trade->GetMoney(),
                     _player->GetName().c_str(), _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 = NULL;
         delete trader->m_trade;
         trader->m_trade = NULL;
 
         // desynchronized with the other saves here (SaveInventoryAndGoldToDB() not have own transaction guards)
         SQLTransaction 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:

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

 {
     Creature* unit = GetPlayer()->GetNPCIfCanInteractWith(activateTaxi.Vendor, UNIT_NPC_FLAG_FLIGHTMASTER);
     if (!unit)
     {
         TC_LOG_DEBUG("network", "WORLD: HandleActivateTaxiOpcode - %s not found or you can't interact with it.", activateTaxi.Vendor.ToString().c_str());
         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;
         }
     }
 
     std::vector<uint32> nodes;
     sTaxiPathGraph.GetCompleteNodeRoute(from, to, GetPlayer(), nodes);
     GetPlayer()->ActivateTaxiPathTo(nodes, unit);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (!normalizePlayerName(packet.Name))
         return;
 
     TC_LOG_DEBUG("network", "WorldSession::HandleAddFriendOpcode: %s asked to add friend: %s",
         GetPlayerInfo().c_str(), packet.Name.c_str());
 
     PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_GUID_RACE_ACC_BY_NAME);
     stmt->setString(0, packet.Name);
 
     _addFriendCallback.SetParam(std::move(packet.Notes));
     _addFriendCallback.SetFutureResult(CharacterDatabase.AsyncQuery(stmt));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleAddFriendOpcodeCallBack	(	PreparedQueryResult	result,
		std::string const &	friendNote
	)

 {
     if (!GetPlayer())
         return;
 
     ObjectGuid friendGuid;
     FriendsResult friendResult = FRIEND_NOT_FOUND;
 
     if (result)
     {
         Field* fields = result->Fetch();
 
         if (ObjectGuid::LowType lowGuid = fields[0].GetUInt64())
         {
             friendGuid = ObjectGuid::Create<HighGuid::Player>(lowGuid);
             uint32 team = Player::TeamForRace(fields[1].GetUInt8());
             uint32 friendAccountId = fields[2].GetUInt32();
 
             if (HasPermission(rbac::RBAC_PERM_ALLOW_GM_FRIEND) || AccountMgr::IsPlayerAccount(AccountMgr::GetSecurity(friendAccountId, realm.Id.Realm)))
             {
                 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* playerFriend = ObjectAccessor::FindPlayer(friendGuid);
                     if (playerFriend && playerFriend->IsVisibleGloballyFor(GetPlayer()))
                         friendResult = FRIEND_ADDED_ONLINE;
                     else
                         friendResult = FRIEND_ADDED_OFFLINE;
 
                     if (GetPlayer()->GetSocial()->AddToSocialList(friendGuid, SOCIAL_FLAG_FRIEND))
                         GetPlayer()->GetSocial()->SetFriendNote(friendGuid, friendNote);
                     else
                         friendResult = FRIEND_LIST_FULL;
                 }
             }
         }
     }
 
     sSocialMgr->SendFriendStatus(GetPlayer(), friendResult, friendGuid);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (!normalizePlayerName(packet.Name))
         return;
 
     TC_LOG_DEBUG("network", "WorldSession::HandleAddIgnoreOpcode: %s asked to Ignore: %s",
         GetPlayerInfo().c_str(), packet.Name.c_str());
 
     PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_GUID_BY_NAME);
     stmt->setString(0, packet.Name);
 
     _addIgnoreCallback = CharacterDatabase.AsyncQuery(stmt);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleAddIgnoreOpcodeCallBack ( PreparedQueryResult result )

 {
     if (!GetPlayer())
         return;
 
     ObjectGuid ignoreGuid;
     FriendsResult ignoreResult = FRIEND_IGNORE_NOT_FOUND;
 
     if (result)
     {
         Field* fields = result->Fetch();
 
         if (ObjectGuid::LowType lowGuid = fields[0].GetUInt64())
         {
             ignoreGuid = ObjectGuid::Create<HighGuid::Player>(lowGuid);
 
             if (ignoreGuid == GetPlayer()->GetGUID())              //not add yourself
                 ignoreResult = FRIEND_IGNORE_SELF;
             else if (GetPlayer()->GetSocial()->HasIgnore(ignoreGuid))
                 ignoreResult = FRIEND_IGNORE_ALREADY;
             else
             {
                 ignoreResult = FRIEND_IGNORE_ADDED;
 
                 // ignore list full
                 if (!GetPlayer()->GetSocial()->AddToSocialList(ignoreGuid, 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:

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:

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))
         _player->DestroyItem(item->GetBagSlot(), item->GetSlot(), true);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     BarberShopStyleEntry const* bs_hair = sBarberShopStyleStore.LookupEntry(packet.NewHairStyle);
     if (!bs_hair || bs_hair->Type != 0 || bs_hair->Race != _player->getRace() || bs_hair->Sex != _player->GetByteValue(PLAYER_BYTES_3, PLAYER_BYTES_3_OFFSET_GENDER))
         return;
 
     BarberShopStyleEntry const* bs_facialHair = sBarberShopStyleStore.LookupEntry(packet.NewFacialHair);
     if (!bs_facialHair || bs_facialHair->Type != 2 || bs_facialHair->Race != _player->getRace() || bs_facialHair->Sex != _player->GetByteValue(PLAYER_BYTES_3, PLAYER_BYTES_3_OFFSET_GENDER))
         return;
 
     BarberShopStyleEntry const* bs_skinColor = sBarberShopStyleStore.LookupEntry(packet.NewSkinColor);
     if (bs_skinColor && (bs_skinColor->Type != 3 || bs_skinColor->Race != _player->getRace() || bs_skinColor->Sex != _player->GetByteValue(PLAYER_BYTES_3, PLAYER_BYTES_3_OFFSET_GENDER)))
         return;
 
     BarberShopStyleEntry const* bs_face = sBarberShopStyleStore.LookupEntry(packet.NewFace);
     if (bs_face && (bs_face->Type != 4 || bs_face->Race != _player->getRace() || bs_face->Sex != _player->GetByteValue(PLAYER_BYTES_3, PLAYER_BYTES_3_OFFSET_GENDER)))
         return;
 
     if (!Player::ValidateAppearance(_player->getRace(), _player->getClass(), _player->GetByteValue(PLAYER_BYTES_3, PLAYER_BYTES_3_OFFSET_GENDER),
         bs_hair->Data,
         packet.NewHairColor,
         bs_face ? bs_face->Data : _player->GetByteValue(PLAYER_BYTES, PLAYER_BYTES_OFFSET_FACE_ID),
         bs_facialHair->Data,
         bs_skinColor ? bs_skinColor->Data : _player->GetByteValue(PLAYER_BYTES, PLAYER_BYTES_OFFSET_SKIN_ID)))
         return;
 
     GameObject* go = _player->FindNearestGameObjectOfType(GAMEOBJECT_TYPE_BARBER_CHAIR, 5.0f);
     if (!go)
     {
         SendBarberShopResult(BARBER_SHOP_RESULT_NOT_ON_CHAIR);
         return;
     }
 
     if (_player->GetStandState() != UnitStandStateType(UNIT_STAND_STATE_SIT_LOW_CHAIR + go->GetGOInfo()->barberChair.chairheight))
     {
         SendBarberShopResult(BARBER_SHOP_RESULT_NOT_ON_CHAIR);
         return;
     }
 
     uint32 cost = _player->GetBarberShopCost(bs_hair, packet.NewHairColor, bs_facialHair, bs_skinColor, bs_face);
 
     // 0 - ok
     // 1, 3 - not enough money
     // 2 - you have to sit on barber chair
     if (!_player->HasEnoughMoney((uint64)cost))
     {
         SendBarberShopResult(BARBER_SHOP_RESULT_NO_MONEY);
         return;
     }
 
     SendBarberShopResult(BARBER_SHOP_RESULT_SUCCESS);
 
     _player->ModifyMoney(-int64(cost));                     // it isn't free
     _player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_GOLD_SPENT_AT_BARBER, cost);
 
     _player->SetByteValue(PLAYER_BYTES, PLAYER_BYTES_OFFSET_HAIR_STYLE_ID, uint8(bs_hair->Data));
     _player->SetByteValue(PLAYER_BYTES, PLAYER_BYTES_OFFSET_HAIR_COLOR_ID, uint8(packet.NewHairColor));
     _player->SetByteValue(PLAYER_BYTES_2, PLAYER_BYTES_2_OFFSET_FACIAL_STYLE, uint8(bs_facialHair->Data));
     if (bs_skinColor)
         _player->SetByteValue(PLAYER_BYTES, PLAYER_BYTES_OFFSET_SKIN_ID, uint8(bs_skinColor->Data));
     if (bs_face)
         _player->SetByteValue(PLAYER_BYTES, PLAYER_BYTES_OFFSET_FACE_ID, uint8(bs_face->Data));
 
     _player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_VISIT_BARBER_SHOP, 1);
 
     _player->SetStandState(UNIT_STAND_STATE_STAND);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     Creature* unit = GetPlayer()->GetMap()->GetCreature(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->GetZoneId()))
         bf->SendAreaSpiritHealerQueryOpcode(_player, areaSpiritHealerQuery.HealerGuid);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     Creature* unit = GetPlayer()->GetMap()->GetCreature(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->GetZoneId()))
         bf->AddPlayerToResurrectQueue(areaSpiritHealerQueue.HealerGuid, _player->GetGUID());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     Player* player = GetPlayer();
     if (player->IsInFlight())
     {
         TC_LOG_DEBUG("network", "HandleAreaTriggerOpcode: Player '%s' (%s) in flight, ignore Area Trigger ID:%u",
             player->GetName().c_str(), player->GetGUID().ToString().c_str(), packet.AreaTriggerID);
         return;
     }
 
     AreaTriggerEntry const* atEntry = sAreaTriggerStore.LookupEntry(packet.AreaTriggerID);
     if (!atEntry)
     {
         TC_LOG_DEBUG("network", "HandleAreaTriggerOpcode: Player '%s' (%s) send unknown (by DBC) Area Trigger ID:%u",
             player->GetName().c_str(), player->GetGUID().ToString().c_str(), packet.AreaTriggerID);
         return;
     }
 
     if (!player->IsInAreaTriggerRadius(atEntry))
     {
         TC_LOG_DEBUG("network", "HandleAreaTriggerOpcode: Player '%s' (%s) too far, ignore Area Trigger ID: %u",
             player->GetName().c_str(), player->GetGUID().ToString().c_str(), packet.AreaTriggerID);
         return;
     }
 
     if (player->isDebugAreaTriggers)
         ChatHandler(player->GetSession()).PSendSysMessage(packet.Entered ? LANG_DEBUG_AREATRIGGER_ENTERED : LANG_DEBUG_AREATRIGGER_LEFT, packet.AreaTriggerID);
 
     if (sScriptMgr->OnAreaTrigger(player, atEntry, packet.Entered))
         return;
 
     if (player->IsAlive())
     {
         if (std::unordered_set<uint32> const* quests = sObjectMgr->GetQuestsForAreaTrigger(packet.AreaTriggerID))
         {
             for (uint32 questId : *quests)
             {
                 Quest const* qInfo = sObjectMgr->GetQuestTemplate(questId);
                 if (qInfo && player->GetQuestStatus(questId) == QUEST_STATUS_INCOMPLETE)
                 {
                     for (uint8 j = 0; j < qInfo->Objectives.size(); ++j)
                     {
                         if (qInfo->Objectives[j].Type == QUEST_OBJECTIVE_AREATRIGGER)
                         {
                             player->SetQuestObjectiveData(qInfo, j, int32(true));
                             break;
                         }
                     }
 
                     if (player->CanCompleteQuest(questId))
                         player->CompleteQuest(questId);
                 }
             }
         }
     }
 
     if (sObjectMgr->IsTavernAreaTrigger(packet.AreaTriggerID))
     {
         // set resting flag we are in the inn
         player->SetRestFlag(REST_FLAG_IN_TAVERN, atEntry->ID);
 
         if (sWorld->IsFFAPvPRealm())
             player->RemoveByteFlag(UNIT_FIELD_BYTES_2, 1, UNIT_BYTE2_FLAG_FFA_PVP);
 
         return;
     }
 
     if (Battleground* bg = player->GetBattleground())
         if (bg->GetStatus() == STATUS_IN_PROGRESS)
             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 (Map::EnterState denyReason = sMapMgr->PlayerCannotEnter(at->target_mapId, player, false))
         {
             bool reviveAtTrigger = false; // should we revive the player if he is trying to enter the correct instance?
             switch (denyReason)
             {
                 case Map::CANNOT_ENTER_NO_ENTRY:
                     TC_LOG_DEBUG("maps", "MAP: Player '%s' attempted to enter map with id %d which has no entry", player->GetName().c_str(), at->target_mapId);
                     break;
                 case Map::CANNOT_ENTER_UNINSTANCED_DUNGEON:
                     TC_LOG_DEBUG("maps", "MAP: Player '%s' attempted to enter dungeon map %d but no instance template was found", player->GetName().c_str(), at->target_mapId);
                     break;
                 case Map::CANNOT_ENTER_DIFFICULTY_UNAVAILABLE:
                     TC_LOG_DEBUG("maps", "MAP: Player '%s' attempted to enter instance map %d but the requested difficulty was not found", player->GetName().c_str(), at->target_mapId);
                     if (MapEntry const* entry = sMapStore.LookupEntry(at->target_mapId))
                         player->SendTransferAborted(entry->ID, TRANSFER_ABORT_DIFFICULTY, player->GetDifficultyID(entry));
                     break;
                 case Map::CANNOT_ENTER_NOT_IN_RAID:
                     TC_LOG_DEBUG("maps", "MAP: Player '%s' must be in a raid group to enter map %d", player->GetName().c_str(), at->target_mapId);
                     player->SendRaidGroupOnlyMessage(RAID_GROUP_ERR_ONLY, 0);
                     reviveAtTrigger = true;
                     break;
                 case Map::CANNOT_ENTER_CORPSE_IN_DIFFERENT_INSTANCE:
                     player->GetSession()->SendPacket(WorldPackets::Misc::AreaTriggerNoCorpse().Write());
                     TC_LOG_DEBUG("maps", "MAP: Player '%s' does not have a corpse in instance map %d and cannot enter", player->GetName().c_str(), at->target_mapId);
                     break;
                 case Map::CANNOT_ENTER_INSTANCE_BIND_MISMATCH:
                     if (MapEntry const* entry = sMapStore.LookupEntry(at->target_mapId))
                     {
                         char const* mapName = entry->MapName_lang;
                         TC_LOG_DEBUG("maps", "MAP: Player '%s' cannot enter instance map '%s' because their permanent bind is incompatible with their group's", player->GetName().c_str(), mapName);
                         // is there a special opcode for this?
                         // @todo figure out how to get player localized difficulty string (e.g. "10 player", "Heroic" etc)
                         ChatHandler(player->GetSession()).PSendSysMessage(player->GetSession()->GetTrinityString(LANG_INSTANCE_BIND_MISMATCH), mapName);
                     }
                     reviveAtTrigger = true;
                     break;
                 case Map::CANNOT_ENTER_TOO_MANY_INSTANCES:
                     player->SendTransferAborted(at->target_mapId, TRANSFER_ABORT_TOO_MANY_INSTANCES);
                     TC_LOG_DEBUG("maps", "MAP: Player '%s' cannot enter instance map %d because he has exceeded the maximum number of instances per hour.", player->GetName().c_str(), at->target_mapId);
                     reviveAtTrigger = true;
                     break;
                 case Map::CANNOT_ENTER_MAX_PLAYERS:
                     player->SendTransferAborted(at->target_mapId, TRANSFER_ABORT_MAX_PLAYERS);
                     reviveAtTrigger = true;
                     break;
                 case Map::CANNOT_ENTER_ZONE_IN_COMBAT:
                     player->SendTransferAborted(at->target_mapId, TRANSFER_ABORT_ZONE_IN_COMBAT);
                     reviveAtTrigger = true;
                     break;
                 default:
                     break;
             }
 
             if (reviveAtTrigger) // check if the player is touching the areatrigger leading to the map his corpse is on
                 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)
         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:

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:

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

Client explicitly checks the following before sending CMSG_ATTACKSWING 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:

void WorldSession::HandleAuctionHelloOpcode ( WorldPackets::AuctionHouse::AuctionHelloRequest & packet )

 {
     Creature* unit = GetPlayer()->GetNPCIfCanInteractWith(packet.Guid, UNIT_NPC_FLAG_AUCTIONEER);
     if (!unit)
     {
         TC_LOG_DEBUG("network", "WORLD: HandleAuctionHelloOpcode - Unit (%s) not found or you can't interact with him.", packet.Guid.ToString().c_str());
         return;
     }
 
     // remove fake death
     if (GetPlayer()->HasUnitState(UNIT_STATE_DIED))
         GetPlayer()->RemoveAurasByType(SPELL_AURA_FEIGN_DEATH);
 
     SendAuctionHello(packet.Guid, unit);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleAuctionListBidderItems ( WorldPackets::AuctionHouse::AuctionListBidderItems & packet )

 {
     Creature* creature = GetPlayer()->GetNPCIfCanInteractWith(packet.Auctioneer, UNIT_NPC_FLAG_AUCTIONEER);
     if (!creature)
     {
         TC_LOG_DEBUG("network", "WORLD: HandleAuctionListBidderItems - %s not found or you can't interact with him.", packet.Auctioneer.ToString().c_str());
         return;
     }
 
     // remove fake death
     if (GetPlayer()->HasUnitState(UNIT_STATE_DIED))
         GetPlayer()->RemoveAurasByType(SPELL_AURA_FEIGN_DEATH);
 
     AuctionHouseObject* auctionHouse = sAuctionMgr->GetAuctionsMap(creature->getFaction());
 
     WorldPackets::AuctionHouse::AuctionListBidderItemsResult result;
 
     Player player = GetPlayer();
     auctionHouse->BuildListBidderItems(result, player, result.TotalCount);
     result.DesiredDelay = 300;
     SendPacket(result.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleAuctionListItems ( WorldPackets::AuctionHouse::AuctionListItems & packet )

 {
     Creature* creature = GetPlayer()->GetNPCIfCanInteractWith(packet.Auctioneer, UNIT_NPC_FLAG_AUCTIONEER);
     if (!creature)
     {
         TC_LOG_DEBUG("network", "WORLD: HandleAuctionListItems - %s not found or you can't interact with him.", packet.Auctioneer.ToString().c_str());
         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 (%s), searchedname: %s, levelmin: %u, levelmax: %u, auctionSlotID: %u, auctionMainCategory: %u, auctionSubCategory: %u, quality: %u, usable: %u",
         packet.Auctioneer.ToString().c_str(), packet.Name.c_str(), packet.MinLevel, packet.MaxLevel , packet.InvType, packet.ItemClass, packet.ItemSubclass, packet.Quality, packet.OnlyUsable);
 
     WorldPackets::AuctionHouse::AuctionListItemsResult result;
 
     // converting string that we try to find to lower case
     std::wstring wsearchedname;
     if (!Utf8toWStr(packet.Name, wsearchedname))
         return;
 
     wstrToLower(wsearchedname);
 
     auctionHouse->BuildListAuctionItems(result, _player,
         wsearchedname, packet.Offset, packet.MinLevel, packet.MaxLevel, packet.OnlyUsable,
         packet.InvType, packet.ItemClass, packet.ItemSubclass, packet.Quality, result.TotalCount);
 
     result.DesiredDelay = 300;
     result.OnlyUsable = packet.OnlyUsable;
     SendPacket(result.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleAuctionListOwnerItems ( WorldPackets::AuctionHouse::AuctionListOwnerItems & packet )

 {
     Creature* creature = GetPlayer()->GetNPCIfCanInteractWith(packet.Auctioneer, UNIT_NPC_FLAG_AUCTIONEER);
     if (!creature)
     {
         TC_LOG_DEBUG("network", "WORLD: HandleAuctionListOwnerItems - %s not found or you can't interact with him.", packet.Auctioneer.ToString().c_str());
         return;
     }
 
     // remove fake death
     if (GetPlayer()->HasUnitState(UNIT_STATE_DIED))
         GetPlayer()->RemoveAurasByType(SPELL_AURA_FEIGN_DEATH);
 
     AuctionHouseObject* auctionHouse = sAuctionMgr->GetAuctionsMap(creature->getFaction());
 
     WorldPackets::AuctionHouse::AuctionListOwnerItemsResult result;
 
     auctionHouse->BuildListOwnerItems(result, _player, result.TotalCount);
     result.DesiredDelay = 300;
     SendPacket(result.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleAuctionListPendingSales ( WorldPackets::AuctionHouse::AuctionListPendingSales & packet )

 {
     WorldPackets::AuctionHouse::AuctionListPendingSalesResult result;
     result.TotalNumRecords = 0;
     SendPacket(result.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleAuctionPlaceBid ( WorldPackets::AuctionHouse::AuctionPlaceBid & packet )

 {
     if (!packet.AuctionItemID || !packet.BidAmount)
         return; // check for cheaters
 
     Creature* creature = GetPlayer()->GetNPCIfCanInteractWith(packet.Auctioneer, UNIT_NPC_FLAG_AUCTIONEER);
     if (!creature)
     {
         TC_LOG_DEBUG("network", "WORLD: HandleAuctionPlaceBid - %s not found or you can't interact with him.", packet.Auctioneer.ToString().c_str());
         return;
     }
 
     // remove fake death
     if (GetPlayer()->HasUnitState(UNIT_STATE_DIED))
         GetPlayer()->RemoveAurasByType(SPELL_AURA_FEIGN_DEATH);
 
     AuctionHouseObject* auctionHouse = sAuctionMgr->GetAuctionsMap(creature->getFaction());
 
     AuctionEntry* auction = auctionHouse->GetAuction(packet.AuctionItemID);
     Player* player = GetPlayer();
 
     if (!auction || auction->owner == player->GetGUID().GetCounter())
     {
         //you cannot bid your own auction:
         SendAuctionCommandResult(NULL, AUCTION_PLACE_BID, ERR_AUCTION_BID_OWN);
         return;
     }
 
     // impossible have online own another character (use this for speedup check in case online owner)
     ObjectGuid ownerGuid = ObjectGuid::Create<HighGuid::Player>(auction->owner);
     Player* auction_owner = ObjectAccessor::FindPlayer(ownerGuid);
     if (!auction_owner && ObjectMgr::GetPlayerAccountIdByGUID(ownerGuid) == player->GetSession()->GetAccountId())
     {
         //you cannot bid your another character auction:
         SendAuctionCommandResult(NULL, AUCTION_PLACE_BID, ERR_AUCTION_BID_OWN);
         return;
     }
 
     // cheating
     if (packet.BidAmount <= auction->bid || packet.BidAmount < auction->startbid)
         return;
 
     // price too low for next bid if not buyout
     if ((packet.BidAmount < auction->buyout || auction->buyout == 0) &&
         packet.BidAmount < auction->bid + auction->GetAuctionOutBid())
     {
         // client already test it but just in case ...
         SendAuctionCommandResult(auction, AUCTION_PLACE_BID, ERR_AUCTION_HIGHER_BID);
         return;
     }
 
     if (!player->HasEnoughMoney(packet.BidAmount))
     {
         // client already test it but just in case ...
         SendAuctionCommandResult(auction, AUCTION_PLACE_BID, ERR_AUCTION_NOT_ENOUGHT_MONEY);
         return;
     }
 
     SQLTransaction trans = CharacterDatabase.BeginTransaction();
 
     if (packet.BidAmount < auction->buyout || auction->buyout == 0)
     {
         if (auction->bidder)
         {
             if (auction->bidder == player->GetGUID().GetCounter())
                 player->ModifyMoney(-int64(packet.BidAmount - auction->bid));
             else
             {
                 // mail to last bidder and return money
                 sAuctionMgr->SendAuctionOutbiddedMail(auction, packet.BidAmount, GetPlayer(), trans);
                 player->ModifyMoney(-int64(packet.BidAmount));
             }
         }
         else
             player->ModifyMoney(-int64(packet.BidAmount));
 
         auction->bidder = player->GetGUID().GetCounter();
         auction->bid = packet.BidAmount;
         GetPlayer()->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_AUCTION_BID, packet.BidAmount);
 
         PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_AUCTION_BID);
         stmt->setUInt64(0, auction->bidder);
         stmt->setUInt32(1, auction->bid);
         stmt->setUInt32(2, auction->Id);
         trans->Append(stmt);
 
         SendAuctionCommandResult(auction, AUCTION_PLACE_BID, ERR_AUCTION_OK);
 
         // Not sure if we must send this now.
         Player* owner = ObjectAccessor::FindConnectedPlayer(ObjectGuid::Create<HighGuid::Player>(auction->owner));
         Item* item = sAuctionMgr->GetAItem(auction->itemGUIDLow);
         if (owner && item)
             owner->GetSession()->SendAuctionOwnerBidNotification(auction, item);
     }
     else
     {
         //buyout:
         if (player->GetGUID().GetCounter() == auction->bidder)
             player->ModifyMoney(-int64(auction->buyout - auction->bid));
         else
         {
             player->ModifyMoney(-int64(auction->buyout));
             if (auction->bidder)                          //buyout for bidded auction ..
                 sAuctionMgr->SendAuctionOutbiddedMail(auction, auction->buyout, GetPlayer(), trans);
         }
         auction->bidder = player->GetGUID().GetCounter();
         auction->bid = auction->buyout;
         GetPlayer()->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_AUCTION_BID, auction->buyout);
 
         SendAuctionCommandResult(auction, AUCTION_PLACE_BID, ERR_AUCTION_OK);
 
         //- Mails must be under transaction control too to prevent data loss
         sAuctionMgr->SendAuctionSalePendingMail(auction, trans);
         sAuctionMgr->SendAuctionSuccessfulMail(auction, trans);
         sAuctionMgr->SendAuctionWonMail(auction, trans);
 
         auction->DeleteFromDB(trans);
 
         sAuctionMgr->RemoveAItem(auction->itemGUIDLow);
         auctionHouse->RemoveAuction(auction);
     }
 
     player->SaveInventoryAndGoldToDB(trans);
     CharacterDatabase.CommitTransaction(trans);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleAuctionRemoveItem ( WorldPackets::AuctionHouse::AuctionRemoveItem & packet )

 {
     Creature* creature = GetPlayer()->GetNPCIfCanInteractWith(packet.Auctioneer, UNIT_NPC_FLAG_AUCTIONEER);
     if (!creature)
     {
         TC_LOG_DEBUG("network", "WORLD: HandleAuctionRemoveItem - %s not found or you can't interact with him.", packet.Auctioneer.ToString().c_str());
         return;
     }
 
     // remove fake death
     if (GetPlayer()->HasUnitState(UNIT_STATE_DIED))
         GetPlayer()->RemoveAurasByType(SPELL_AURA_FEIGN_DEATH);
 
     AuctionHouseObject* auctionHouse = sAuctionMgr->GetAuctionsMap(creature->getFaction());
 
     AuctionEntry* auction = auctionHouse->GetAuction(packet.AuctionItemID);
     Player* player = GetPlayer();
 
     SQLTransaction trans = CharacterDatabase.BeginTransaction();
     if (auction && auction->owner == player->GetGUID().GetCounter())
     {
         Item* item = sAuctionMgr->GetAItem(auction->itemGUIDLow);
         if (item)
         {
             if (auction->bidder)                            // If we have a bidder, we have to send him the money he paid
             {
                 uint32 auctionCut = auction->GetAuctionCut();
                 if (!player->HasEnoughMoney((uint64)auctionCut))          //player doesn't have enough money, maybe message needed
                     return;
                 sAuctionMgr->SendAuctionCancelledToBidderMail(auction, trans);
                 player->ModifyMoney(-int64(auctionCut));
             }
 
             // item will deleted or added to received mail list
             MailDraft(auction->BuildAuctionMailSubject(AUCTION_CANCELED), AuctionEntry::BuildAuctionMailBody(0, 0, auction->buyout, auction->deposit, 0))
                 .AddItem(item)
                 .SendMailTo(trans, player, auction, MAIL_CHECK_MASK_COPIED);
         }
         else
         {
             TC_LOG_ERROR("network", "Auction id: %u got non existing item (item guid : " UI64FMTD ")!", auction->Id, auction->itemGUIDLow);
             SendAuctionCommandResult(NULL, AUCTION_CANCEL, ERR_AUCTION_DATABASE_ERROR);
             return;
         }
     }
     else
     {
         SendAuctionCommandResult(NULL, AUCTION_CANCEL, ERR_AUCTION_DATABASE_ERROR);
         //this code isn't possible ... maybe there should be assert
         TC_LOG_ERROR("network", "CHEATER: %s tried to cancel auction (id: %u) of another player or auction is NULL", player->GetGUID().ToString().c_str(), packet.AuctionItemID);
         return;
     }
 
     //inform player, that auction is removed
     SendAuctionCommandResult(auction, AUCTION_CANCEL, ERR_AUCTION_OK);
 
     // Now remove the auction
 
     player->SaveInventoryAndGoldToDB(trans);
     auction->DeleteFromDB(trans);
     CharacterDatabase.CommitTransaction(trans);
 
     sAuctionMgr->RemoveAItem(auction->itemGUIDLow);
     auctionHouse->RemoveAuction(auction);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleAuctionSellItem ( WorldPackets::AuctionHouse::AuctionSellItem & packet )

- HARDCODED DB GUID, BAD BAD BAD

 {
     if (packet.Items.size() > MAX_AUCTION_ITEMS)
     {
         SendAuctionCommandResult(NULL, AUCTION_SELL_ITEM, ERR_AUCTION_DATABASE_ERROR);
         return;
     }
 
     for (auto const& item : packet.Items)
         if (!item.Guid || !item.UseCount || item.UseCount > 1000)
             return;
 
     if (!packet.MinBid || !packet.RunTime)
         return;
 
     if (packet.MinBid > MAX_MONEY_AMOUNT || packet.BuyoutPrice > MAX_MONEY_AMOUNT)
     {
         TC_LOG_DEBUG("network", "WORLD: HandleAuctionSellItem - Player %s (%s) attempted to sell item with higher price than max gold amount.", _player->GetName().c_str(), _player->GetGUID().ToString().c_str());
         SendAuctionCommandResult(NULL, AUCTION_SELL_ITEM, ERR_AUCTION_DATABASE_ERROR);
         return;
     }
 
 
     Creature* creature = GetPlayer()->GetNPCIfCanInteractWith(packet.Auctioneer, UNIT_NPC_FLAG_AUCTIONEER);
     if (!creature)
     {
         TC_LOG_DEBUG("network", "WORLD: HandleAuctionSellItem - Unit (%s) not found or you can't interact with him.", packet.Auctioneer.ToString().c_str());
         return;
     }
 
     AuctionHouseEntry const* auctionHouseEntry = AuctionHouseMgr::GetAuctionHouseEntry(creature->getFaction());
     if (!auctionHouseEntry)
     {
         TC_LOG_DEBUG("network", "WORLD: HandleAuctionSellItem - Unit (%s) has wrong faction.", packet.Auctioneer.ToString().c_str());
         return;
     }
 
     packet.RunTime *= MINUTE;
 
     switch (packet.RunTime)
     {
         case 1 * MIN_AUCTION_TIME:
         case 2 * MIN_AUCTION_TIME:
         case 4 * MIN_AUCTION_TIME:
             break;
         default:
             return;
     }
 
     if (GetPlayer()->HasUnitState(UNIT_STATE_DIED))
         GetPlayer()->RemoveAurasByType(SPELL_AURA_FEIGN_DEATH);
 
     uint32 finalCount = 0;
     for (auto const& packetItem : packet.Items)
     {
         Item* item = _player->GetItemByGuid(packetItem.Guid);
 
         if (!item)
         {
             SendAuctionCommandResult(NULL, AUCTION_SELL_ITEM, ERR_AUCTION_ITEM_NOT_FOUND);
             return;
         }
 
         if (sAuctionMgr->GetAItem(item->GetGUID().GetCounter()) || !item->CanBeTraded() || item->IsNotEmptyBag() ||
             item->GetTemplate()->GetFlags() & ITEM_FLAG_CONJURED || item->GetUInt32Value(ITEM_FIELD_DURATION) ||
             item->GetCount() < packetItem.UseCount)
         {
             SendAuctionCommandResult(NULL, AUCTION_SELL_ITEM, ERR_AUCTION_DATABASE_ERROR);
             return;
         }
 
         finalCount += packetItem.UseCount;
     }
 
     if (packet.Items.empty())
     {
         SendAuctionCommandResult(NULL, AUCTION_SELL_ITEM, ERR_AUCTION_DATABASE_ERROR);
         return;
     }
 
     if (!finalCount)
     {
         SendAuctionCommandResult(NULL, AUCTION_SELL_ITEM, ERR_AUCTION_DATABASE_ERROR);
         return;
     }
 
     // check if there are 2 identical guids, in this case user is most likely cheating
     for (uint32 i = 0; i < packet.Items.size() - 1; ++i)
     {
         for (uint32 j = i + 1; j < packet.Items.size(); ++j)
         {
             if (packet.Items[i].Guid == packet.Items[j].Guid)
             {
                 SendAuctionCommandResult(NULL, AUCTION_SELL_ITEM, ERR_AUCTION_DATABASE_ERROR);
                 return;
             }
         }
     }
 
     for (auto const& packetItem : packet.Items)
     {
         Item* item = _player->GetItemByGuid(packetItem.Guid);
 
         if (item->GetMaxStackCount() < finalCount)
         {
             SendAuctionCommandResult(NULL, AUCTION_SELL_ITEM, ERR_AUCTION_DATABASE_ERROR);
             return;
         }
     }
 
     Item* item = _player->GetItemByGuid(packet.Items[0].Guid);
 
     uint32 auctionTime = uint32(packet.RunTime * sWorld->getRate(RATE_AUCTION_TIME));
     AuctionHouseObject* auctionHouse = sAuctionMgr->GetAuctionsMap(creature->getFaction());
 
     uint32 deposit = sAuctionMgr->GetAuctionDeposit(auctionHouseEntry, packet.RunTime, item, finalCount);
     if (!_player->HasEnoughMoney((uint64)deposit))
     {
         SendAuctionCommandResult(NULL, AUCTION_SELL_ITEM, ERR_AUCTION_NOT_ENOUGHT_MONEY);
         return;
     }
 
     AuctionEntry* AH = new AuctionEntry();
 
     if (sWorld->getBoolConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_AUCTION))
         AH->auctioneer = UI64LIT(23442);     
     else
         AH->auctioneer = packet.Auctioneer.GetCounter();
 
     // Required stack size of auction matches to current item stack size, just move item to auctionhouse
     if (packet.Items.size() == 1 && item->GetCount() == packet.Items[0].UseCount)
     {
         if (HasPermission(rbac::RBAC_PERM_LOG_GM_TRADE))
         {
             sLog->outCommand(GetAccountId(), "GM %s (Account: %u) create auction: %s (Entry: %u Count: %u)",
                 GetPlayerName().c_str(), GetAccountId(), item->GetTemplate()->GetDefaultLocaleName(), item->GetEntry(), item->GetCount());
         }
 
         AH->Id = sObjectMgr->GenerateAuctionID();
         AH->itemGUIDLow = item->GetGUID().GetCounter();
         AH->itemEntry = item->GetEntry();
         AH->itemCount = item->GetCount();
         AH->owner = _player->GetGUID().GetCounter();
         AH->startbid = packet.MinBid;
         AH->bidder = UI64LIT(0);
         AH->bid = 0;
         AH->buyout = packet.BuyoutPrice;
         AH->expire_time = time(NULL) + auctionTime;
         AH->deposit = deposit;
         AH->etime = packet.RunTime;
         AH->auctionHouseEntry = auctionHouseEntry;
 
         TC_LOG_INFO("network", "CMSG_AUCTION_SELL_ITEM: %s %s is selling item %s %s to auctioneer " UI64FMTD " with count %u with initial bid " UI64FMTD " with buyout " UI64FMTD " and with time %u (in sec) in auctionhouse %u",
             _player->GetGUID().ToString().c_str(), _player->GetName().c_str(), item->GetGUID().ToString().c_str(), item->GetTemplate()->GetDefaultLocaleName(), AH->auctioneer, item->GetCount(), packet.MinBid, packet.BuyoutPrice, auctionTime, AH->GetHouseId());
         sAuctionMgr->AddAItem(item);
         auctionHouse->AddAuction(AH);
         sAuctionMgr->PendingAuctionAdd(_player, AH);
 
         _player->MoveItemFromInventory(item->GetBagSlot(), item->GetSlot(), true);
 
         SQLTransaction trans = CharacterDatabase.BeginTransaction();
         item->DeleteFromInventoryDB(trans);
         item->SaveToDB(trans);
 
         AH->SaveToDB(trans);
         _player->SaveInventoryAndGoldToDB(trans);
         CharacterDatabase.CommitTransaction(trans);
 
         SendAuctionCommandResult(AH, AUCTION_SELL_ITEM, ERR_AUCTION_OK);
 
         GetPlayer()->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_CREATE_AUCTION, 1);
     }
     else // Required stack size of auction does not match to current item stack size, clone item and set correct stack size
     {
         Item* newItem = item->CloneItem(finalCount, _player);
         if (!newItem)
         {
             TC_LOG_ERROR("network", "CMSG_AUCTION_SELL_ITEM: Could not create clone of item %u", item->GetEntry());
             SendAuctionCommandResult(NULL, AUCTION_SELL_ITEM, ERR_AUCTION_DATABASE_ERROR);
             delete AH;
             return;
         }
 
         if (HasPermission(rbac::RBAC_PERM_LOG_GM_TRADE))
         {
             sLog->outCommand(GetAccountId(), "GM %s (Account: %u) create auction: %s (Entry: %u Count: %u)",
                 GetPlayerName().c_str(), GetAccountId(), newItem->GetTemplate()->GetDefaultLocaleName(), newItem->GetEntry(), newItem->GetCount());
         }
 
         AH->Id = sObjectMgr->GenerateAuctionID();
         AH->itemGUIDLow = newItem->GetGUID().GetCounter();
         AH->itemEntry = newItem->GetEntry();
         AH->itemCount = newItem->GetCount();
         AH->owner = _player->GetGUID().GetCounter();
         AH->startbid = packet.MinBid;
         AH->bidder = UI64LIT(0);
         AH->bid = 0;
         AH->buyout = packet.BuyoutPrice;
         AH->expire_time = time(NULL) + auctionTime;
         AH->deposit = deposit;
         AH->etime = packet.RunTime;
         AH->auctionHouseEntry = auctionHouseEntry;
 
         TC_LOG_INFO("network", "CMSG_AUCTION_SELL_ITEM: %s %s is selling %s %s to auctioneer " UI64FMTD " with count %u with initial bid " UI64FMTD " with buyout " UI64FMTD " and with time %u (in sec) in auctionhouse %u",
             _player->GetGUID().ToString().c_str(), _player->GetName().c_str(), newItem->GetGUID().ToString().c_str(), newItem->GetTemplate()->GetDefaultLocaleName(), AH->auctioneer, newItem->GetCount(), packet.MinBid, packet.BuyoutPrice, auctionTime, AH->GetHouseId());
         sAuctionMgr->AddAItem(newItem);
         auctionHouse->AddAuction(AH);
         sAuctionMgr->PendingAuctionAdd(_player, AH);
 
         for (auto const& packetItem : packet.Items)
         {
             Item* item2 = _player->GetItemByGuid(packetItem.Guid);
 
             // Item stack count equals required count, ready to delete item - cloned item will be used for auction
             if (item2->GetCount() == packetItem.UseCount)
             {
                 _player->MoveItemFromInventory(item2->GetBagSlot(), item2->GetSlot(), true);
 
                 SQLTransaction trans = CharacterDatabase.BeginTransaction();
                 item2->DeleteFromInventoryDB(trans);
                 item2->DeleteFromDB(trans);
                 CharacterDatabase.CommitTransaction(trans);
                 delete item2;
             }
             else // Item stack count is bigger than required count, update item stack count and save to database - cloned item will be used for auction
             {
                 item2->SetCount(item2->GetCount() - packetItem.UseCount);
                 item2->SetState(ITEM_CHANGED, _player);
                 _player->ItemRemovedQuestCheck(item2->GetEntry(), packetItem.UseCount);
                 item2->SendUpdateToPlayer(_player);
 
                 SQLTransaction trans = CharacterDatabase.BeginTransaction();
                 item2->SaveToDB(trans);
                 CharacterDatabase.CommitTransaction(trans);
             }
         }
 
         SQLTransaction trans = CharacterDatabase.BeginTransaction();
         newItem->SaveToDB(trans);
         AH->SaveToDB(trans);
         _player->SaveInventoryAndGoldToDB(trans);
         CharacterDatabase.CommitTransaction(trans);
 
         SendAuctionCommandResult(AH, AUCTION_SELL_ITEM, ERR_AUCTION_OK);
 
         GetPlayer()->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_CREATE_AUCTION, 1);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     TC_LOG_DEBUG("network", "STORAGE: receive bag = %u, slot = %u", packet.Bag, packet.Slot);
 
     if (!CanUseBank())
     {
         TC_LOG_ERROR("network", "WORLD: HandleAutoBankItemOpcode - Unit (%s) not found or you can't interact with him.", m_currentBankerGUID.ToString().c_str());
         return;
     }
 
     Item* item = _player->GetItemByPos(packet.Bag, packet.Slot);
     if (!item)
         return;
 
     ItemPosCountVec dest;
     InventoryResult msg = _player->CanBankItem(NULL_BAG, NULL_SLOT, dest, item, false);
     if (msg != EQUIP_ERR_OK)
     {
         _player->SendEquipError(msg, item, NULL);
         return;
     }
 
     if (dest.size() == 1 && dest[0].pos == item->GetPos())
     {
         _player->SendEquipError(EQUIP_ERR_CANT_SWAP, item, NULL);
         return;
     }
 
     _player->RemoveItem(packet.Bag, packet.Slot, true);
     _player->ItemRemovedQuestCheck(item->GetEntry(), item->GetCount());
     _player->BankItem(dest, item, true);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (autoEquipItem.Inv.Items.size() != 1)
     {
         TC_LOG_ERROR("network", "HandleAutoEquipItemOpcode - Invalid itemCount (" SZFMTD ")", autoEquipItem.Inv.Items.size());
         return;
     }
 
     TC_LOG_DEBUG("network", "HandleAutoEquipItemOpcode: receive PackSlot: %u, Slot: %u",
         autoEquipItem.PackSlot, autoEquipItem.Slot);
 
     Item* srcItem  = _player->GetItemByPos(autoEquipItem.PackSlot, autoEquipItem.Slot);
     if (!srcItem)
         return;                                         // only at cheat
 
     uint16 dest;
     InventoryResult msg = _player->CanEquipItem(NULL_SLOT, dest, srcItem, !srcItem->IsBag());
     if (msg != EQUIP_ERR_OK)
     {
         _player->SendEquipError(msg, srcItem);
         return;
     }
 
     uint16 src = srcItem->GetPos();
     if (dest == src)                                    // prevent equip in same slot, only at cheat
         return;
 
     Item* dstItem = _player->GetItemByPos(dest);
     if (!dstItem)                                      // empty slot, simple case
     {
         _player->RemoveItem(autoEquipItem.PackSlot, autoEquipItem.Slot, true);
         _player->EquipItem(dest, srcItem, true);
         _player->AutoUnequipOffhandIfNeed();
     }
     else                                                    // have currently equipped item, not simple case
     {
         uint8 dstbag = dstItem->GetBagSlot();
         uint8 dstslot = dstItem->GetSlot();
 
         msg = _player->CanUnequipItem(dest, !srcItem->IsBag());
         if (msg != EQUIP_ERR_OK)
         {
             _player->SendEquipError(msg, dstItem);
             return;
         }
 
         // check dest->src move possibility
         ItemPosCountVec sSrc;
         uint16 eSrc = 0;
         if (_player->IsInventoryPos(src))
         {
             msg = _player->CanStoreItem(autoEquipItem.PackSlot, autoEquipItem.Slot, sSrc, dstItem, true);
             if (msg != EQUIP_ERR_OK)
                 msg = _player->CanStoreItem(autoEquipItem.PackSlot, NULL_SLOT, sSrc, dstItem, true);
             if (msg != EQUIP_ERR_OK)
                 msg = _player->CanStoreItem(NULL_BAG, NULL_SLOT, sSrc, dstItem, true);
         }
         else if (_player->IsBankPos(src))
         {
             msg = _player->CanBankItem(autoEquipItem.PackSlot, autoEquipItem.Slot, sSrc, dstItem, true);
             if (msg != EQUIP_ERR_OK)
                 msg = _player->CanBankItem(autoEquipItem.PackSlot, NULL_SLOT, sSrc, dstItem, true);
             if (msg != EQUIP_ERR_OK)
                 msg = _player->CanBankItem(NULL_BAG, NULL_SLOT, sSrc, dstItem, true);
         }
         else if (_player->IsEquipmentPos(src))
         {
             msg = _player->CanEquipItem(autoEquipItem.Slot, eSrc, dstItem, true);
             if (msg == EQUIP_ERR_OK)
                 msg = _player->CanUnequipItem(eSrc, true);
         }
 
         if (msg != EQUIP_ERR_OK)
         {
             _player->SendEquipError(msg, dstItem, srcItem);
             return;
         }
 
         // now do moves, remove...
         _player->RemoveItem(dstbag, dstslot, false);
         _player->RemoveItem(autoEquipItem.PackSlot, autoEquipItem.Slot, false);
 
         // add to dest
         _player->EquipItem(dest, srcItem, true);
 
         // add to src
         if (_player->IsInventoryPos(src))
             _player->StoreItem(sSrc, dstItem, true);
         else if (_player->IsBankPos(src))
             _player->BankItem(sSrc, dstItem, true);
         else if (_player->IsEquipmentPos(src))
             _player->EquipItem(eSrc, dstItem, true);
 
         _player->AutoUnequipOffhandIfNeed();
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     // cheating attempt, client should never send opcode in that case
     if (autoEquipItemSlot.Inv.Items.size() != 1 || !Player::IsEquipmentPos(INVENTORY_SLOT_BAG_0, autoEquipItemSlot.ItemDstSlot))
         return;
 
     Item* item = _player->GetItemByGuid(autoEquipItemSlot.Item);
     uint16 dstPos = autoEquipItemSlot.ItemDstSlot | (INVENTORY_SLOT_BAG_0 << 8);
     uint16 srcPos = autoEquipItemSlot.Inv.Items[0].Slot | (uint32(autoEquipItemSlot.Inv.Items[0].ContainerSlot) << 8);
 
     if (!item || item->GetPos() != srcPos || srcPos == dstPos)
         return;
 
     _player->SwapItem(srcPos, dstPos);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (!packet.Inv.Items.empty())
     {
         TC_LOG_ERROR("network", "HandleAutoStoreBagItemOpcode - Invalid itemCount (" SZFMTD ")", packet.Inv.Items.size());
         return;
     }
 
     TC_LOG_DEBUG("network", "HandleAutoStoreBagItemOpcode: receive ContainerSlotA: %u, SlotA: %u, ContainerSlotB: %u",
         packet.ContainerSlotA, packet.SlotA, packet.ContainerSlotB);
 
     Item* item = _player->GetItemByPos(packet.ContainerSlotA, packet.SlotA);
     if (!item)
         return;
 
     if (!_player->IsValidPos(packet.ContainerSlotB, NULL_SLOT, false))      // can be autostore pos
     {
         _player->SendEquipError(EQUIP_ERR_WRONG_SLOT);
         return;
     }
 
     uint16 src = item->GetPos();
 
     // check unequip potability for equipped items and bank bags
     if (_player->IsEquipmentPos(src) || _player->IsBagPos(src))
     {
         InventoryResult msg = _player->CanUnequipItem(src, !_player->IsBagPos(src));
         if (msg != EQUIP_ERR_OK)
         {
             _player->SendEquipError(msg, item);
             return;
         }
     }
 
     ItemPosCountVec dest;
     InventoryResult msg = _player->CanStoreItem(packet.ContainerSlotB, NULL_SLOT, dest, item, false);
     if (msg != EQUIP_ERR_OK)
     {
         _player->SendEquipError(msg, item);
         return;
     }
 
     // no-op: placed in same slot
     if (dest.size() == 1 && dest[0].pos == src)
     {
         // just remove grey item state
         _player->SendEquipError(EQUIP_ERR_INTERNAL_BAG_ERROR, item);
         return;
     }
 
     _player->RemoveItem(packet.ContainerSlotA, packet.SlotA, true);
     _player->StoreItem(dest, item, true);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     TC_LOG_DEBUG("network", "STORAGE: receive bag = %u, slot = %u", packet.Bag, packet.Slot);
 
     if (!CanUseBank())
     {
         TC_LOG_ERROR("network", "WORLD: HandleAutoStoreBankItemOpcode - Unit (%s) not found or you can't interact with him.", m_currentBankerGUID.ToString().c_str());
         return;
     }
 
     Item* item = _player->GetItemByPos(packet.Bag, packet.Slot);
     if (!item)
         return;
 
     if (_player->IsBankPos(packet.Bag, packet.Slot))                    // moving from bank to inventory
     {
         ItemPosCountVec dest;
         InventoryResult msg = _player->CanStoreItem(NULL_BAG, NULL_SLOT, dest, item, false);
         if (msg != EQUIP_ERR_OK)
         {
             _player->SendEquipError(msg, item, NULL);
             return;
         }
 
         _player->RemoveItem(packet.Bag, packet.Slot, true);
         if (Item const* storedItem = _player->StoreItem(dest, item, true))
             _player->ItemAddedQuestCheck(storedItem->GetEntry(), storedItem->GetCount());
 
     }
     else                                                                // moving from inventory to bank
     {
         ItemPosCountVec dest;
         InventoryResult msg = _player->CanBankItem(NULL_BAG, NULL_SLOT, dest, item, false);
         if (msg != EQUIP_ERR_OK)
         {
             _player->SendEquipError(msg, item, NULL);
             return;
         }
 
         _player->RemoveItem(packet.Bag, packet.Slot, true);
         _player->BankItem(dest, item, true);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Todo:: Implement looting by LootObject guid

 {
     Player* player = GetPlayer();
     ObjectGuid lguid = player->GetLootGUID();
 
     for (WorldPackets::Loot::LootRequest const& req : packet.Loot)
     {
         Loot* loot = NULL;
 
         if (lguid.IsGameObject())
         {
             GameObject* go = player->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, INTERACTION_DISTANCE)))
             {
                 player->SendLootRelease(lguid);
                 continue;
             }
 
             loot = &go->loot;
         }
         else if (lguid.IsItem())
         {
             Item* pItem = player->GetItemByGuid(lguid);
 
             if (!pItem)
             {
                 player->SendLootRelease(lguid);
                 continue;
             }
 
             loot = &pItem->loot;
         }
         else if (lguid.IsCorpse())
         {
             Corpse* bones = ObjectAccessor::GetCorpse(*player, lguid);
             if (!bones)
             {
                 player->SendLootRelease(lguid);
                 continue;
             }
 
             loot = &bones->loot;
         }
         else
         {
             Creature* creature = GetPlayer()->GetMap()->GetCreature(lguid);
 
             bool lootAllowed = creature && creature->IsAlive() == (player->getClass() == CLASS_ROGUE && creature->loot.loot_type == LOOT_PICKPOCKETING);
             if (!lootAllowed || !creature->IsWithinDistInMap(_player, INTERACTION_DISTANCE))
             {
                 player->SendLootError(lguid, lootAllowed ? LOOT_ERROR_TOO_FAR : LOOT_ERROR_DIDNT_KILL);
                 continue;
             }
 
             loot = &creature->loot;
         }
 
         // Since 6.x client sends loot starting from 1 hence the -1
         player->StoreLootItem(req.LootListID-1, loot);
 
         // If player is removing the last LootItem, delete the empty container.
         if (loot->isLooted() && lguid.IsItem())
             player->GetSession()->DoLootRelease(lguid);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     Creature* unit = GetPlayer()->GetNPCIfCanInteractWith(packet.Unit, UNIT_NPC_FLAG_BANKER);
     if (!unit)
     {
         TC_LOG_ERROR("network", "WORLD: HandleBankerActivateOpcode - %s not found or you can not interact with him.", packet.Unit.ToString().c_str());
         return;
     }
 
     // remove fake death
     if (GetPlayer()->HasUnitState(UNIT_STATE_DIED))
         GetPlayer()->RemoveAurasByType(SPELL_AURA_FEIGN_DEATH);
 
     // set currentBankerGUID for other bank action
 
     SendShowBank(packet.Unit);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     // not allow leave battleground in combat
     if (_player->IsInCombat())
         if (Battleground* bg = _player->GetBattleground())
             if (bg->GetStatus() != STATUS_WAIT_LEAVE)
                 return;
 
     _player->LeaveBattleground();
 }

Here is the caller graph for this function:

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

 {
     BattlemasterListEntry const* battlemasterListEntry = sBattlemasterListStore.LookupEntry(battlefieldList.ListID);
     if (!battlemasterListEntry)
     {
         TC_LOG_DEBUG("bg.battleground", "BattlegroundHandler: invalid bgtype (%u) with player (Name: %s, %s) received.", battlefieldList.ListID, _player->GetName().c_str(), _player->GetGUID().ToString().c_str());
         return;
     }
 
     sBattlegroundMgr->SendBattlegroundList(_player, ObjectGuid::Empty, BattlegroundTypeId(battlefieldList.ListID));
 }

Here is the caller graph for this function:

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

 {
     if (!_player->InBattlegroundQueue())
     {
         TC_LOG_DEBUG("bg.battleground", "CMSG_BATTLEFIELD_PORT %s Slot: %u, Unk: %u, Time: %u, AcceptedInvite: %u. Player not in queue!",
             GetPlayerInfo().c_str(), battlefieldPort.Ticket.Id, battlefieldPort.Ticket.Type, battlefieldPort.Ticket.Time, uint32(battlefieldPort.AcceptedInvite));
         return;
     }
 
     BattlegroundQueueTypeId bgQueueTypeId = _player->GetBattlegroundQueueTypeId(battlefieldPort.Ticket.Id);
     if (bgQueueTypeId == BATTLEGROUND_QUEUE_NONE)
     {
         TC_LOG_DEBUG("bg.battleground", "CMSG_BATTLEFIELD_PORT %s Slot: %u, Unk: %u, Time: %u, AcceptedInvite: %u. Invalid queueSlot!",
             GetPlayerInfo().c_str(), battlefieldPort.Ticket.Id, battlefieldPort.Ticket.Type, battlefieldPort.Ticket.Time, uint32(battlefieldPort.AcceptedInvite));
         return;
     }
 
     BattlegroundQueue& bgQueue = sBattlegroundMgr->GetBattlegroundQueue(bgQueueTypeId);
 
     //we must use temporary variable, because GroupQueueInfo pointer can be deleted in BattlegroundQueue::RemovePlayer() function
     GroupQueueInfo ginfo;
     if (!bgQueue.GetPlayerGroupInfoData(_player->GetGUID(), &ginfo))
     {
         TC_LOG_DEBUG("bg.battleground", "CMSG_BATTLEFIELD_PORT %s Slot: %u, Unk: %u, Time: %u, AcceptedInvite: %u. Player not in queue (No player Group Info)!",
             GetPlayerInfo().c_str(), battlefieldPort.Ticket.Id, battlefieldPort.Ticket.Type, battlefieldPort.Ticket.Time, uint32(battlefieldPort.AcceptedInvite));
         return;
     }
     // if action == 1, then player must have been invited to join
     if (!ginfo.IsInvitedToBGInstanceGUID && battlefieldPort.AcceptedInvite)
     {
         TC_LOG_DEBUG("bg.battleground", "CMSG_BATTLEFIELD_PORT %s Slot: %u, Unk: %u, Time: %u, AcceptedInvite: %u. Player is not invited to any bg!",
             GetPlayerInfo().c_str(), battlefieldPort.Ticket.Id, battlefieldPort.Ticket.Type, battlefieldPort.Ticket.Time, uint32(battlefieldPort.AcceptedInvite));
         return;
     }
 
     BattlegroundTypeId bgTypeId = BattlegroundMgr::BGTemplateId(bgQueueTypeId);
     // BGTemplateId returns BATTLEGROUND_AA when it is arena queue.
     // Do instance id search as there is no AA bg instances.
     Battleground* bg = sBattlegroundMgr->GetBattleground(ginfo.IsInvitedToBGInstanceGUID, bgTypeId == BATTLEGROUND_AA ? BATTLEGROUND_TYPE_NONE : bgTypeId);
     if (!bg)
     {
         if (battlefieldPort.AcceptedInvite)
         {
             TC_LOG_DEBUG("bg.battleground", "CMSG_BATTLEFIELD_PORT %s Slot: %u, Unk: %u, Time: %u, AcceptedInvite: %u. Cant find BG with id %u!",
                 GetPlayerInfo().c_str(), battlefieldPort.Ticket.Id, battlefieldPort.Ticket.Type, battlefieldPort.Ticket.Time, uint32(battlefieldPort.AcceptedInvite), ginfo.IsInvitedToBGInstanceGUID);
             return;
         }
 
         bg = sBattlegroundMgr->GetBattlegroundTemplate(bgTypeId);
         if (!bg)
         {
             TC_LOG_ERROR("network", "BattlegroundHandler: bg_template not found for type id %u.", bgTypeId);
             return;
         }
     }
 
     TC_LOG_DEBUG("bg.battleground", "CMSG_BATTLEFIELD_PORT %s Slot: %u, Unk: %u, Time: %u, AcceptedInvite: %u.",
         GetPlayerInfo().c_str(), battlefieldPort.Ticket.Id, battlefieldPort.Ticket.Type, battlefieldPort.Ticket.Time, uint32(battlefieldPort.AcceptedInvite));
 
     // get real bg type
     bgTypeId = bg->GetTypeID();
 
     // expected bracket entry
     PvPDifficultyEntry const* bracketEntry = GetBattlegroundBracketByLevel(bg->GetMapId(), _player->getLevel());
     if (!bracketEntry)
         return;
 
     //some checks if player isn't cheating - it is not exactly cheating, but we cannot allow it
     if (battlefieldPort.AcceptedInvite && ginfo.ArenaType == 0)
     {
         //if player is trying to enter battleground (not arena!) and he has deserter debuff, we must just remove him from queue
         if (!_player->CanJoinToBattleground(bg))
         {
             //send bg command result to show nice message
             WorldPackets::Battleground::BattlefieldStatusFailed battlefieldStatus;
             sBattlegroundMgr->BuildBattlegroundStatusFailed(&battlefieldStatus, bg, _player, battlefieldPort.Ticket.Id, 0, ERR_GROUP_JOIN_BATTLEGROUND_DESERTERS);
             SendPacket(battlefieldPort.Write());
             battlefieldPort.AcceptedInvite = false;
             TC_LOG_DEBUG("bg.battleground", "Player %s (%s) has a deserter debuff, do not port him to battleground!", _player->GetName().c_str(), _player->GetGUID().ToString().c_str());
         }
         //if player don't match battleground max level, then do not allow him to enter! (this might happen when player leveled up during his waiting in queue
         if (_player->getLevel() > bg->GetMaxLevel())
         {
             TC_LOG_DEBUG("network", "Player %s (%s) has level (%u) higher than maxlevel (%u) of battleground (%u)! Do not port him to battleground!",
                 _player->GetName().c_str(), _player->GetGUID().ToString().c_str(), _player->getLevel(), bg->GetMaxLevel(), bg->GetTypeID());
             battlefieldPort.AcceptedInvite = false;
         }
     }
 
     if (battlefieldPort.AcceptedInvite)
     {
         // check Freeze debuff
         if (_player->HasAura(9454))
             return;
 
         if (!_player->IsInvitedForBattlegroundQueueType(bgQueueTypeId))
             return;                                 // cheating?
 
         if (!_player->InBattleground())
             _player->SetBattlegroundEntryPoint();
 
         // resurrect the player
         if (!_player->IsAlive())
         {
             _player->ResurrectPlayer(1.0f);
             _player->SpawnCorpseBones();
         }
         // stop taxi flight at port
         if (_player->IsInFlight())
         {
             _player->GetMotionMaster()->MovementExpired();
             _player->CleanupAfterTaxiFlight();
         }
 
         WorldPackets::Battleground::BattlefieldStatusActive battlefieldStatus;
         sBattlegroundMgr->BuildBattlegroundStatusActive(&battlefieldStatus, bg, _player, battlefieldPort.Ticket.Id, _player->GetBattlegroundQueueJoinTime(bgQueueTypeId), bg->GetArenaType());
         SendPacket(battlefieldStatus.Write());
 
         // remove battleground queue status from BGmgr
         bgQueue.RemovePlayer(_player->GetGUID(), false);
         // this is still needed here if battleground "jumping" shouldn't add deserter debuff
         // also this is required to prevent stuck at old battleground after SetBattlegroundId set to new
         if (Battleground* currentBg = _player->GetBattleground())
             currentBg->RemovePlayerAtLeave(_player->GetGUID(), false, true);
 
         // set the destination instance id
         _player->SetBattlegroundId(bg->GetInstanceID(), bgTypeId);
         // set the destination team
         _player->SetBGTeam(ginfo.Team);
 
         // bg->HandleBeforeTeleportToBattleground(_player);
         sBattlegroundMgr->SendToBattleground(_player, ginfo.IsInvitedToBGInstanceGUID, bgTypeId);
         // add only in HandleMoveWorldPortAck()
         // bg->AddPlayer(_player, team);
         TC_LOG_DEBUG("bg.battleground", "Battleground: player %s (%s) joined battle for bg %u, bgtype %u, queue type %u.", _player->GetName().c_str(), _player->GetGUID().ToString().c_str(), bg->GetInstanceID(), bg->GetTypeID(), bgQueueTypeId);
     }
     else // leave queue
     {
         // if player leaves rated arena match before match start, it is counted as he played but he lost
         if (ginfo.IsRated && ginfo.IsInvitedToBGInstanceGUID)
         {
             ArenaTeam* at = sArenaTeamMgr->GetArenaTeamById(ginfo.Team);
             if (at)
             {
                 TC_LOG_DEBUG("bg.battleground", "UPDATING memberLost's personal arena rating for %s by opponents rating: %u, because he has left queue!", _player->GetGUID().ToString().c_str(), ginfo.OpponentsTeamRating);
                 at->MemberLost(_player, ginfo.OpponentsMatchmakerRating);
                 at->SaveToDB();
             }
         }
 
         WorldPackets::Battleground::BattlefieldStatusNone battlefieldStatus;
         battlefieldStatus.Ticket = battlefieldPort.Ticket;
         SendPacket(battlefieldStatus.Write());
 
         _player->RemoveBattlegroundQueueId(bgQueueTypeId);  // must be called this way, because if you move this call to queue->removeplayer, it causes bugs
         bgQueue.RemovePlayer(_player->GetGUID(), true);
         // player left queue, we should update it - do not update Arena Queue
         if (!ginfo.ArenaType)
             sBattlegroundMgr->ScheduleQueueUpdate(ginfo.ArenaMatchmakerRating, ginfo.ArenaType, bgQueueTypeId, bgTypeId, bracketEntry->GetBracketId());
 
         TC_LOG_DEBUG("bg.battleground", "Battleground: player %s (%s) left queue for bgtype %u, queue type %u.", _player->GetName().c_str(), _player->GetGUID().ToString().c_str(), bg->GetTypeID(), bgQueueTypeId);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     Creature* unit = GetPlayer()->GetMap()->GetCreature(hello.Unit);
     if (!unit)
         return;
 
     if (!unit->IsBattleMaster())                             // it's not battlemaster
         return;
 
     // Stop the npc if moving
     unit->StopMoving();
 
     BattlegroundTypeId bgTypeId = sBattlegroundMgr->GetBattleMasterBG(unit->GetEntry());
 
     if (!_player->GetBGAccessByLevel(bgTypeId))
     {
                                                             // temp, must be gossip message...
         SendNotification(LANG_YOUR_BG_LEVEL_REQ_ERROR);
         return;
     }
 
     sBattlegroundMgr->SendBattlegroundList(_player, hello.Unit, bgTypeId);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     // ignore if we already in BG or BG queue
     if (_player->InBattleground())
         return;
 
     uint8 arenatype = ArenaTeam::GetTypeBySlot(packet.TeamSizeIndex);
 
     //check existence
     Battleground* bg = sBattlegroundMgr->GetBattlegroundTemplate(BATTLEGROUND_AA);
     if (!bg)
     {
         TC_LOG_ERROR("network", "Battleground: template bg (all arenas) not found");
         return;
     }
 
     if (DisableMgr::IsDisabledFor(DISABLE_TYPE_BATTLEGROUND, BATTLEGROUND_AA, nullptr))
     {
         ChatHandler(this).PSendSysMessage(LANG_ARENA_DISABLED);
         return;
     }
 
     BattlegroundTypeId bgTypeId = bg->GetTypeID();
     BattlegroundQueueTypeId bgQueueTypeId = BattlegroundMgr::BGQueueTypeId(bgTypeId, arenatype);
     PvPDifficultyEntry const* bracketEntry = GetBattlegroundBracketByLevel(bg->GetMapId(), _player->getLevel());
     if (!bracketEntry)
         return;
 
     Group* grp = _player->GetGroup();
     // no group found, error
     if (!grp)
         return;
     if (grp->GetLeaderGUID() != _player->GetGUID())
         return;
 
     uint32 ateamId = _player->GetArenaTeamId(packet.TeamSizeIndex);
     // check real arenateam existence only here (if it was moved to group->CanJoin .. () then we would ahve to get it twice)
     ArenaTeam* at = sArenaTeamMgr->GetArenaTeamById(ateamId);
     if (!at)
     {
         _player->GetSession()->SendNotInArenaTeamPacket(arenatype);
         return;
     }
 
     // get the team rating for queuing
     uint32 arenaRating = at->GetRating();
     uint32 matchmakerRating = at->GetAverageMMR(grp);
     // the arenateam id must match for everyone in the group
 
     if (arenaRating <= 0)
         arenaRating = 1;
 
     BattlegroundQueue& bgQueue = sBattlegroundMgr->GetBattlegroundQueue(bgQueueTypeId);
 
     uint32 avgTime = 0;
     GroupQueueInfo* ginfo = nullptr;
 
     ObjectGuid errorGuid;
     GroupJoinBattlegroundResult err = grp->CanJoinBattlegroundQueue(bg, bgQueueTypeId, arenatype, arenatype, true, packet.TeamSizeIndex, errorGuid);
     if (!err)
     {
         TC_LOG_DEBUG("bg.battleground", "Battleground: arena team id %u, leader %s queued with matchmaker rating %u for type %u", _player->GetArenaTeamId(packet.TeamSizeIndex), _player->GetName().c_str(), matchmakerRating, arenatype);
 
         ginfo = bgQueue.AddGroup(_player, grp, bgTypeId, bracketEntry, arenatype, true, false, arenaRating, matchmakerRating, ateamId);
         avgTime = bgQueue.GetAverageQueueWaitTime(ginfo, bracketEntry->GetBracketId());
     }
 
     for (GroupReference* itr = grp->GetFirstMember(); itr != nullptr; itr = itr->next())
     {
         Player* member = itr->GetSource();
         if (!member)
             continue;
 
         if (err)
         {
             WorldPackets::Battleground::BattlefieldStatusFailed battlefieldStatus;
             sBattlegroundMgr->BuildBattlegroundStatusFailed(&battlefieldStatus, bg, _player, 0, arenatype, err, &errorGuid);
             member->SendDirectMessage(battlefieldStatus.Write());
             continue;
         }
 
         // add to queue
         uint32 queueSlot = member->AddBattlegroundQueueId(bgQueueTypeId);
 
         WorldPackets::Battleground::BattlefieldStatusQueued battlefieldStatus;
         sBattlegroundMgr->BuildBattlegroundStatusQueued(&battlefieldStatus, bg, member, queueSlot, ginfo->JoinTime, avgTime, arenatype, true);
         member->SendDirectMessage(battlefieldStatus.Write());
 
         TC_LOG_DEBUG("bg.battleground", "Battleground: player joined queue for arena as group bg queue type %u bg type %u, %s, NAME %s", bgQueueTypeId, bgTypeId, member->GetGUID().ToString().c_str(), member->GetName().c_str());
     }
 
     sBattlegroundMgr->ScheduleQueueUpdate(matchmakerRating, arenatype, bgQueueTypeId, bgTypeId, bracketEntry->GetBracketId());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     bool isPremade = false;
     Group* grp = NULL;
     uint32 bgTypeId_ = battlemasterJoin.QueueID & 0xFFFF;
     if (!sBattlemasterListStore.LookupEntry(bgTypeId_))
     {
         TC_LOG_ERROR("network", "Battleground: invalid bgtype (%u) received. possible cheater? %s", bgTypeId_, _player->GetGUID().ToString().c_str());
         return;
     }
 
     if (DisableMgr::IsDisabledFor(DISABLE_TYPE_BATTLEGROUND, bgTypeId_, NULL))
     {
         ChatHandler(this).PSendSysMessage(LANG_BG_DISABLED);
         return;
     }
 
     BattlegroundTypeId bgTypeId = BattlegroundTypeId(bgTypeId_);
 
     // can do this, since it's battleground, not arena
     BattlegroundQueueTypeId bgQueueTypeId = BattlegroundMgr::BGQueueTypeId(bgTypeId, 0);
     BattlegroundQueueTypeId bgQueueTypeIdRandom = BattlegroundMgr::BGQueueTypeId(BATTLEGROUND_RB, 0);
 
     // ignore if player is already in BG
     if (_player->InBattleground())
         return;
 
     // get bg instance or bg template if instance not found
     Battleground* bg = sBattlegroundMgr->GetBattlegroundTemplate(bgTypeId);
     if (!bg)
         return;
 
     // expected bracket entry
     PvPDifficultyEntry const* bracketEntry = GetBattlegroundBracketByLevel(bg->GetMapId(), _player->getLevel());
     if (!bracketEntry)
         return;
 
     GroupJoinBattlegroundResult err = ERR_BATTLEGROUND_NONE;
 
     // check queue conditions
     if (!battlemasterJoin.JoinAsGroup)
     {
         if (GetPlayer()->isUsingLfg())
         {
             WorldPackets::Battleground::BattlefieldStatusFailed battlefieldStatus;
             sBattlegroundMgr->BuildBattlegroundStatusFailed(&battlefieldStatus, bg, _player, 0, 0, ERR_LFG_CANT_USE_BATTLEGROUND);
             SendPacket(battlefieldStatus.Write());
             return;
         }
 
         // check Deserter debuff
         if (!_player->CanJoinToBattleground(bg))
         {
             WorldPackets::Battleground::BattlefieldStatusFailed battlefieldStatus;
             sBattlegroundMgr->BuildBattlegroundStatusFailed(&battlefieldStatus, bg, _player, 0, 0, ERR_GROUP_JOIN_BATTLEGROUND_DESERTERS);
             SendPacket(battlefieldStatus.Write());
             return;
         }
 
         if (_player->GetBattlegroundQueueIndex(bgQueueTypeIdRandom) < PLAYER_MAX_BATTLEGROUND_QUEUES)
         {
             // player is already in random queue
             WorldPackets::Battleground::BattlefieldStatusFailed battlefieldStatus;
             sBattlegroundMgr->BuildBattlegroundStatusFailed(&battlefieldStatus, bg, _player, 0, 0, ERR_IN_RANDOM_BG);
             SendPacket(battlefieldStatus.Write());
             return;
         }
 
         if (_player->InBattlegroundQueue() && bgTypeId == BATTLEGROUND_RB)
         {
             // player is already in queue, can't start random queue
             WorldPackets::Battleground::BattlefieldStatusFailed battlefieldStatus;
             sBattlegroundMgr->BuildBattlegroundStatusFailed(&battlefieldStatus, bg, _player, 0, 0, ERR_IN_NON_RANDOM_BG);
             SendPacket(battlefieldStatus.Write());
             return;
         }
 
         // check if already in queue
         if (_player->GetBattlegroundQueueIndex(bgQueueTypeId) < PLAYER_MAX_BATTLEGROUND_QUEUES)
             // player is already in this queue
             return;
 
         // check if has free queue slots
         if (!_player->HasFreeBattlegroundQueueId())
         {
             WorldPackets::Battleground::BattlefieldStatusFailed battlefieldStatus;
             sBattlegroundMgr->BuildBattlegroundStatusFailed(&battlefieldStatus, bg, _player, 0, 0, ERR_BATTLEGROUND_TOO_MANY_QUEUES);
             SendPacket(battlefieldStatus.Write());
             return;
         }
 
         // check Freeze debuff
         if (_player->HasAura(9454))
             return;
 
         BattlegroundQueue& bgQueue = sBattlegroundMgr->GetBattlegroundQueue(bgQueueTypeId);
         GroupQueueInfo* ginfo = bgQueue.AddGroup(_player, NULL, bgTypeId, bracketEntry, 0, false, isPremade, 0, 0);
 
         uint32 avgTime = bgQueue.GetAverageQueueWaitTime(ginfo, bracketEntry->GetBracketId());
         uint32 queueSlot = _player->AddBattlegroundQueueId(bgQueueTypeId);
 
         WorldPackets::Battleground::BattlefieldStatusQueued battlefieldStatus;
         sBattlegroundMgr->BuildBattlegroundStatusQueued(&battlefieldStatus, bg, _player, queueSlot, ginfo->JoinTime, avgTime, ginfo->ArenaType, false);
         SendPacket(battlefieldStatus.Write());
 
         TC_LOG_DEBUG("bg.battleground", "Battleground: player joined queue for bg queue type %u bg type %u, %s, NAME %s",
             bgQueueTypeId, bgTypeId, _player->GetGUID().ToString().c_str(), _player->GetName().c_str());
     }
     else
     {
         grp = _player->GetGroup();
 
         if (!grp)
             return;
 
         if (grp->GetLeaderGUID() != _player->GetGUID())
             return;
 
         ObjectGuid errorGuid;
         err = grp->CanJoinBattlegroundQueue(bg, bgQueueTypeId, 0, bg->GetMaxPlayersPerTeam(), false, 0, errorGuid);
         isPremade = (grp->GetMembersCount() >= bg->GetMinPlayersPerTeam());
 
         BattlegroundQueue& bgQueue = sBattlegroundMgr->GetBattlegroundQueue(bgQueueTypeId);
         GroupQueueInfo* ginfo = NULL;
         uint32 avgTime = 0;
 
         if (!err)
         {
             TC_LOG_DEBUG("bg.battleground", "Battleground: the following players are joining as group:");
             ginfo = bgQueue.AddGroup(_player, grp, bgTypeId, bracketEntry, 0, false, isPremade, 0, 0);
             avgTime = bgQueue.GetAverageQueueWaitTime(ginfo, bracketEntry->GetBracketId());
         }
 
         for (GroupReference* itr = grp->GetFirstMember(); itr != NULL; itr = itr->next())
         {
             Player* member = itr->GetSource();
             if (!member)
                 continue;   // this should never happen
 
             if (err)
             {
                 WorldPackets::Battleground::BattlefieldStatusFailed battlefieldStatus;
                 sBattlegroundMgr->BuildBattlegroundStatusFailed(&battlefieldStatus, bg, _player, 0, 0, err, &errorGuid);
                 member->SendDirectMessage(battlefieldStatus.Write());
                 continue;
             }
 
             // add to queue
             uint32 queueSlot = member->AddBattlegroundQueueId(bgQueueTypeId);
 
             WorldPackets::Battleground::BattlefieldStatusQueued battlefieldStatus;
             sBattlegroundMgr->BuildBattlegroundStatusQueued(&battlefieldStatus, bg, member, queueSlot, ginfo->JoinTime, avgTime, ginfo->ArenaType, true);
             member->SendDirectMessage(battlefieldStatus.Write());
             TC_LOG_DEBUG("bg.battleground", "Battleground: player joined queue for bg queue type %u bg type %u, %s, NAME %s",
                 bgQueueTypeId, bgTypeId, member->GetGUID().ToString().c_str(), member->GetName().c_str());
         }
         TC_LOG_DEBUG("bg.battleground", "Battleground: group end");
     }
 
     sBattlegroundMgr->ScheduleQueueUpdate(0, 0, bgQueueTypeId, bgTypeId, bracketEntry->GetBracketId());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     sServiceDispatcher.Dispatch(this, request.Method.GetServiceHash(), request.Method.Token, request.Method.GetMethodId(), std::move(request.Data));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleBattlenetRequestRealmListTicket ( WorldPackets::Battlenet::RequestRealmListTicket & requestRealmListTicket )

 {
     SetRealmListSecret(requestRealmListTicket.Secret);
 
     WorldPackets::Battlenet::RealmListTicket realmListTicket;
     realmListTicket.Token = requestRealmListTicket.Token;
     realmListTicket.Ticket << "WorldserverRealmListTicket";
 
     SendPacket(realmListTicket.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     GetBattlePetMgr()->RemovePet(battlePetDeletePet.PetGuid);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (BattlePetMgr::BattlePet* pet = GetBattlePetMgr()->GetPet(battlePetModifyName.PetGuid))
     {
         pet->PacketInfo.Name = battlePetModifyName.Name;
 
         if (pet->SaveInfo != BATTLE_PET_NEW)
             pet->SaveInfo = BATTLE_PET_CHANGED;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     // TODO: Move this to BattlePetMgr::SendJournal() just to have all packets in one file
     WorldPackets::BattlePet::BattlePetJournal battlePetJournal;
     battlePetJournal.Trap = GetBattlePetMgr()->GetTrapLevel();
 
     for (auto itr : GetBattlePetMgr()->GetLearnedPets())
         battlePetJournal.Pets.push_back(itr.PacketInfo);
 
     battlePetJournal.Slots = GetBattlePetMgr()->GetSlots();
     SendPacket(battlePetJournal.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (BattlePetMgr::BattlePet* pet = GetBattlePetMgr()->GetPet(battlePetSetBattleSlot.PetGuid))
         GetBattlePetMgr()->GetSlot(battlePetSetBattleSlot.Slot)->Pet = pet->PacketInfo;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (BattlePetMgr::BattlePet* pet = GetBattlePetMgr()->GetPet(battlePetSetFlags.PetGuid))
     {
         if (battlePetSetFlags.ControlType == 2) // 2 - apply
             pet->PacketInfo.Flags |= battlePetSetFlags.Flags;
         else                                    // 3 - remove
             pet->PacketInfo.Flags &= ~battlePetSetFlags.Flags;
 
         if (pet->SaveInfo != BATTLE_PET_NEW)
             pet->SaveInfo = BATTLE_PET_CHANGED;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     GetBattlePetMgr()->SummonPet(battlePetSummon.PetGuid);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     TradeData* my_trade = _player->m_trade;
     if (!my_trade)
         return;
 
     WorldPackets::Trade::TradeStatus info;
     info.Status = TRADE_STATUS_INITIATED;
     my_trade->GetTrader()->GetSession()->SendTradeStatus(info);
     SendTradeStatus(info);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleBfEntryInviteResponse ( WorldPackets::Battlefield::BFMgrEntryInviteResponse & bfMgrEntryInviteResponse )

Send by client on clicking in accept or refuse of invitation windows for join game.

 {
     Battlefield* bf = sBattlefieldMgr->GetBattlefieldByQueueId(bfMgrEntryInviteResponse.QueueID);
     if (!bf)
         return;
 
     // If player accept invitation
     if (bfMgrEntryInviteResponse.AcceptedInvite)
     {
         bf->PlayerAcceptInviteToWar(_player);
     }
     else
     {
         if (_player->GetZoneId() == bf->GetZoneId())
             bf->KickPlayerFromBattlefield(_player->GetGUID());
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleBfQueueExitRequest ( WorldPackets::Battlefield::BFMgrQueueExitRequest & bfMgrQueueExitRequest )

 {
     Battlefield* bf = sBattlefieldMgr->GetBattlefieldByQueueId(bfMgrQueueExitRequest.QueueID);
     if (!bf)
         return;
 
     bf->AskToLeaveQueue(_player);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleBfQueueInviteResponse ( WorldPackets::Battlefield::BFMgrQueueInviteResponse & bfMgrQueueInviteResponse )

Send by client when he click on accept for queue.

 {
     Battlefield* bf = sBattlefieldMgr->GetBattlefieldByQueueId(bfMgrQueueInviteResponse.QueueID);
     if (!bf)
         return;
 
     if (bfMgrQueueInviteResponse.AcceptedInvite)
         bf->PlayerAcceptInviteToQueue(_player);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (!GetPlayer()->IsInWorld() || !GetPlayer()->IsAlive())
         return;
 
     Creature* unit = GetPlayer()->GetNPCIfCanInteractWith(packet.Unit, UNIT_NPC_FLAG_INNKEEPER);
     if (!unit)
     {
         TC_LOG_DEBUG("network", "WORLD: HandleBinderActivateOpcode - %s not found or you can not interact with him.", packet.Unit.ToString().c_str());
         return;
     }
 
     // remove fake death
     if (GetPlayer()->HasUnitState(UNIT_STATE_DIED))
         GetPlayer()->RemoveAurasByType(SPELL_AURA_FEIGN_DEATH);
 
     SendBindPoint(unit);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleBlackMarketOpen ( WorldPackets::BlackMarket::BlackMarketOpen & packet )

 {
     Creature* unit = GetPlayer()->GetNPCIfCanInteractWith(packet.Guid, UNIT_NPC_FLAG_BLACK_MARKET);
     if (!unit)
     {
         TC_LOG_DEBUG("network", "WORLD: HandleBlackMarketHello - Unit (GUID: %s) not found or you can't interact with him.", packet.Guid.ToString().c_str());
         return;
     }
 
     // remove fake death
     if (GetPlayer()->HasUnitState(UNIT_STATE_DIED))
         GetPlayer()->RemoveAurasByType(SPELL_AURA_FEIGN_DEATH);
 
     SendBlackMarketOpenResult(packet.Guid, unit);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     // Note: There is no way to trigger this with standard UI except /script ReportBug("text")
     if (!sSupportMgr->GetBugSystemStatus())
         return;
 
     PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_BUG_REPORT);
     stmt->setString(0, bugReport.Text);
     stmt->setString(1, bugReport.DiagInfo);
     CharacterDatabase.Execute(stmt);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

47 {

48 }

Here is the caller graph for this function:

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

 {
     TC_LOG_DEBUG("network", "WORLD: Received CMSG_BUYBACK_ITEM: Vendor %s, Slot: %u", packet.VendorGUID.ToString().c_str(), packet.Slot);
 
     Creature* creature = GetPlayer()->GetNPCIfCanInteractWith(packet.VendorGUID, UNIT_NPC_FLAG_VENDOR);
     if (!creature)
     {
         TC_LOG_DEBUG("network", "WORLD: HandleBuybackItem - Unit (%s) not found or you can not interact with him.", packet.VendorGUID.ToString().c_str());
         _player->SendSellError(SELL_ERR_CANT_FIND_VENDOR, NULL, ObjectGuid::Empty);
         return;
     }
 
     // remove fake death
     if (GetPlayer()->HasUnitState(UNIT_STATE_DIED))
         GetPlayer()->RemoveAurasByType(SPELL_AURA_FEIGN_DEATH);
 
     Item* pItem = _player->GetItemFromBuyBackSlot(packet.Slot);
     if (pItem)
     {
         uint32 price = _player->GetUInt32Value(PLAYER_FIELD_BUYBACK_PRICE_1 + packet.Slot - BUYBACK_SLOT_START);
         if (!_player->HasEnoughMoney(uint64(price)))
         {
             _player->SendBuyError(BUY_ERR_NOT_ENOUGHT_MONEY, creature, pItem->GetEntry(), 0);
             return;
         }
 
         ItemPosCountVec dest;
         InventoryResult msg = _player->CanStoreItem(NULL_BAG, NULL_SLOT, dest, pItem, false);
         if (msg == EQUIP_ERR_OK)
         {
             _player->ModifyMoney(-(int32)price);
             _player->RemoveItemFromBuyBackSlot(packet.Slot, false);
             _player->ItemAddedQuestCheck(pItem->GetEntry(), pItem->GetCount());
             _player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_RECEIVE_EPIC_ITEM, pItem->GetEntry(), pItem->GetCount());
             _player->StoreItem(dest, pItem, true);
         }
         else
             _player->SendEquipError(msg, pItem, NULL);
         return;
     }
     else
         _player->SendBuyError(BUY_ERR_CANT_FIND_ITEM, creature, 0, 0);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     WorldPacket data(SMSG_BUY_BANK_SLOT_RESULT, 4);
     if (!CanUseBank(packet.Guid))
     {
         data << uint32(ERR_BANKSLOT_NOTBANKER);
         SendPacket(&data);
         TC_LOG_ERROR("network", "WORLD: HandleBuyBankSlotOpcode - %s not found or you can't interact with him.", packet.Guid.ToString().c_str());
         return;
     }
 
     uint32 slot = _player->GetBankBagSlotCount();
 
     // next slot
     ++slot;
 
     TC_LOG_INFO("network", "PLAYER: Buy bank bag slot, slot number = %u", slot);
 
     BankBagSlotPricesEntry const* slotEntry = sBankBagSlotPricesStore.LookupEntry(slot);
 
     if (!slotEntry)
     {
         data << uint32(ERR_BANKSLOT_FAILED_TOO_MANY);
         SendPacket(&data);
         return;
     }
 
     uint32 price = slotEntry->Cost;
 
     if (!_player->HasEnoughMoney(uint64(price)))
     {
         data << uint32(ERR_BANKSLOT_INSUFFICIENT_FUNDS);
         SendPacket(&data);
         return;
     }
 
     _player->SetBankBagSlotCount(slot);
     _player->ModifyMoney(-int64(price));
 
      data << uint32(ERR_BANKSLOT_OK);
      SendPacket(&data);
 
     _player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_BUY_BANK_SLOT);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     // client expects count starting at 1, and we send vendorslot+1 to client already
     if (packet.Muid > 0)
         --packet.Muid;
     else
         return; // cheating
 
     switch (packet.ItemType)
     {
         case ITEM_VENDOR_TYPE_ITEM:
         {
             Item* bagItem = _player->GetItemByGuid(packet.ContainerGUID);
 
             uint8 bag = NULL_BAG;
             if (bagItem && bagItem->IsBag())
                 bag = bagItem->GetSlot();
             else if (packet.ContainerGUID == GetPlayer()->GetGUID()) // The client sends the player guid when trying to store an item in the default backpack
                 bag = INVENTORY_SLOT_BAG_0;
 
             GetPlayer()->BuyItemFromVendorSlot(packet.VendorGUID, packet.Muid, packet.Item.ItemID,
                 packet.Quantity, bag, packet.Slot);
             break;
         }
         case ITEM_VENDOR_TYPE_CURRENCY:
         {
             GetPlayer()->BuyCurrencyFromVendorSlot(packet.VendorGUID, packet.Muid, packet.Item.ItemID, packet.Quantity);
             break;
         }
         default:
         {
             TC_LOG_DEBUG("network", "WORLD: received wrong itemType (%u) in HandleBuyItemOpcode", packet.ItemType);
             break;
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleBuyStableSlot ( WorldPacket & recvPacket )

 {
     ObjectGuid npcGUID;
 
     recvData >> npcGUID;
 
     if (!CheckStableMaster(npcGUID))
     {
         SendPetStableResult(STABLE_ERR_STABLE);
         return;
     }
 
     // remove fake death
     if (GetPlayer()->HasUnitState(UNIT_STATE_DIED))
         GetPlayer()->RemoveAurasByType(SPELL_AURA_FEIGN_DEATH);
 
     if (GetPlayer()->m_stableSlots < MAX_PET_STABLES)
     {
         /*StableSlotPricesEntry const* SlotPrice = sStableSlotPricesStore.LookupEntry(GetPlayer()->m_stableSlots+1);
         if (_player->HasEnoughMoney(SlotPrice->Price))
         {
             ++GetPlayer()->m_stableSlots;
             _player->ModifyMoney(-int32(SlotPrice->Price));
             SendPetStableResult(STABLE_SUCCESS_BUY_SLOT);
         }
         else
             SendPetStableResult(STABLE_ERR_MONEY);*/
     }
     else
         SendPetStableResult(STABLE_ERR_STABLE);
 }

Here is the call graph for this function:

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

 {
     GetBattlePetMgr()->CageBattlePet(cageBattlePet.PetGuid);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     ObjectGuid guid = _player->GetGUID();
 
     // prevent events in the past
     // To Do: properly handle timezones and remove the "- time_t(86400L)" hack
     if (calendarAddEvent.EventInfo.Time < (time(NULL) - time_t(86400L)))
         return;
 
     CalendarEvent* calendarEvent = new CalendarEvent(sCalendarMgr->GetFreeEventId(), guid, UI64LIT(0), CalendarEventType(calendarAddEvent.EventInfo.EventType), calendarAddEvent.EventInfo.TextureID,
         calendarAddEvent.EventInfo.Time, calendarAddEvent.EventInfo.Flags, calendarAddEvent.EventInfo.Title, calendarAddEvent.EventInfo.Description, time_t(0));
 
     if (calendarEvent->IsGuildEvent() || calendarEvent->IsGuildAnnouncement())
         if (Player* creator = ObjectAccessor::FindPlayer(guid))
             calendarEvent->SetGuildId(creator->GetGuildId());
 
     if (calendarEvent->IsGuildAnnouncement())
     {
         CalendarInvite invite(0, calendarEvent->GetEventId(), ObjectGuid::Empty, guid, CALENDAR_DEFAULT_RESPONSE_TIME, CALENDAR_STATUS_NOT_SIGNED_UP, CALENDAR_RANK_PLAYER, "");
         // WARNING: By passing pointer to a local variable, the underlying method(s) must NOT perform any kind
         // of storage of the pointer as it will lead to memory corruption
         sCalendarMgr->AddInvite(calendarEvent, &invite);
     }
     else
     {
         SQLTransaction trans;
         if (calendarAddEvent.EventInfo.Invites.size() > 1)
             trans = CharacterDatabase.BeginTransaction();
 
         for (uint32 i = 0; i < calendarAddEvent.EventInfo.Invites.size(); ++i)
         {
             CalendarInvite* invite = new CalendarInvite(sCalendarMgr->GetFreeInviteId(), calendarEvent->GetEventId(), calendarAddEvent.EventInfo.Invites[i].Guid,
                 guid, CALENDAR_DEFAULT_RESPONSE_TIME, CalendarInviteStatus(calendarAddEvent.EventInfo.Invites[i].Status),
                 CalendarModerationRank(calendarAddEvent.EventInfo.Invites[i].Moderator), "");
             sCalendarMgr->AddInvite(calendarEvent, invite, trans);
         }
 
         if (calendarAddEvent.EventInfo.Invites.size() > 1)
             CharacterDatabase.CommitTransaction(trans);
     }
 
     sCalendarMgr->AddEvent(calendarEvent, CALENDAR_SENDTYPE_ADD);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     ObjectGuid guid = _player->GetGUID();
     TC_LOG_DEBUG("network", "CMSG_CALENDAR_COMPLAIN [%s] EventId ["
         UI64FMTD "] guid [%s] InviteId [" UI64FMTD "]", guid.ToString().c_str(), calendarComplain.EventID,
         calendarComplain.InvitedByGUID.ToString().c_str(), calendarComplain.InviteID);
 
     // what to do with complains?
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     ObjectGuid guid = _player->GetGUID();
 
     // prevent events in the past
     // To Do: properly handle timezones and remove the "- time_t(86400L)" hack
     if (calendarCopyEvent.Date < (time(NULL) - time_t(86400L)))
         return;
 
     if (CalendarEvent* oldEvent = sCalendarMgr->GetEvent(calendarCopyEvent.EventID))
     {
         CalendarEvent* newEvent = new CalendarEvent(*oldEvent, sCalendarMgr->GetFreeEventId());
         newEvent->SetDate(calendarCopyEvent.Date);
         sCalendarMgr->AddEvent(newEvent, CALENDAR_SENDTYPE_COPY);
 
         CalendarInviteStore invites = sCalendarMgr->GetEventInvites(calendarCopyEvent.EventID);
         SQLTransaction trans;
         if (invites.size() > 1)
             trans = CharacterDatabase.BeginTransaction();
 
         for (CalendarInviteStore::const_iterator itr = invites.begin(); itr != invites.end(); ++itr)
             sCalendarMgr->AddInvite(newEvent, new CalendarInvite(**itr, sCalendarMgr->GetFreeInviteId(), newEvent->GetEventId()), trans);
 
         if (invites.size() > 1)
             CharacterDatabase.CommitTransaction(trans);
         // Should we change owner when somebody makes a copy of event owned by another person?
     }
     else
         sCalendarMgr->SendCalendarCommandResult(guid, CALENDAR_ERROR_EVENT_INVALID);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleCalendarEventInvite ( WorldPackets::Calendar::CalendarEventInvite & calendarEventInvite )

 {
     ObjectGuid playerGuid = _player->GetGUID();
 
     ObjectGuid inviteeGuid;
     uint32 inviteeTeam = 0;
     ObjectGuid::LowType inviteeGuildId = UI64LIT(0);
 
     if (Player* player = ObjectAccessor::FindConnectedPlayerByName(calendarEventInvite.Name))
     {
         // Invitee is online
         inviteeGuid = player->GetGUID();
         inviteeTeam = player->GetTeam();
         inviteeGuildId = player->GetGuildId();
     }
     else
     {
         // Invitee offline, get data from database
         PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_GUID_RACE_ACC_BY_NAME);
         stmt->setString(0, calendarEventInvite.Name);
         if (PreparedQueryResult result = CharacterDatabase.Query(stmt))
         {
             Field* fields = result->Fetch();
             inviteeGuid = ObjectGuid::Create<HighGuid::Player>(fields[0].GetUInt64());
             inviteeTeam = Player::TeamForRace(fields[1].GetUInt8());
             inviteeGuildId = Player::GetGuildIdFromDB(inviteeGuid);
         }
     }
 
     if (!inviteeGuid)
     {
         sCalendarMgr->SendCalendarCommandResult(playerGuid, CALENDAR_ERROR_PLAYER_NOT_FOUND);
         return;
     }
 
     if (_player->GetTeam() != inviteeTeam && !sWorld->getBoolConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_CALENDAR))
     {
         sCalendarMgr->SendCalendarCommandResult(playerGuid, CALENDAR_ERROR_NOT_ALLIED);
         return;
     }
 
     if (QueryResult result = CharacterDatabase.PQuery("SELECT flags FROM character_social WHERE guid = %u AND friend = %u", inviteeGuid.GetCounter(), playerGuid.GetCounter()))
     {
         Field* fields = result->Fetch();
         if (fields[0].GetUInt8() & SOCIAL_FLAG_IGNORED)
         {
             sCalendarMgr->SendCalendarCommandResult(playerGuid, CALENDAR_ERROR_IGNORING_YOU_S, calendarEventInvite.Name.c_str());
             return;
         }
     }
 
     if (!calendarEventInvite.Creating)
     {
         if (CalendarEvent* calendarEvent = sCalendarMgr->GetEvent(calendarEventInvite.EventID))
         {
             if (calendarEvent->IsGuildEvent() && calendarEvent->GetGuildId() == inviteeGuildId)
             {
                 // we can't invite guild members to guild events
                 sCalendarMgr->SendCalendarCommandResult(playerGuid, CALENDAR_ERROR_NO_GUILD_INVITES);
                 return;
             }
 
             CalendarInvite* invite = new CalendarInvite(sCalendarMgr->GetFreeInviteId(), calendarEventInvite.EventID, inviteeGuid, playerGuid, CALENDAR_DEFAULT_RESPONSE_TIME, CALENDAR_STATUS_INVITED, CALENDAR_RANK_PLAYER, "");
             sCalendarMgr->AddInvite(calendarEvent, invite);
         }
         else
             sCalendarMgr->SendCalendarCommandResult(playerGuid, CALENDAR_ERROR_EVENT_INVALID);
     }
     else
     {
         if (calendarEventInvite.IsSignUp && inviteeGuildId == _player->GetGuildId())
         {
             sCalendarMgr->SendCalendarCommandResult(playerGuid, CALENDAR_ERROR_NO_GUILD_INVITES);
             return;
         }
 
         CalendarInvite invite(sCalendarMgr->GetFreeInviteId(), 0L, inviteeGuid, playerGuid, CALENDAR_DEFAULT_RESPONSE_TIME, CALENDAR_STATUS_INVITED, CALENDAR_RANK_PLAYER, "");
         sCalendarMgr->SendCalendarEventInvite(invite);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleCalendarEventModeratorStatus ( WorldPackets::Calendar::CalendarEventModeratorStatus & calendarEventModeratorStatus )

 {
     ObjectGuid guid = _player->GetGUID();
 
     TC_LOG_DEBUG("network", "CMSG_CALENDAR_EVENT_MODERATOR_STATUS [%s] EventID ["
         UI64FMTD "] ModeratorID [" UI64FMTD "], Invitee ([%s] InviteID: ["
         UI64FMTD "], Status %u", guid.ToString().c_str(), calendarEventModeratorStatus.EventID, calendarEventModeratorStatus.ModeratorID, calendarEventModeratorStatus.Guid.ToString().c_str(), calendarEventModeratorStatus.InviteID, calendarEventModeratorStatus.Status);
 
     if (CalendarEvent* calendarEvent = sCalendarMgr->GetEvent(calendarEventModeratorStatus.EventID))
     {
         if (CalendarInvite* invite = sCalendarMgr->GetInvite(calendarEventModeratorStatus.InviteID))
         {
             invite->SetRank(CalendarModerationRank(calendarEventModeratorStatus.Status));
             sCalendarMgr->UpdateInvite(invite);
             sCalendarMgr->SendCalendarEventModeratorStatusAlert(*calendarEvent, *invite);
         }
         else
             sCalendarMgr->SendCalendarCommandResult(guid, CALENDAR_ERROR_NO_INVITE); // correct?
     }
     else
         sCalendarMgr->SendCalendarCommandResult(guid, CALENDAR_ERROR_EVENT_INVALID);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     ObjectGuid guid = _player->GetGUID();
 
     TC_LOG_DEBUG("network", "CMSG_CALENDAR_REMOVE_INVITE [%s] EventId [" UI64FMTD
         "], ownerInviteId [" UI64FMTD "], Invitee ([%s] id: [" UI64FMTD "])",
         guid.ToString().c_str(), calendarRemoveInvite.EventID, calendarRemoveInvite.ModeratorID, calendarRemoveInvite.Guid.ToString().c_str(), calendarRemoveInvite.InviteID);
 
     if (CalendarEvent* calendarEvent = sCalendarMgr->GetEvent(calendarRemoveInvite.EventID))
     {
         if (calendarEvent->GetOwnerGUID() == calendarRemoveInvite.Guid)
         {
             sCalendarMgr->SendCalendarCommandResult(guid, CALENDAR_ERROR_DELETE_CREATOR_FAILED);
             return;
         }
 
         sCalendarMgr->RemoveInvite(calendarRemoveInvite.InviteID, calendarRemoveInvite.EventID, guid);
     }
     else
         sCalendarMgr->SendCalendarCommandResult(guid, CALENDAR_ERROR_NO_INVITE);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleCalendarEventRsvp ( WorldPackets::Calendar::CalendarEventRSVP & calendarEventRSVP )

 {
     ObjectGuid guid = _player->GetGUID();
 
     if (CalendarEvent* calendarEvent = sCalendarMgr->GetEvent(calendarEventRSVP.EventID))
     {
         // I think we still should be able to remove self from locked events
         if (calendarEventRSVP.Status != CALENDAR_STATUS_REMOVED && calendarEvent->IsLocked())
         {
             sCalendarMgr->SendCalendarCommandResult(guid, CALENDAR_ERROR_EVENT_LOCKED);
             return;
         }
 
         if (CalendarInvite* invite = sCalendarMgr->GetInvite(calendarEventRSVP.InviteID))
         {
             invite->SetStatus(CalendarInviteStatus(calendarEventRSVP.Status));
             invite->SetResponseTime(time(NULL));
 
             sCalendarMgr->UpdateInvite(invite);
             sCalendarMgr->SendCalendarEventStatus(*calendarEvent, *invite);
             sCalendarMgr->SendCalendarClearPendingAction(guid);
         }
         else
             sCalendarMgr->SendCalendarCommandResult(guid, CALENDAR_ERROR_NO_INVITE); // correct?
     }
     else
         sCalendarMgr->SendCalendarCommandResult(guid, CALENDAR_ERROR_EVENT_INVALID);
 }

Here is the caller graph for this function:

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

 {
     ObjectGuid guid = _player->GetGUID();
 
     TC_LOG_DEBUG("network", "CMSG_CALENDAR_EVENT_SIGNUP [%s] EventId [" UI64FMTD "] Tentative %u", guid.ToString().c_str(), calendarEventSignUp.EventID, calendarEventSignUp.Tentative);
 
     if (CalendarEvent* calendarEvent = sCalendarMgr->GetEvent(calendarEventSignUp.EventID))
     {
         if (calendarEvent->IsGuildEvent() && calendarEvent->GetGuildId() != _player->GetGuildId())
         {
             sCalendarMgr->SendCalendarCommandResult(guid, CALENDAR_ERROR_GUILD_PLAYER_NOT_IN_GUILD);
             return;
         }
 
         CalendarInviteStatus status = calendarEventSignUp.Tentative ? CALENDAR_STATUS_TENTATIVE : CALENDAR_STATUS_SIGNED_UP;
         CalendarInvite* invite = new CalendarInvite(sCalendarMgr->GetFreeInviteId(), calendarEventSignUp.EventID, guid, guid, time(NULL), status, CALENDAR_RANK_PLAYER, "");
         sCalendarMgr->AddInvite(calendarEvent, invite);
         sCalendarMgr->SendCalendarClearPendingAction(guid);
     }
     else
         sCalendarMgr->SendCalendarCommandResult(guid, CALENDAR_ERROR_EVENT_INVALID);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleCalendarEventStatus ( WorldPackets::Calendar::CalendarEventStatus & calendarEventStatus )

 {
     ObjectGuid guid = _player->GetGUID();
 
     TC_LOG_DEBUG("network", "CMSG_CALENDAR_EVENT_STATUS [%s] EventId ["
         UI64FMTD "] ownerInviteId [" UI64FMTD "], Invitee ([%s] id: ["
         UI64FMTD "], status %u", guid.ToString().c_str(), calendarEventStatus.EventID, calendarEventStatus.ModeratorID, calendarEventStatus.Guid.ToString().c_str(), calendarEventStatus.InviteID, calendarEventStatus.Status);
 
     if (CalendarEvent* calendarEvent = sCalendarMgr->GetEvent(calendarEventStatus.EventID))
     {
         if (CalendarInvite* invite = sCalendarMgr->GetInvite(calendarEventStatus.InviteID))
         {
             invite->SetStatus((CalendarInviteStatus)calendarEventStatus.Status);
 
             sCalendarMgr->UpdateInvite(invite);
             sCalendarMgr->SendCalendarEventStatus(*calendarEvent, *invite);
             sCalendarMgr->SendCalendarClearPendingAction(calendarEventStatus.Guid);
         }
         else
             sCalendarMgr->SendCalendarCommandResult(guid, CALENDAR_ERROR_NO_INVITE); // correct?
     }
     else
         sCalendarMgr->SendCalendarCommandResult(guid, CALENDAR_ERROR_EVENT_INVALID);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     ObjectGuid guid = _player->GetGUID();
     time_t currTime = time(NULL);
 
     WorldPackets::Calendar::CalendarSendCalendar packet;
     packet.ServerNow = currTime;
     packet.RaidOrigin = 1135753200; // Constant date, unk (28.12.2005 07:00)
     packet.ServerTime = currTime;
 
     CalendarInviteStore playerInvites = sCalendarMgr->GetPlayerInvites(guid);
     for (auto const& invite : playerInvites)
     {
         WorldPackets::Calendar::CalendarSendCalendarInviteInfo inviteInfo;
         inviteInfo.EventID = invite->GetEventId();
         inviteInfo.InviteID = invite->GetInviteId();
         inviteInfo.InviterGuid = invite->GetSenderGUID();
         inviteInfo.Status = invite->GetStatus();
         inviteInfo.Moderator = invite->GetRank();
         if (CalendarEvent* calendarEvent = sCalendarMgr->GetEvent(invite->GetEventId()))
             inviteInfo.InviteType = calendarEvent->IsGuildEvent() && calendarEvent->GetGuildId() == _player->GetGuildId();
 
         packet.Invites.push_back(inviteInfo);
     }
 
     CalendarEventStore playerEvents = sCalendarMgr->GetPlayerEvents(guid);
     for (auto const& event : playerEvents)
     {
         WorldPackets::Calendar::CalendarSendCalendarEventInfo eventInfo;
         eventInfo.EventID = event->GetEventId();
         eventInfo.Date = event->GetDate();
         Guild* guild = sGuildMgr->GetGuildById(event->GetGuildId());
         eventInfo.EventGuildID = guild ? guild->GetGUID() : ObjectGuid::Empty;
         eventInfo.EventName = event->GetTitle();
         eventInfo.EventType = event->GetType();
         eventInfo.Flags = event->GetFlags();
         eventInfo.OwnerGuid = event->GetOwnerGUID();
         eventInfo.TextureID = event->GetTextureId();
 
         packet.Events.push_back(eventInfo);
     }
 
     for (uint8 i = 0; i < MAX_DIFFICULTY; ++i)
     {
         Player::BoundInstancesMap boundInstances = _player->GetBoundInstances(Difficulty(i));
         for (auto const& boundInstance : boundInstances)
         {
             if (boundInstance.second.perm)
             {
                 WorldPackets::Calendar::CalendarSendCalendarRaidLockoutInfo lockoutInfo;
 
                 InstanceSave const* save = boundInstance.second.save;
                 lockoutInfo.MapID = save->GetMapId();
                 lockoutInfo.DifficultyID = save->GetDifficultyID();
                 lockoutInfo.ExpireTime = save->GetResetTime() - currTime;
                 lockoutInfo.InstanceID = save->GetInstanceId(); // instance save id as unique instance copy id
 
                 packet.RaidLockouts.push_back(lockoutInfo);
             }
         }
     }
 
     std::set<uint32> sentMaps;
     ResetTimeByMapDifficultyMap const& resets = sInstanceSaveMgr->GetResetTimeMap();
     for (auto const& reset : resets)
     {
         uint32 mapID = PAIR64_LOPART(reset.first);
         if (sentMaps.find(mapID) != sentMaps.end())
             continue;
 
         MapEntry const* mapEntry = sMapStore.LookupEntry(mapID);
         if (!mapEntry || !mapEntry->IsRaid())
             continue;
 
         sentMaps.insert(mapID);
         WorldPackets::Calendar::CalendarSendCalendarRaidResetInfo resetInfo;
         resetInfo.MapID = mapID;
         resetInfo.Duration = reset.second - currTime;
         resetInfo.Offset = 0; // Never seen anything else in sniffs - still unknown
 
         packet.RaidResets.push_back(resetInfo);
     }
 
     SendPacket(packet.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (CalendarEvent* calendarEvent = sCalendarMgr->GetEvent(calendarGetEvent.EventID))
         sCalendarMgr->SendCalendarEvent(_player->GetGUID(), *calendarEvent, CALENDAR_SENDTYPE_GET);
     else
         sCalendarMgr->SendCalendarCommandResult(_player->GetGUID(), CALENDAR_ERROR_EVENT_INVALID);
 }

Here is the caller graph for this function:

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

 {
     ObjectGuid guid = _player->GetGUID();
     uint32 pending = sCalendarMgr->GetPlayerNumPending(guid);
 
     TC_LOG_DEBUG("network", "CMSG_CALENDAR_GET_NUM_PENDING: [%s] Pending: %u", guid.ToString().c_str(), pending);
 
     SendPacket(WorldPackets::Calendar::CalendarSendNumPending(pending).Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleCalendarGuildFilter ( WorldPackets::Calendar::CalendarGuildFilter & calendarGuildFilter )

 {
     if (Guild* guild = sGuildMgr->GetGuildById(_player->GetGuildId()))
         guild->MassInviteToEvent(this, calendarGuildFilter.MinLevel, calendarGuildFilter.MaxLevel, calendarGuildFilter.MaxRankOrder);
 }

Here is the caller graph for this function:

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

 {
     ObjectGuid guid = _player->GetGUID();
     sCalendarMgr->RemoveEvent(calendarRemoveEvent.EventID, guid);
 }

Here is the caller graph for this function:

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

 {
     ObjectGuid guid = _player->GetGUID();
     time_t oldEventTime = time_t(0);
 
     // prevent events in the past
     // To Do: properly handle timezones and remove the "- time_t(86400L)" hack
     if (calendarUpdateEvent.EventInfo.Time < (time(NULL) - time_t(86400L)))
         return;
 
     if (CalendarEvent* calendarEvent = sCalendarMgr->GetEvent(calendarUpdateEvent.EventInfo.EventID))
     {
         oldEventTime = calendarEvent->GetDate();
 
         calendarEvent->SetType(CalendarEventType(calendarUpdateEvent.EventInfo.EventType));
         calendarEvent->SetFlags(calendarUpdateEvent.EventInfo.Flags);
         calendarEvent->SetDate(calendarUpdateEvent.EventInfo.Time);
         calendarEvent->SetTextureId(calendarUpdateEvent.EventInfo.TextureID);
         calendarEvent->SetTitle(calendarUpdateEvent.EventInfo.Title);
         calendarEvent->SetDescription(calendarUpdateEvent.EventInfo.Description);
 
         sCalendarMgr->UpdateEvent(calendarEvent);
         sCalendarMgr->SendCalendarEventUpdateAlert(*calendarEvent, oldEventTime);
     }
     else
         sCalendarMgr->SendCalendarCommandResult(guid, CALENDAR_ERROR_EVENT_INVALID);
 }

Here is the caller graph for this function:

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

 {
     SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(cancelAura.SpellID);
     if (!spellInfo)
         return;
 
     // not allow remove spells with attr SPELL_ATTR0_CANT_CANCEL
     if (spellInfo->HasAttribute(SPELL_ATTR0_CANT_CANCEL))
         return;
 
     // channeled spell case (it currently cast then)
     if (spellInfo->IsChanneled())
     {
         if (Spell* curSpell = _player->GetCurrentSpell(CURRENT_CHANNELED_SPELL))
             if (curSpell->GetSpellInfo()->Id == uint32(cancelAura.SpellID))
                 _player->InterruptSpell(CURRENT_CHANNELED_SPELL);
         return;
     }
 
     // non channeled case:
     // don't allow remove non positive spells
     // don't allow cancelling passive auras (some of them are visible)
     if (!spellInfo->IsPositive() || spellInfo->IsPassive())
         return;
 
     _player->RemoveOwnedAura(cancelAura.SpellID, cancelAura.CasterGUID, 0, AURA_REMOVE_BY_CANCEL);
 
     // If spell being removed is a resource tracker, see if player was tracking both (herbs / minerals) and remove the other
     if (sWorld->getBoolConfig(CONFIG_ALLOW_TRACK_BOTH_RESOURCES) && spellInfo->HasAura(DIFFICULTY_NONE, SPELL_AURA_TRACK_RESOURCES))
     {
         Unit::AuraEffectList const& auraEffects = _player->GetAuraEffectsByType(SPELL_AURA_TRACK_RESOURCES);
         if (!auraEffects.empty())
         {
             // Build list of spell IDs to cancel. Trying to cancel the aura while iterating
             //  over AuraEffectList caused "incompatible iterator" errors on second pass
             std::list<uint32> spellIDs;
 
             for (Unit::AuraEffectList::const_iterator auraEffect = auraEffects.begin(); auraEffect != auraEffects.end(); ++auraEffect)
                 spellIDs.push_back((*auraEffect)->GetId());
 
             // Remove all auras related to resource tracking (only Herbs and Minerals in 3.3.5a)
             for (std::list<uint32>::iterator it = spellIDs.begin(); it != spellIDs.end(); ++it)
                 _player->RemoveOwnedAura(*it, cancelAura.CasterGUID, 0, AURA_REMOVE_BY_CANCEL);
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     // may be better send SMSG_CANCEL_AUTO_REPEAT?
     // cancel and prepare for deleting
     _player->InterruptSpell(CURRENT_AUTOREPEAT_SPELL);
 }

Here is the caller graph for this function:

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

 {
     if (_player->IsNonMeleeSpellCast(false))
         _player->InterruptNonMeleeSpells(false, packet.SpellID, false);
 }

Here is the caller graph for this function:

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

 {
     // ignore for remote control state (for player case)
     Unit* mover = _player->m_mover;
     if (mover != _player && mover->GetTypeId() == TYPEID_PLAYER)
         return;
 
     mover->InterruptSpell(CURRENT_CHANNELED_SPELL);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     _player->RemoveAurasByType(SPELL_AURA_MOD_SCALE, [](AuraApplication const* aurApp)
     {
         SpellInfo const* spellInfo = aurApp->GetBase()->GetSpellInfo();
         return !spellInfo->HasAttribute(SPELL_ATTR0_CANT_CANCEL) && spellInfo->IsPositive() && !spellInfo->IsPassive();
     });
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     _player->RemoveAurasByType(SPELL_AURA_MOUNTED, [](AuraApplication const* aurApp)
     {
         SpellInfo const* spellInfo = aurApp->GetBase()->GetSpellInfo();
         return !spellInfo->HasAttribute(SPELL_ATTR0_CANT_CANCEL) && spellInfo->IsPositive() && !spellInfo->IsPassive();
     });
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     // apply only to equipped item
     if (!Player::IsEquipmentPos(INVENTORY_SLOT_BAG_0, cancelTempEnchantment.Slot))
         return;
 
     Item* item = GetPlayer()->GetItemByPos(INVENTORY_SLOT_BAG_0, cancelTempEnchantment.Slot);
 
     if (!item)
         return;
 
     if (!item->GetEnchantmentId(TEMP_ENCHANTMENT_SLOT))
         return;
 
     GetPlayer()->ApplyEnchantment(item, TEMP_ENCHANTMENT_SLOT, false);
     item->ClearEnchantment(TEMP_ENCHANTMENT_SLOT);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     // sent also after LOGOUT COMPLETE
     if (_player)                                             // needed because STATUS_LOGGEDIN_OR_RECENTLY_LOGGOUT
         _player->TradeCancel(true);
 }

Here is the caller graph for this function:

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

 {
     Player* player = ObjectAccessor::FindPlayer(packet.TargetGUID);
 
     if (!player)
         return;
 
     WorldPackets::Duel::CanDuelResult response;
     response.TargetGUID = packet.TargetGUID;
     response.Result = !player->duel;
     SendPacket(response.Write());
 
     if (response.Result)
     {
         if (_player->IsMounted())
             _player->CastSpell(player, SPELL_MOUNTED_DUEL);
         else
             _player->CastSpell(player, SPELL_DUEL);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     // ignore for remote control state (for player case)
     Unit* mover = _player->m_mover;
     if (mover != _player && mover->GetTypeId() == TYPEID_PLAYER)
         return;
 
     SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(cast.Cast.SpellID);
     if (!spellInfo)
     {
         TC_LOG_ERROR("network", "WORLD: unknown spell id %u", cast.Cast.SpellID);
         return;
     }
 
     if (spellInfo->IsPassive())
         return;
 
     Unit* caster = mover;
     if (caster->GetTypeId() == TYPEID_UNIT && !caster->ToCreature()->HasSpell(spellInfo->Id))
     {
         // If the vehicle creature does not have the spell but it allows the passenger to cast own spells
         // change caster to player and let him cast
         if (!_player->IsOnVehicle(caster) || spellInfo->CheckVehicle(_player) != SPELL_CAST_OK)
             return;
 
         caster = _player;
     }
 
     // check known spell or raid marker spell (which not requires player to know it)
     if (caster->GetTypeId() == TYPEID_PLAYER && !caster->ToPlayer()->HasActiveSpell(spellInfo->Id) && !spellInfo->HasEffect(SPELL_EFFECT_CHANGE_RAID_MARKER) && !spellInfo->HasAttribute(SPELL_ATTR8_RAID_MARKER))
         return;
 
     // Check possible spell cast overrides
     spellInfo = caster->GetCastSpellInfo(spellInfo);
 
     // Client is resending autoshot cast opcode when other spell is cast during shoot rotation
     // Skip it to prevent "interrupt" message
     if (spellInfo->IsAutoRepeatRangedSpell() && caster->GetCurrentSpell(CURRENT_AUTOREPEAT_SPELL)
         && caster->GetCurrentSpell(CURRENT_AUTOREPEAT_SPELL)->m_spellInfo == spellInfo)
         return;
 
     // can't use our own spells when we're in possession of another unit,
     if (_player->isPossessing())
         return;
 
     // client provided targets
     SpellCastTargets targets(caster, cast.Cast);
 
     // auto-selection buff level base at target level (in spellInfo)
     if (targets.GetUnitTarget())
     {
         SpellInfo const* actualSpellInfo = spellInfo->GetAuraRankForLevel(targets.GetUnitTarget()->getLevel());
 
         // if rank not found then function return NULL but in explicit cast case original spell can be cast and later failed with appropriate error message
         if (actualSpellInfo)
             spellInfo = actualSpellInfo;
     }
 
     Spell* spell = new Spell(caster, spellInfo, TRIGGERED_NONE, ObjectGuid::Empty, false);
     spell->m_cast_count = cast.Cast.CastID;                         // set count of casts
     spell->m_misc.Raw.Data[0] = cast.Cast.Misc[0];
     spell->m_misc.Raw.Data[1] = cast.Cast.Misc[1];
     spell->prepare(&targets);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     // we will get correct pointer for group here, so we don't have to check if group is BG raid
     Group* group = GetPlayer()->GetGroup();
     if (!group)
         return;
 
     if (packet.NewSubGroup >= MAX_RAID_SUBGROUPS)
         return;
 
     ObjectGuid senderGuid = GetPlayer()->GetGUID();
     if (!group->IsLeader(senderGuid) && !group->IsAssistant(senderGuid))
         return;
 
     if (!group->HasFreeSlotSubGroup(packet.NewSubGroup))
         return;
 
     group->ChangeMembersGroup(packet.TargetGUID, packet.NewSubGroup);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

template<void(Channel::*)(Player const *) CommandFunction>

void WorldSession::HandleChannelCommand ( WorldPackets::Channel::ChannelPlayerCommand & packet )

 {
     TC_LOG_DEBUG("chat.system", "%s %s ChannelName: %s",
         GetOpcodeNameForLogging(packet.GetOpcode()).c_str(), GetPlayerInfo().c_str(), packet.ChannelName.c_str());
 
     if (ChannelMgr* cMgr = ChannelMgr::ForTeam(GetPlayer()->GetTeam()))
         if (Channel* channel = cMgr->GetChannel(packet.ChannelName, GetPlayer()))
             (channel->*CommandFunction)(GetPlayer());
 }

Here is the call graph for this function:

template<void(Channel::*)(Player const *, std::string const &) CommandFunction>

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

 {
     if (packet.Name.length() >= MAX_CHANNEL_NAME_STR)
     {
         TC_LOG_DEBUG("chat.system", "%s %s ChannelName: %s, Name: %s, Name too long.",
             GetOpcodeNameForLogging(packet.GetOpcode()).c_str(), GetPlayerInfo().c_str(), packet.ChannelName.c_str(), packet.Name.c_str());
         return;
     }
 
     TC_LOG_DEBUG("chat.system", "%s %s ChannelName: %s, Name: %s",
         GetOpcodeNameForLogging(packet.GetOpcode()).c_str(), GetPlayerInfo().c_str(), packet.ChannelName.c_str(), packet.Name.c_str());
 
     if (!normalizePlayerName(packet.Name))
         return;
 
     if (ChannelMgr* cMgr = ChannelMgr::ForTeam(GetPlayer()->GetTeam()))
         if (Channel* channel = cMgr->GetChannel(packet.ChannelName, GetPlayer()))
             (channel->*CommandFunction)(GetPlayer(), packet.Name);
 }

Here is the call graph for this function:

void WorldSession::HandleCharCreateCallback	(	PreparedQueryResult	result,
		WorldPackets::Character::CharacterCreateInfo *	createInfo
	)

This is a series of callbacks executed consecutively as a result from the database becomes available. This is much more efficient than synchronous requests on packet handler, and much less DoS prone. It also prevents data synchronisation errors.

Todo:: what to if account already has characters of both races?

Todo:: check if cinematic already shown? (already logged in?; cinematic field)

 {
     switch (_charCreateCallback.GetStage())
     {
         case 0:
         {
             if (result)
             {
                 SendCharCreate(CHAR_CREATE_NAME_IN_USE);
                 _charCreateCallback.Reset();
                 return;
             }
 
             ASSERT(_charCreateCallback.GetParam().get() == createInfo);
 
             PreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_SUM_REALM_CHARACTERS);
             stmt->setUInt32(0, GetAccountId());
 
             _charCreateCallback.FreeResult();
             _charCreateCallback.SetFutureResult(LoginDatabase.AsyncQuery(stmt));
             _charCreateCallback.NextStage();
             break;
         }
         case 1:
         {
             uint64 acctCharCount = 0;
             if (result)
             {
                 Field* fields = result->Fetch();
                 acctCharCount = uint64(fields[0].GetDouble());
             }
 
             if (acctCharCount >= sWorld->getIntConfig(CONFIG_CHARACTERS_PER_ACCOUNT))
             {
                 SendCharCreate(CHAR_CREATE_ACCOUNT_LIMIT);
                 _charCreateCallback.Reset();
                 return;
             }
 
             ASSERT(_charCreateCallback.GetParam().get() == createInfo);
 
             PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_SUM_CHARS);
             stmt->setUInt32(0, GetAccountId());
 
             _charCreateCallback.FreeResult();
             _charCreateCallback.SetFutureResult(CharacterDatabase.AsyncQuery(stmt));
             _charCreateCallback.NextStage();
             break;
         }
         case 2:
         {
             if (result)
             {
                 Field* fields = result->Fetch();
                 createInfo->CharCount = uint8(fields[0].GetUInt64()); // SQL's COUNT() returns uint64 but it will always be less than uint8.Max
 
                 if (createInfo->CharCount >= sWorld->getIntConfig(CONFIG_CHARACTERS_PER_REALM))
                 {
                     SendCharCreate(CHAR_CREATE_SERVER_LIMIT);
                     _charCreateCallback.Reset();
                     return;
                 }
             }
 
             bool allowTwoSideAccounts = !sWorld->IsPvPRealm() || HasPermission(rbac::RBAC_PERM_TWO_SIDE_CHARACTER_CREATION);
             uint32 skipCinematics = sWorld->getIntConfig(CONFIG_SKIP_CINEMATICS);
 
             _charCreateCallback.FreeResult();
 
             if (!allowTwoSideAccounts || skipCinematics == 1 || createInfo->Class == CLASS_DEATH_KNIGHT)
             {
                 PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHAR_CREATE_INFO);
                 stmt->setUInt32(0, GetAccountId());
                 stmt->setUInt32(1, (skipCinematics == 1 || createInfo->Class == CLASS_DEATH_KNIGHT) ? 10 : 1);
                 _charCreateCallback.SetFutureResult(CharacterDatabase.AsyncQuery(stmt));
                 _charCreateCallback.NextStage();
                 return;
             }
 
             _charCreateCallback.NextStage();
             HandleCharCreateCallback(PreparedQueryResult(NULL), createInfo);   // Will jump to case 3
             break;
         }
         case 3:
         {
             bool haveSameRace = false;
             uint32 heroicReqLevel = sWorld->getIntConfig(CONFIG_CHARACTER_CREATING_MIN_LEVEL_FOR_HEROIC_CHARACTER);
             bool hasHeroicReqLevel = (heroicReqLevel == 0);
             bool allowTwoSideAccounts = !sWorld->IsPvPRealm() || HasPermission(rbac::RBAC_PERM_TWO_SIDE_CHARACTER_CREATION);
             uint32 skipCinematics = sWorld->getIntConfig(CONFIG_SKIP_CINEMATICS);
             bool checkHeroicReqs = createInfo->Class == CLASS_DEATH_KNIGHT && !HasPermission(rbac::RBAC_PERM_SKIP_CHECK_CHARACTER_CREATION_HEROIC_CHARACTER);
 
             if (result)
             {
                 uint32 team = Player::TeamForRace(createInfo->Race);
                 uint32 freeHeroicSlots = sWorld->getIntConfig(CONFIG_HEROIC_CHARACTERS_PER_REALM);
 
                 Field* field = result->Fetch();
                 uint8 accRace  = field[1].GetUInt8();
 
                 if (checkHeroicReqs)
                 {
                     uint8 accClass = field[2].GetUInt8();
                     if (accClass == CLASS_DEATH_KNIGHT)
                     {
                         if (freeHeroicSlots > 0)
                             --freeHeroicSlots;
 
                         if (freeHeroicSlots == 0)
                         {
                             SendCharCreate(CHAR_CREATE_UNIQUE_CLASS_LIMIT);
                             _charCreateCallback.Reset();
                             return;
                         }
                     }
 
                     if (!hasHeroicReqLevel)
                     {
                         uint8 accLevel = field[0].GetUInt8();
                         if (accLevel >= heroicReqLevel)
                             hasHeroicReqLevel = true;
                     }
                 }
 
                 // need to check team only for first character
                 if (!allowTwoSideAccounts)
                 {
                     uint32 accTeam = 0;
                     if (accRace > 0)
                         accTeam = Player::TeamForRace(accRace);
 
                     if (accTeam != team)
                     {
                         SendCharCreate(CHAR_CREATE_PVP_TEAMS_VIOLATION);
                         _charCreateCallback.Reset();
                         return;
                     }
                 }
 
                 // search same race for cinematic or same class if need
                 while ((skipCinematics == 1 && !haveSameRace) || createInfo->Class == CLASS_DEATH_KNIGHT)
                 {
                     if (!result->NextRow())
                         break;
 
                     field = result->Fetch();
                     accRace = field[1].GetUInt8();
 
                     if (!haveSameRace)
                         haveSameRace = createInfo->Race == accRace;
 
                     if (checkHeroicReqs)
                     {
                         uint8 acc_class = field[2].GetUInt8();
                         if (acc_class == CLASS_DEATH_KNIGHT)
                         {
                             if (freeHeroicSlots > 0)
                                 --freeHeroicSlots;
 
                             if (freeHeroicSlots == 0)
                             {
                                 SendCharCreate(CHAR_CREATE_UNIQUE_CLASS_LIMIT);
                                 _charCreateCallback.Reset();
                                 return;
                             }
                         }
 
                         if (!hasHeroicReqLevel)
                         {
                             uint8 acc_level = field[0].GetUInt8();
                             if (acc_level >= heroicReqLevel)
                                 hasHeroicReqLevel = true;
                         }
                     }
                 }
             }
 
             if (checkHeroicReqs && !hasHeroicReqLevel)
             {
                 SendCharCreate(CHAR_CREATE_LEVEL_REQUIREMENT);
                 _charCreateCallback.Reset();
                 return;
             }
 
             Player newChar(this);
             newChar.GetMotionMaster()->Initialize();
             if (!newChar.Create(sObjectMgr->GetGenerator<HighGuid::Player>().Generate(), createInfo))
             {
                 // Player not create (race/class/etc problem?)
                 newChar.CleanupsBeforeDelete();
 
                 SendCharCreate(CHAR_CREATE_ERROR);
                 _charCreateCallback.Reset();
                 return;
             }
 
             if ((haveSameRace && skipCinematics == 1) || skipCinematics == 2)
                 newChar.setCinematic(1);                          // not show intro
 
             newChar.SetAtLoginFlag(AT_LOGIN_FIRST);               // First login
 
             // Player created, save it now
             newChar.SaveToDB(true);
             createInfo->CharCount += 1;
 
             SQLTransaction trans = LoginDatabase.BeginTransaction();
 
             PreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_DEL_REALM_CHARACTERS_BY_REALM);
             stmt->setUInt32(0, GetAccountId());
             stmt->setUInt32(1, realm.Id.Realm);
             trans->Append(stmt);
 
             stmt = LoginDatabase.GetPreparedStatement(LOGIN_INS_REALM_CHARACTERS);
             stmt->setUInt32(0, createInfo->CharCount);
             stmt->setUInt32(1, GetAccountId());
             stmt->setUInt32(2, realm.Id.Realm);
             trans->Append(stmt);
 
             LoginDatabase.CommitTransaction(trans);
 
             if (createInfo->TemplateSet)
             {
                 if (HasPermission(rbac::RBAC_PERM_USE_CHARACTER_TEMPLATES))
                 {
                     if (CharacterTemplate const* charTemplate = sObjectMgr->GetCharacterTemplate(*createInfo->TemplateSet))
                     {
                         if (charTemplate->Level != 1)
                         {
                             stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_LEVEL);
                             stmt->setUInt8(0, uint8(charTemplate->Level));
                             stmt->setUInt64(1, newChar.GetGUID().GetCounter());
                             CharacterDatabase.Execute(stmt);
                         }
                     }
                 }
                 else
                     TC_LOG_WARN("cheat", "Account: %u (IP: %s) tried to use a character template without given permission. Possible cheating attempt.", GetAccountId(), GetRemoteAddress().c_str());
             }
 
             SendCharCreate(CHAR_CREATE_SUCCESS);
 
             TC_LOG_INFO("entities.player.character", "Account: %u (IP: %s) Create Character: %s %s", GetAccountId(), GetRemoteAddress().c_str(), createInfo->Name.c_str(), newChar.GetGUID().ToString().c_str());
             sScriptMgr->OnPlayerCreate(&newChar);
             sWorld->AddCharacterInfo(newChar.GetGUID(), GetAccountId(), newChar.GetName(), newChar.GetByteValue(PLAYER_BYTES_3, PLAYER_BYTES_3_OFFSET_GENDER), newChar.getRace(), newChar.getClass(), newChar.getLevel(), false);
 
             newChar.CleanupsBeforeDelete();
             _charCreateCallback.Reset();
             break;
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (!HasPermission(rbac::RBAC_PERM_SKIP_CHECK_CHARACTER_CREATION_TEAMMASK))
     {
         if (uint32 mask = sWorld->getIntConfig(CONFIG_CHARACTER_CREATING_DISABLED))
         {
             bool disabled = false;
 
             switch (Player::TeamIdForRace(charCreate.CreateInfo->Race))
             {
                 case TEAM_ALLIANCE:
                     disabled = (mask & (1 << 0)) != 0;
                     break;
                 case TEAM_HORDE:
                     disabled = (mask & (1 << 1)) != 0;
                     break;
                 case TEAM_NEUTRAL:
                     disabled = (mask & (1 << 2)) != 0;
                     break;
             }
 
             if (disabled)
             {
                 SendCharCreate(CHAR_CREATE_DISABLED);
                 return;
             }
         }
     }
 
     ChrClassesEntry const* classEntry = sChrClassesStore.LookupEntry(charCreate.CreateInfo->Class);
     if (!classEntry)
     {
         TC_LOG_ERROR("network", "Class (%u) not found in DBC while creating new char for account (ID: %u): wrong DBC files or cheater?", charCreate.CreateInfo->Class, GetAccountId());
         SendCharCreate(CHAR_CREATE_FAILED);
         return;
     }
 
     ChrRacesEntry const* raceEntry = sChrRacesStore.LookupEntry(charCreate.CreateInfo->Race);
     if (!raceEntry)
     {
         TC_LOG_ERROR("network", "Race (%u) not found in DBC while creating new char for account (ID: %u): wrong DBC files or cheater?", charCreate.CreateInfo->Race, GetAccountId());
         SendCharCreate(CHAR_CREATE_FAILED);
         return;
     }
 
     // prevent character creating Expansion race without Expansion account
     uint8 raceExpansionRequirement = sObjectMgr->GetRaceExpansionRequirement(charCreate.CreateInfo->Race);
     if (raceExpansionRequirement > GetExpansion())
     {
         TC_LOG_ERROR("network", "Expansion %u account:[%d] tried to Create character with expansion %u race (%u)", GetExpansion(), GetAccountId(), raceExpansionRequirement, charCreate.CreateInfo->Race);
         SendCharCreate(CHAR_CREATE_EXPANSION);
         return;
     }
 
     // prevent character creating Expansion class without Expansion account
     uint8 classExpansionRequirement = sObjectMgr->GetClassExpansionRequirement(charCreate.CreateInfo->Class);
     if (classExpansionRequirement > GetExpansion())
     {
         TC_LOG_ERROR("network", "Expansion %u account:[%d] tried to Create character with expansion %u class (%u)", GetExpansion(), GetAccountId(), classExpansionRequirement, charCreate.CreateInfo->Class);
         SendCharCreate(CHAR_CREATE_EXPANSION_CLASS);
         return;
     }
 
     if (!HasPermission(rbac::RBAC_PERM_SKIP_CHECK_CHARACTER_CREATION_RACEMASK))
     {
         uint32 raceMaskDisabled = sWorld->getIntConfig(CONFIG_CHARACTER_CREATING_DISABLED_RACEMASK);
         if ((1 << (charCreate.CreateInfo->Race - 1)) & raceMaskDisabled)
         {
             SendCharCreate(CHAR_CREATE_DISABLED);
             return;
         }
     }
 
     if (!HasPermission(rbac::RBAC_PERM_SKIP_CHECK_CHARACTER_CREATION_CLASSMASK))
     {
         uint32 classMaskDisabled = sWorld->getIntConfig(CONFIG_CHARACTER_CREATING_DISABLED_CLASSMASK);
         if ((1 << (charCreate.CreateInfo->Class - 1)) & classMaskDisabled)
         {
             SendCharCreate(CHAR_CREATE_DISABLED);
             return;
         }
     }
 
     // prevent character creating with invalid name
     if (!normalizePlayerName(charCreate.CreateInfo->Name))
     {
         TC_LOG_ERROR("network", "Account:[%d] but tried to Create character with empty [name] ", GetAccountId());
         SendCharCreate(CHAR_NAME_NO_NAME);
         return;
     }
 
     // check name limitations
     ResponseCodes res = ObjectMgr::CheckPlayerName(charCreate.CreateInfo->Name, GetSessionDbcLocale(), true);
     if (res != CHAR_NAME_SUCCESS)
     {
         SendCharCreate(res);
         return;
     }
 
     if (!HasPermission(rbac::RBAC_PERM_SKIP_CHECK_CHARACTER_CREATION_RESERVEDNAME) && sObjectMgr->IsReservedName(charCreate.CreateInfo->Name))
     {
         SendCharCreate(CHAR_NAME_RESERVED);
         return;
     }
 
     if (charCreate.CreateInfo->Class == CLASS_DEATH_KNIGHT && !HasPermission(rbac::RBAC_PERM_SKIP_CHECK_CHARACTER_CREATION_HEROIC_CHARACTER))
     {
         // speedup check for heroic class disabled case
         if (!sWorld->getIntConfig(CONFIG_HEROIC_CHARACTERS_PER_REALM))
         {
             SendCharCreate(CHAR_CREATE_UNIQUE_CLASS_LIMIT);
             return;
         }
 
         // speedup check for heroic class disabled case
         if (sWorld->getIntConfig(CONFIG_CHARACTER_CREATING_MIN_LEVEL_FOR_HEROIC_CHARACTER) > sWorld->getIntConfig(CONFIG_MAX_PLAYER_LEVEL))
         {
             SendCharCreate(CHAR_CREATE_LEVEL_REQUIREMENT);
             return;
         }
     }
 
     PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHECK_NAME);
     stmt->setString(0, charCreate.CreateInfo->Name);
 
     _charCreateCallback.SetParam(charCreate.CreateInfo);
     _charCreateCallback.SetFutureResult(CharacterDatabase.AsyncQuery(stmt));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleCharCustomizeCallback	(	PreparedQueryResult	result,
		WorldPackets::Character::CharCustomizeInfo *	customizeInfo
	)

Todo:: : make async

Customize

Name Change and update atLogin flags

 {
     ASSERT(_charCustomizeCallback.GetParam().get() == customizeInfo);
 
     if (!result)
     {
         SendCharCustomize(CHAR_CREATE_ERROR, customizeInfo);
         return;
     }
 
     Field* fields = result->Fetch();
 
     std::string oldName = fields[0].GetString();
     uint8 plrRace = fields[1].GetUInt8();
     uint8 plrClass = fields[2].GetUInt8();
     uint8 plrGender = fields[3].GetUInt8();
     uint16 atLoginFlags = fields[4].GetUInt16();
 
     if (!Player::ValidateAppearance(plrRace, plrClass, plrGender, customizeInfo->HairStyleID, customizeInfo->HairColorID, customizeInfo->FaceID, customizeInfo->FacialHairStyleID, customizeInfo->SkinID, true))
     {
         SendCharCustomize(CHAR_CREATE_ERROR, customizeInfo);
         return;
     }
 
     if (!(atLoginFlags & AT_LOGIN_CUSTOMIZE))
     {
         SendCharCustomize(CHAR_CREATE_ERROR, customizeInfo);
         return;
     }
 
     atLoginFlags &= ~AT_LOGIN_CUSTOMIZE;
 
     // prevent character rename to invalid name
     if (!normalizePlayerName(customizeInfo->CharName))
     {
         SendCharCustomize(CHAR_NAME_NO_NAME, customizeInfo);
         return;
     }
 
     ResponseCodes res = ObjectMgr::CheckPlayerName(customizeInfo->CharName, GetSessionDbcLocale(), true);
     if (res != CHAR_NAME_SUCCESS)
     {
         SendCharCustomize(res, customizeInfo);
         return;
     }
 
     // check name limitations
     if (!HasPermission(rbac::RBAC_PERM_SKIP_CHECK_CHARACTER_CREATION_RESERVEDNAME) && sObjectMgr->IsReservedName(customizeInfo->CharName))
     {
         SendCharCustomize(CHAR_NAME_RESERVED, customizeInfo);
         return;
     }
 
     // character with this name already exist
     ObjectGuid newGuid = ObjectMgr::GetPlayerGUIDByName(customizeInfo->CharName);
     if (!newGuid.IsEmpty())
     {
         if (newGuid != customizeInfo->CharGUID)
         {
             SendCharCustomize(CHAR_CREATE_NAME_IN_USE, customizeInfo);
             return;
         }
     }
 
     PreparedStatement* stmt = nullptr;
     SQLTransaction trans = CharacterDatabase.BeginTransaction();
 
     ObjectGuid::LowType lowGuid = customizeInfo->CharGUID.GetCounter();
 
     {
         stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_GENDER_AND_APPEARANCE);
 
         stmt->setUInt8(0, customizeInfo->SexID);
         stmt->setUInt8(1, customizeInfo->SkinID);
         stmt->setUInt8(2, customizeInfo->FaceID);
         stmt->setUInt8(3, customizeInfo->HairStyleID);
         stmt->setUInt8(4, customizeInfo->HairColorID);
         stmt->setUInt8(5, customizeInfo->FacialHairStyleID);
         stmt->setUInt64(6, lowGuid);
 
         trans->Append(stmt);
     }
 
     {
         stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_CHAR_NAME_AT_LOGIN);
         stmt->setString(0, customizeInfo->CharName);
         stmt->setUInt16(1, atLoginFlags);
         stmt->setUInt64(2, lowGuid);
 
         trans->Append(stmt);
 
         stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_DECLINED_NAME);
         stmt->setUInt64(0, lowGuid);
 
         trans->Append(stmt);
     }
 
     CharacterDatabase.CommitTransaction(trans);
 
     sWorld->UpdateCharacterInfo(customizeInfo->CharGUID, customizeInfo->CharName, customizeInfo->SexID);
 
     SendCharCustomize(RESPONSE_SUCCESS, customizeInfo);
 
     TC_LOG_INFO("entities.player.character", "Account: %u (IP: %s), Character[%s] (%s) Customized to: %s",
         GetAccountId(), GetRemoteAddress().c_str(), oldName.c_str(), customizeInfo->CharGUID.ToString().c_str(), customizeInfo->CharName.c_str());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (!IsLegitCharacterForAccount(packet.CustomizeInfo->CharGUID))
     {
         TC_LOG_ERROR("network", "Account %u, IP: %s tried to customise %s, but it does not belong to their account!",
             GetAccountId(), GetRemoteAddress().c_str(), packet.CustomizeInfo->CharGUID.ToString().c_str());
         KickPlayer();
         return;
     }
 
     PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHAR_CUSTOMIZE_INFO);
     stmt->setUInt64(0, packet.CustomizeInfo->CharGUID.GetCounter());
 
     _charCustomizeCallback.SetParam(packet.CustomizeInfo);
     _charCustomizeCallback.SetFutureResult(CharacterDatabase.AsyncQuery(stmt));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     // Initiating
     uint32 initAccountId = GetAccountId();
 
     // can't delete loaded character
     if (ObjectAccessor::FindPlayer(charDelete.Guid))
     {
         sScriptMgr->OnPlayerFailedDelete(charDelete.Guid, initAccountId);
         return;
     }
 
     // is guild leader
     if (sGuildMgr->GetGuildByLeader(charDelete.Guid))
     {
         sScriptMgr->OnPlayerFailedDelete(charDelete.Guid, initAccountId);
         SendCharDelete(CHAR_DELETE_FAILED_GUILD_LEADER);
         return;
     }
 
     // is arena team captain
     if (sArenaTeamMgr->GetArenaTeamByCaptain(charDelete.Guid))
     {
         sScriptMgr->OnPlayerFailedDelete(charDelete.Guid, initAccountId);
         SendCharDelete(CHAR_DELETE_FAILED_ARENA_CAPTAIN);
         return;
     }
 
     uint32 accountId = 0;
     uint8 level = 0;
     std::string name;
 
     PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHARACTER_DATA_BY_GUID);
     stmt->setUInt64(0, charDelete.Guid.GetCounter());
 
     if (PreparedQueryResult result = CharacterDatabase.Query(stmt))
     {
         Field* fields = result->Fetch();
         accountId = fields[0].GetUInt32();
         name = fields[1].GetString();
         level = fields[2].GetUInt8();
     }
 
     // prevent deleting other players' characters using cheating tools
     if (accountId != initAccountId)
     {
         sScriptMgr->OnPlayerFailedDelete(charDelete.Guid, initAccountId);
         return;
     }
 
     TC_LOG_INFO("entities.player.character", "Account: %u, IP: %s deleted character: %s, %s, Level: %u", accountId, GetRemoteAddress().c_str(), name.c_str(), charDelete.Guid.ToString().c_str(), level);
 
     // To prevent hook failure, place hook before removing reference from DB
     sScriptMgr->OnPlayerDelete(charDelete.Guid, initAccountId); // To prevent race conditioning, but as it also makes sense, we hand the accountId over for successful delete.
     // Shouldn't interfere with character deletion though
 
     if (sLog->ShouldLog("entities.player.dump", LOG_LEVEL_INFO)) // optimize GetPlayerDump call
     {
         std::string dump;
         if (PlayerDumpWriter().GetDump(charDelete.Guid.GetCounter(), dump))
             sLog->outCharDump(dump.c_str(), accountId, charDelete.Guid.GetCounter(), name.c_str());
     }
 
     sGuildFinderMgr->RemoveAllMembershipRequestsFromPlayer(charDelete.Guid);
     sCalendarMgr->RemoveAllPlayerEventsAndInvites(charDelete.Guid);
     Player::DeleteFromDB(charDelete.Guid, accountId);
 
     SendCharDelete(CHAR_DELETE_SUCCESS);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleCharEnum ( PreparedQueryResult result )

 {
     WorldPackets::Character::EnumCharactersResult charEnum;
     charEnum.Success = true;
     charEnum.IsDeletedCharacters = false;
 
     _legitCharacters.clear();
 
     if (result)
     {
         do
         {
             Field* fields = result->Fetch();
             WorldPackets::Character::EnumCharactersResult::CharacterInfo charInfo(fields);
 
             TC_LOG_INFO("network", "Loading char guid %s from account %u.", charInfo.Guid.ToString().c_str(), GetAccountId());
 
             if (!Player::ValidateAppearance(charInfo.Race, charInfo.Class, charInfo.Sex, charInfo.HairStyle, charInfo.HairColor, charInfo.Face, charInfo.FacialHair, charInfo.Skin))
             {
                 TC_LOG_ERROR("entities.player.loading", "Player %s has wrong Appearance values (Hair/Skin/Color), forcing recustomize", charInfo.Guid.ToString().c_str());
 
                 if (!(charInfo.CustomizationFlag == CHAR_CUSTOMIZE_FLAG_CUSTOMIZE))
                 {
                     PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_ADD_AT_LOGIN_FLAG);
                     stmt->setUInt16(0, uint16(AT_LOGIN_CUSTOMIZE));
                     stmt->setUInt64(1, charInfo.Guid.GetCounter());
                     CharacterDatabase.Execute(stmt);
                     charInfo.CustomizationFlag = CHAR_CUSTOMIZE_FLAG_CUSTOMIZE;
                 }
             }
 
             // Do not allow locked characters to login
             if (!(charInfo.Flags & (CHARACTER_FLAG_LOCKED_FOR_TRANSFER | CHARACTER_FLAG_LOCKED_BY_BILLING)))
                 _legitCharacters.insert(charInfo.Guid);
 
             if (!sWorld->HasCharacterInfo(charInfo.Guid)) // This can happen if characters are inserted into the database manually. Core hasn't loaded name data yet.
                 sWorld->AddCharacterInfo(charInfo.Guid, GetAccountId(), charInfo.Name, charInfo.Sex, charInfo.Race, charInfo.Class, charInfo.Level, false);
 
             charEnum.Characters.emplace_back(charInfo);
         }
         while (result->NextRow());
     }
 
     SendPacket(charEnum.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

get all the data necessary for loading all characters (along with their pets) on the account

 {
     // remove expired bans
     PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_EXPIRED_BANS);
     CharacterDatabase.Execute(stmt);
 
 
     if (sWorld->getBoolConfig(CONFIG_DECLINED_NAMES_USED))
         stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_ENUM_DECLINED_NAME);
     else
         stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_ENUM);
 
     stmt->setUInt8(0, PET_SAVE_AS_CURRENT);
     stmt->setUInt32(1, GetAccountId());
 
     _charEnumCallback.SetParam(false);
     _charEnumCallback.SetFutureResult(CharacterDatabase.AsyncQuery(stmt));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleCharRaceOrFactionChangeCallback	(	PreparedQueryResult	result,
		WorldPackets::Character::CharRaceOrFactionChangeInfo *	factionChangeInfo
	)

Todo:: : make this part async

 {
     ASSERT(_charFactionChangeCallback.GetParam().get() == factionChangeInfo);
 
     if (!result)
     {
         SendCharFactionChange(CHAR_CREATE_ERROR, factionChangeInfo);
         return;
     }
 
     // get the players old (at this moment current) race
     CharacterInfo const* characterInfo = sWorld->GetCharacterInfo(factionChangeInfo->Guid);
     if (!characterInfo)
     {
         SendCharFactionChange(CHAR_CREATE_ERROR, factionChangeInfo);
         return;
     }
 
     uint8 oldRace     = characterInfo->Race;
     uint8 playerClass = characterInfo->Class;
     uint8 level       = characterInfo->Level;
 
     if (!sObjectMgr->GetPlayerInfo(factionChangeInfo->RaceID, playerClass))
     {
         SendCharFactionChange(CHAR_CREATE_ERROR, factionChangeInfo);
         return;
     }
 
     Field* fields              = result->Fetch();
     uint16 atLoginFlags        = fields[0].GetUInt16();
     std::string knownTitlesStr = fields[1].GetString();
 
     uint16 usedLoginFlag = (factionChangeInfo->FactionChange ? AT_LOGIN_CHANGE_FACTION : AT_LOGIN_CHANGE_RACE);
     if (!(atLoginFlags & usedLoginFlag))
     {
         SendCharFactionChange(CHAR_CREATE_ERROR, factionChangeInfo);
         return;
     }
 
     TeamId newTeamId = Player::TeamIdForRace(factionChangeInfo->RaceID);
     if (newTeamId == TEAM_NEUTRAL)
     {
         SendCharFactionChange(CHAR_CREATE_RESTRICTED_RACECLASS, factionChangeInfo);
         return;
     }
 
     if (factionChangeInfo->FactionChange == (Player::TeamIdForRace(oldRace) == newTeamId))
     {
         SendCharFactionChange(factionChangeInfo->FactionChange ? CHAR_CREATE_CHARACTER_SWAP_FACTION : CHAR_CREATE_CHARACTER_RACE_ONLY, factionChangeInfo);
         return;
     }
 
     if (!HasPermission(rbac::RBAC_PERM_SKIP_CHECK_CHARACTER_CREATION_RACEMASK))
     {
         uint32 raceMaskDisabled = sWorld->getIntConfig(CONFIG_CHARACTER_CREATING_DISABLED_RACEMASK);
         if ((1 << (factionChangeInfo->RaceID - 1)) & raceMaskDisabled)
         {
             SendCharFactionChange(CHAR_CREATE_ERROR, factionChangeInfo);
             return;
         }
     }
 
     // prevent character rename to invalid name
     if (!normalizePlayerName(factionChangeInfo->Name))
     {
         SendCharFactionChange(CHAR_NAME_NO_NAME, factionChangeInfo);
         return;
     }
 
     ResponseCodes res = ObjectMgr::CheckPlayerName(factionChangeInfo->Name, GetSessionDbcLocale(), true);
     if (res != CHAR_NAME_SUCCESS)
     {
         SendCharFactionChange(res, factionChangeInfo);
         return;
     }
 
     // check name limitations
     if (!HasPermission(rbac::RBAC_PERM_SKIP_CHECK_CHARACTER_CREATION_RESERVEDNAME) && sObjectMgr->IsReservedName(factionChangeInfo->Name))
     {
         SendCharFactionChange(CHAR_NAME_RESERVED, factionChangeInfo);
         return;
     }
 
     // character with this name already exist
     ObjectGuid newGuid = ObjectMgr::GetPlayerGUIDByName(factionChangeInfo->Name);
     if (!newGuid.IsEmpty())
     {
         if (newGuid != factionChangeInfo->Guid)
         {
             SendCharFactionChange(CHAR_CREATE_NAME_IN_USE, factionChangeInfo);
             return;
         }
     }
 
     if (sArenaTeamMgr->GetArenaTeamByCaptain(factionChangeInfo->Guid))
     {
         SendCharFactionChange(CHAR_CREATE_CHARACTER_ARENA_LEADER, factionChangeInfo);
         return;
     }
 
     // All checks are fine, deal with race change now
     ObjectGuid::LowType lowGuid = factionChangeInfo->Guid.GetCounter();
 
     PreparedStatement* stmt = nullptr;
     SQLTransaction trans = CharacterDatabase.BeginTransaction();
 
     // resurrect the character in case he's dead
     Player::OfflineResurrect(factionChangeInfo->Guid, trans);
 
     // Name Change and update atLogin flags
     {
         CharacterDatabase.EscapeString(factionChangeInfo->Name);
 
         stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_CHAR_NAME_AT_LOGIN);
         stmt->setString(0, factionChangeInfo->Name);
         stmt->setUInt16(1, uint16((atLoginFlags | AT_LOGIN_RESURRECT) & ~usedLoginFlag));
         stmt->setUInt64(2, lowGuid);
 
         trans->Append(stmt);
 
         stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_DECLINED_NAME);
         stmt->setUInt64(0, lowGuid);
 
         trans->Append(stmt);
     }
 
     // Customize
     {
         if (!factionChangeInfo->SkinID)
             factionChangeInfo->SkinID = fields[2].GetUInt8();
 
         if (!factionChangeInfo->FaceID)
             factionChangeInfo->FaceID = fields[3].GetUInt8();
 
         if (!factionChangeInfo->HairStyleID)
             factionChangeInfo->HairStyleID = fields[4].GetUInt8();
 
         if (!factionChangeInfo->HairColorID)
             factionChangeInfo->HairColorID = fields[5].GetUInt8();
 
         if (!factionChangeInfo->FacialHairStyleID)
             factionChangeInfo->FacialHairStyleID = fields[6].GetUInt8();
 
         stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_GENDER_AND_APPEARANCE);
         stmt->setUInt8(0, factionChangeInfo->SexID);
         stmt->setUInt8(1, *factionChangeInfo->SkinID);
         stmt->setUInt8(2, *factionChangeInfo->FaceID);
         stmt->setUInt8(3, *factionChangeInfo->HairStyleID);
         stmt->setUInt8(4, *factionChangeInfo->HairColorID);
         stmt->setUInt8(5, *factionChangeInfo->FacialHairStyleID);
         stmt->setUInt64(6, lowGuid);
 
         trans->Append(stmt);
     }
 
     // Race Change
     {
         stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_CHAR_RACE);
         stmt->setUInt8(0, factionChangeInfo->RaceID);
         stmt->setUInt64(1, lowGuid);
 
         trans->Append(stmt);
     }
 
     sWorld->UpdateCharacterInfo(factionChangeInfo->Guid, factionChangeInfo->Name, factionChangeInfo->SexID, factionChangeInfo->RaceID);
 
     if (oldRace != factionChangeInfo->RaceID)
     {
         // Switch Languages
         // delete all languages first
         stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_SKILL_LANGUAGES);
         stmt->setUInt64(0, lowGuid);
         trans->Append(stmt);
 
         // Now add them back
         stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_CHAR_SKILL_LANGUAGE);
         stmt->setUInt64(0, lowGuid);
 
         // Faction specific languages
         if (newTeamId == TEAM_HORDE)
             stmt->setUInt16(1, 109);
         else
             stmt->setUInt16(1, 98);
 
         trans->Append(stmt);
 
         // Race specific languages
         if (factionChangeInfo->RaceID != RACE_ORC && factionChangeInfo->RaceID != RACE_HUMAN)
         {
             stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_CHAR_SKILL_LANGUAGE);
             stmt->setUInt64(0, lowGuid);
 
             switch (factionChangeInfo->RaceID)
             {
                 case RACE_DWARF:
                     stmt->setUInt16(1, 111);
                     break;
                 case RACE_DRAENEI:
                     stmt->setUInt16(1, 759);
                     break;
                 case RACE_GNOME:
                     stmt->setUInt16(1, 313);
                     break;
                 case RACE_NIGHTELF:
                     stmt->setUInt16(1, 113);
                     break;
                 case RACE_WORGEN:
                     stmt->setUInt16(1, 791);
                     break;
                 case RACE_UNDEAD_PLAYER:
                     stmt->setUInt16(1, 673);
                     break;
                 case RACE_TAUREN:
                     stmt->setUInt16(1, 115);
                     break;
                 case RACE_TROLL:
                     stmt->setUInt16(1, 315);
                     break;
                 case RACE_BLOODELF:
                     stmt->setUInt16(1, 137);
                     break;
                 case RACE_GOBLIN:
                     stmt->setUInt16(1, 792);
                     break;
             }
 
             trans->Append(stmt);
         }
 
         // Team Conversion
         if (factionChangeInfo->FactionChange)
         {
             // Delete all Flypaths
             stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_CHAR_TAXI_PATH);
             stmt->setUInt64(0, lowGuid);
             trans->Append(stmt);
 
             if (level > 7)
             {
                 // Update Taxi path
                 // this doesn't seem to be 100% blizzlike... but it can't really be helped.
                 std::ostringstream taximaskstream;
                 TaxiMask const& factionMask = newTeamId == TEAM_HORDE ? sHordeTaxiNodesMask : sAllianceTaxiNodesMask;
                 for (uint8 i = 0; i < TaxiMaskSize; ++i)
                 {
                     // i = (315 - 1) / 8 = 39
                     // m = 1 << ((315 - 1) % 8) = 4
                     uint8 deathKnightExtraNode = playerClass != CLASS_DEATH_KNIGHT || i != 39 ? 0 : 4;
                     taximaskstream << uint32(factionMask[i] | deathKnightExtraNode) << ' ';
                 }
 
                 stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_CHAR_TAXIMASK);
                 stmt->setString(0, taximaskstream.str());
                 stmt->setUInt64(1, lowGuid);
                 trans->Append(stmt);
             }
 
             if (!sWorld->getBoolConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_GUILD))
             {
                 // Reset guild
                 stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_GUILD_MEMBER);
                 stmt->setUInt64(0, lowGuid);
 
                 if (PreparedQueryResult memberResult = CharacterDatabase.Query(stmt))
                     if (Guild* guild = sGuildMgr->GetGuildById(memberResult->Fetch()[0].GetUInt64()))
                         guild->DeleteMember(factionChangeInfo->Guid, false, false, true);
 
                 Player::LeaveAllArenaTeams(factionChangeInfo->Guid);
             }
 
             if (!HasPermission(rbac::RBAC_PERM_TWO_SIDE_ADD_FRIEND))
             {
                 // Delete Friend List
                 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_SOCIAL_BY_GUID);
                 stmt->setUInt64(0, lowGuid);
                 trans->Append(stmt);
 
                 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_SOCIAL_BY_FRIEND);
                 stmt->setUInt64(0, lowGuid);
                 trans->Append(stmt);
             }
 
             // Reset homebind and position
             stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_PLAYER_HOMEBIND);
             stmt->setUInt64(0, lowGuid);
             trans->Append(stmt);
 
             stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_PLAYER_HOMEBIND);
             stmt->setUInt64(0, lowGuid);
 
             WorldLocation loc;
             uint16 zoneId = 0;
             if (newTeamId == TEAM_ALLIANCE)
             {
                 loc.WorldRelocate(0, -8867.68f, 673.373f, 97.9034f, 0.0f);
                 zoneId = 1519;
             }
             else
             {
                 loc.WorldRelocate(1, 1633.33f, -4439.11f, 15.7588f, 0.0f);
                 zoneId = 1637;
             }
 
             stmt->setUInt16(1, loc.GetMapId());
             stmt->setUInt16(2, zoneId);
             stmt->setFloat(3, loc.GetPositionX());
             stmt->setFloat(4, loc.GetPositionY());
             stmt->setFloat(5, loc.GetPositionZ());
             trans->Append(stmt);
 
             Player::SavePositionInDB(loc, zoneId, factionChangeInfo->Guid, trans);
 
             // Achievement conversion
             for (std::map<uint32, uint32>::const_iterator it = sObjectMgr->FactionChangeAchievements.begin(); it != sObjectMgr->FactionChangeAchievements.end(); ++it)
             {
                 uint32 achiev_alliance = it->first;
                 uint32 achiev_horde = it->second;
 
                 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_ACHIEVEMENT_BY_ACHIEVEMENT);
                 stmt->setUInt16(0, uint16(newTeamId == TEAM_ALLIANCE ? achiev_alliance : achiev_horde));
                 stmt->setUInt64(1, lowGuid);
                 trans->Append(stmt);
 
                 stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_CHAR_ACHIEVEMENT);
                 stmt->setUInt16(0, uint16(newTeamId == TEAM_ALLIANCE ? achiev_alliance : achiev_horde));
                 stmt->setUInt16(1, uint16(newTeamId == TEAM_ALLIANCE ? achiev_horde : achiev_alliance));
                 stmt->setUInt64(2, lowGuid);
                 trans->Append(stmt);
             }
 
             // Item conversion
             for (std::map<uint32, uint32>::const_iterator it = sObjectMgr->FactionChangeItems.begin(); it != sObjectMgr->FactionChangeItems.end(); ++it)
             {
                 uint32 item_alliance = it->first;
                 uint32 item_horde = it->second;
 
                 stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_CHAR_INVENTORY_FACTION_CHANGE);
                 stmt->setUInt32(0, (newTeamId == TEAM_ALLIANCE ? item_alliance : item_horde));
                 stmt->setUInt32(1, (newTeamId == TEAM_ALLIANCE ? item_horde : item_alliance));
                 stmt->setUInt64(2, lowGuid);
                 trans->Append(stmt);
             }
 
             // Delete all current quests
             stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_QUESTSTATUS);
             stmt->setUInt64(0, lowGuid);
             trans->Append(stmt);
 
             // Quest conversion
             for (std::map<uint32, uint32>::const_iterator it = sObjectMgr->FactionChangeQuests.begin(); it != sObjectMgr->FactionChangeQuests.end(); ++it)
             {
                 uint32 quest_alliance = it->first;
                 uint32 quest_horde = it->second;
 
                 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_QUESTSTATUS_REWARDED_BY_QUEST);
                 stmt->setUInt64(0, lowGuid);
                 stmt->setUInt32(1, (newTeamId == TEAM_ALLIANCE ? quest_alliance : quest_horde));
                 trans->Append(stmt);
 
                 stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_CHAR_QUESTSTATUS_REWARDED_FACTION_CHANGE);
                 stmt->setUInt32(0, (newTeamId == TEAM_ALLIANCE ? quest_alliance : quest_horde));
                 stmt->setUInt32(1, (newTeamId == TEAM_ALLIANCE ? quest_horde : quest_alliance));
                 stmt->setUInt64(2, lowGuid);
                 trans->Append(stmt);
             }
 
             // Mark all rewarded quests as "active" (will count for completed quests achievements)
             stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_CHAR_QUESTSTATUS_REWARDED_ACTIVE);
             stmt->setUInt64(0, lowGuid);
             trans->Append(stmt);
 
             // Disable all old-faction specific quests
             {
                 ObjectMgr::QuestMap const& questTemplates = sObjectMgr->GetQuestTemplates();
                 for (ObjectMgr::QuestMap::const_iterator iter = questTemplates.begin(); iter != questTemplates.end(); ++iter)
                 {
                     Quest const* quest = iter->second;
                     uint32 newRaceMask = (newTeamId == TEAM_ALLIANCE) ? RACEMASK_ALLIANCE : RACEMASK_HORDE;
                     if (quest->GetAllowableRaces() != -1 && !(quest->GetAllowableRaces() & newRaceMask))
                     {
                         stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_CHAR_QUESTSTATUS_REWARDED_ACTIVE_BY_QUEST);
                         stmt->setUInt64(0, lowGuid);
                         stmt->setUInt32(1, quest->GetQuestId());
                         trans->Append(stmt);
                     }
                 }
             }
 
             // Spell conversion
             for (std::map<uint32, uint32>::const_iterator it = sObjectMgr->FactionChangeSpells.begin(); it != sObjectMgr->FactionChangeSpells.end(); ++it)
             {
                 uint32 spell_alliance = it->first;
                 uint32 spell_horde = it->second;
 
                 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_SPELL_BY_SPELL);
                 stmt->setUInt32(0, (newTeamId == TEAM_ALLIANCE ? spell_alliance : spell_horde));
                 stmt->setUInt64(1, lowGuid);
                 trans->Append(stmt);
 
                 stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_CHAR_SPELL_FACTION_CHANGE);
                 stmt->setUInt32(0, (newTeamId == TEAM_ALLIANCE ? spell_alliance : spell_horde));
                 stmt->setUInt32(1, (newTeamId == TEAM_ALLIANCE ? spell_horde : spell_alliance));
                 stmt->setUInt64(2, lowGuid);
                 trans->Append(stmt);
             }
 
             // Reputation conversion
             for (std::map<uint32, uint32>::const_iterator it = sObjectMgr->FactionChangeReputation.begin(); it != sObjectMgr->FactionChangeReputation.end(); ++it)
             {
                 uint32 reputation_alliance = it->first;
                 uint32 reputation_horde = it->second;
                 uint32 newReputation = (newTeamId == TEAM_ALLIANCE) ? reputation_alliance : reputation_horde;
                 uint32 oldReputation = (newTeamId == TEAM_ALLIANCE) ? reputation_horde : reputation_alliance;
 
                 // select old standing set in db
                 stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHAR_REP_BY_FACTION);
                 stmt->setUInt32(0, oldReputation);
                 stmt->setUInt64(1, lowGuid);
 
                 if (PreparedQueryResult reputationResult = CharacterDatabase.Query(stmt))
                 {
                     fields = reputationResult->Fetch();
                     int32 oldDBRep = fields[0].GetInt32();
                     FactionEntry const* factionEntry = sFactionStore.LookupEntry(oldReputation);
 
                     // old base reputation
                     int32 oldBaseRep = sObjectMgr->GetBaseReputationOf(factionEntry, oldRace, playerClass);
 
                     // new base reputation
                     int32 newBaseRep = sObjectMgr->GetBaseReputationOf(sFactionStore.LookupEntry(newReputation), factionChangeInfo->RaceID, playerClass);
 
                     // final reputation shouldnt change
                     int32 FinalRep = oldDBRep + oldBaseRep;
                     int32 newDBRep = FinalRep - newBaseRep;
 
                     stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_REP_BY_FACTION);
                     stmt->setUInt32(0, newReputation);
                     stmt->setUInt64(1, lowGuid);
                     trans->Append(stmt);
 
                     stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_CHAR_REP_FACTION_CHANGE);
                     stmt->setUInt16(0, uint16(newReputation));
                     stmt->setInt32(1, newDBRep);
                     stmt->setUInt16(2, uint16(oldReputation));
                     stmt->setUInt64(3, lowGuid);
                     trans->Append(stmt);
                 }
             }
 
             // Title conversion
             if (!knownTitlesStr.empty())
             {
                 uint32 const ktcount = KNOWN_TITLES_SIZE * 2;
                 uint32 knownTitles[ktcount];
                 Tokenizer tokens(knownTitlesStr, ' ', ktcount);
 
                 if (tokens.size() != ktcount)
                 {
                     SendCharFactionChange(CHAR_CREATE_ERROR, factionChangeInfo);
                     return;
                 }
 
                 for (uint32 index = 0; index < ktcount; ++index)
                     knownTitles[index] = atoul(tokens[index]);
 
                 for (std::map<uint32, uint32>::const_iterator it = sObjectMgr->FactionChangeTitles.begin(); it != sObjectMgr->FactionChangeTitles.end(); ++it)
                 {
                     uint32 title_alliance = it->first;
                     uint32 title_horde = it->second;
 
                     CharTitlesEntry const* atitleInfo = sCharTitlesStore.LookupEntry(title_alliance);
                     CharTitlesEntry const* htitleInfo = sCharTitlesStore.LookupEntry(title_horde);
                     // new team
                     if (newTeamId == TEAM_ALLIANCE)
                     {
                         uint32 maskID = htitleInfo->MaskID;
                         uint32 index = maskID / 32;
                         uint32 old_flag = 1 << (maskID % 32);
                         uint32 new_flag = 1 << (atitleInfo->MaskID % 32);
                         if (knownTitles[index] & old_flag)
                         {
                             knownTitles[index] &= ~old_flag;
                             // use index of the new title
                             knownTitles[atitleInfo->MaskID / 32] |= new_flag;
                         }
                     }
                     else
                     {
                         uint32 maskID = atitleInfo->MaskID;
                         uint32 index = maskID / 32;
                         uint32 old_flag = 1 << (maskID % 32);
                         uint32 new_flag = 1 << (htitleInfo->MaskID % 32);
                         if (knownTitles[index] & old_flag)
                         {
                             knownTitles[index] &= ~old_flag;
                             // use index of the new title
                             knownTitles[htitleInfo->MaskID / 32] |= new_flag;
                         }
                     }
 
                     std::ostringstream ss;
                     for (uint32 index = 0; index < ktcount; ++index)
                         ss << knownTitles[index] << ' ';
 
                     stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_CHAR_TITLES_FACTION_CHANGE);
                     stmt->setString(0, ss.str());
                     stmt->setUInt64(1, lowGuid);
                     trans->Append(stmt);
 
                     // unset any currently chosen title
                     stmt = CharacterDatabase.GetPreparedStatement(CHAR_RES_CHAR_TITLES_FACTION_CHANGE);
                     stmt->setUInt64(0, lowGuid);
                     trans->Append(stmt);
                 }
             }
         }
     }
 
     CharacterDatabase.CommitTransaction(trans);
 
     TC_LOG_DEBUG("entities.player", "%s (IP: %s) changed race from %u to %u", GetPlayerInfo().c_str(), GetRemoteAddress().c_str(), oldRace, factionChangeInfo->RaceID);
 
     SendCharFactionChange(RESPONSE_SUCCESS, factionChangeInfo);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (!IsLegitCharacterForAccount(packet.RaceOrFactionChangeInfo->Guid))
     {
         TC_LOG_ERROR("network", "Account %u, IP: %s tried to factionchange character %s, but it does not belong to their account!",
             GetAccountId(), GetRemoteAddress().c_str(), packet.RaceOrFactionChangeInfo->Guid.ToString().c_str());
         KickPlayer();
         return;
     }
 
     PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHAR_RACE_OR_FACTION_CHANGE_INFOS);
     stmt->setUInt64(0, packet.RaceOrFactionChangeInfo->Guid.GetCounter());
 
     _charFactionChangeCallback.SetParam(packet.RaceOrFactionChangeInfo);
     _charFactionChangeCallback.SetFutureResult(CharacterDatabase.AsyncQuery(stmt));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleCharRenameCallBack	(	PreparedQueryResult	result,
		WorldPackets::Character::CharacterRenameInfo *	renameInfo
	)

 {
     ASSERT(_charRenameCallback.GetParam().get() == renameInfo);
 
     if (!result)
     {
         SendCharRename(CHAR_CREATE_ERROR, renameInfo);
         return;
     }
 
     Field* fields = result->Fetch();
 
     std::string oldName = fields[0].GetString();
     uint16 atLoginFlags = fields[1].GetUInt16();
 
     if (!(atLoginFlags & AT_LOGIN_RENAME))
     {
         SendCharRename(CHAR_CREATE_ERROR, renameInfo);
         return;
     }
 
     atLoginFlags &= ~AT_LOGIN_RENAME;
 
     SQLTransaction trans = CharacterDatabase.BeginTransaction();
     ObjectGuid::LowType lowGuid = renameInfo->Guid.GetCounter();
 
     // Update name and at_login flag in the db
     PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_CHAR_NAME_AT_LOGIN);
     stmt->setString(0, renameInfo->NewName);
     stmt->setUInt16(1, atLoginFlags);
     stmt->setUInt64(2, lowGuid);
 
     trans->Append(stmt);
 
     // Removed declined name from db
     stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_DECLINED_NAME);
     stmt->setUInt64(0, lowGuid);
 
     trans->Append(stmt);
 
     CharacterDatabase.CommitTransaction(trans);
 
     TC_LOG_INFO("entities.player.character", "Account: %u (IP: %s) Character:[%s] (%s) Changed name to: %s",
         GetAccountId(), GetRemoteAddress().c_str(), oldName.c_str(), renameInfo->Guid.ToString().c_str(), renameInfo->NewName.c_str());
 
     SendCharRename(RESPONSE_SUCCESS, renameInfo);
 
     sWorld->UpdateCharacterInfo(renameInfo->Guid, renameInfo->NewName);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (!IsLegitCharacterForAccount(request.RenameInfo->Guid))
     {
         TC_LOG_ERROR("network", "Account %u, IP: %s tried to rename character %s, but it does not belong to their account!",
             GetAccountId(), GetRemoteAddress().c_str(), request.RenameInfo->Guid.ToString().c_str());
         KickPlayer();
         return;
     }
 
     // prevent character rename to invalid name
     if (!normalizePlayerName(request.RenameInfo->NewName))
     {
         SendCharRename(CHAR_NAME_NO_NAME, request.RenameInfo.get());
         return;
     }
 
     ResponseCodes res = ObjectMgr::CheckPlayerName(request.RenameInfo->NewName, GetSessionDbcLocale(), true);
     if (res != CHAR_NAME_SUCCESS)
     {
         SendCharRename(res, request.RenameInfo.get());
         return;
     }
 
     // check name limitations
     if (!HasPermission(rbac::RBAC_PERM_SKIP_CHECK_CHARACTER_CREATION_RESERVEDNAME) && sObjectMgr->IsReservedName(request.RenameInfo->NewName))
     {
         SendCharRename(CHAR_NAME_RESERVED, request.RenameInfo.get());
         return;
     }
 
     // Ensure that there is no character with the desired new name
     PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_FREE_NAME);
     stmt->setUInt64(0, request.RenameInfo->Guid.GetCounter());
     stmt->setString(1, request.RenameInfo->NewName);
 
     _charRenameCallback.SetParam(request.RenameInfo);
     _charRenameCallback.SetFutureResult(CharacterDatabase.AsyncQuery(stmt));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleCharUndeleteCallback	(	PreparedQueryResult	result,
		WorldPackets::Character::CharacterUndeleteInfo *	undeleteInfo
	)

This is a series of callbacks executed consecutively as a result from the database becomes available. This is much more efficient than synchronous requests on packet handler. It also prevents data synchronisation errors.

Todo:

: add more safety checks

max char count per account
max heroic char count
team violation

 {
     ASSERT(_charUndeleteCallback.GetParam().get() == undeleteInfo);
 
     switch (_charUndeleteCallback.GetStage())
     {
         case 1:
         {
             if (result)
             {
                 uint32 lastUndelete = result->Fetch()[0].GetUInt32();
                 uint32 maxCooldown = sWorld->getIntConfig(CONFIG_FEATURE_SYSTEM_CHARACTER_UNDELETE_COOLDOWN);
                 if (lastUndelete && (lastUndelete + maxCooldown > time(nullptr)))
                 {
                     SendUndeleteCharacterResponse(CHARACTER_UNDELETE_RESULT_ERROR_COOLDOWN, undeleteInfo);
                     _charUndeleteCallback.Reset();
                     return;
                 }
             }
 
             PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHAR_DEL_INFO_BY_GUID);
             stmt->setUInt64(0, undeleteInfo->CharacterGuid.GetCounter());
 
             _charUndeleteCallback.FreeResult();
             _charUndeleteCallback.SetFutureResult(CharacterDatabase.AsyncQuery(stmt));
             _charUndeleteCallback.NextStage();
             break;
         }
         case 2:
         {
             if (!result)
             {
                 SendUndeleteCharacterResponse(CHARACTER_UNDELETE_RESULT_ERROR_CHAR_CREATE, undeleteInfo);
                 _charUndeleteCallback.Reset();
                 return;
             }
 
             Field* fields = result->Fetch();
             undeleteInfo->Name = fields[1].GetString();
             uint32 account = fields[2].GetUInt32();
 
             if (account != GetAccountId())
             {
                 SendUndeleteCharacterResponse(CHARACTER_UNDELETE_RESULT_ERROR_UNKNOWN, undeleteInfo);
                 _charUndeleteCallback.Reset();
                 return;
             }
 
             PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHECK_NAME);
             stmt->setString(0, undeleteInfo->Name);
 
             _charUndeleteCallback.FreeResult();
             _charUndeleteCallback.SetFutureResult(CharacterDatabase.AsyncQuery(stmt));
             _charUndeleteCallback.NextStage();
             break;
         }
         case 3:
         {
             if (result)
             {
                 SendUndeleteCharacterResponse(CHARACTER_UNDELETE_RESULT_ERROR_NAME_TAKEN_BY_THIS_ACCOUNT, undeleteInfo);
                 _charUndeleteCallback.Reset();
                 return;
             }
 
 
             PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_SUM_CHARS);
             stmt->setUInt32(0, GetAccountId());
 
             _charUndeleteCallback.FreeResult();
             _charUndeleteCallback.SetFutureResult(CharacterDatabase.AsyncQuery(stmt));
             _charUndeleteCallback.NextStage();
             break;
         }
         case 4:
         {
             if (result)
             {
                 Field* fields = result->Fetch();
 
                 if (fields[0].GetUInt64() >= sWorld->getIntConfig(CONFIG_CHARACTERS_PER_REALM)) // SQL's COUNT() returns uint64 but it will always be less than uint8.Max
                 {
                     SendUndeleteCharacterResponse(CHARACTER_UNDELETE_RESULT_ERROR_CHAR_CREATE, undeleteInfo);
                     _charUndeleteCallback.Reset();
                     return;
                 }
             }
 
             PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_RESTORE_DELETE_INFO);
             stmt->setString(0, undeleteInfo->Name);
             stmt->setUInt32(1, GetAccountId());
             stmt->setUInt64(2, undeleteInfo->CharacterGuid.GetCounter());
             CharacterDatabase.Execute(stmt);
 
             stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_LAST_CHAR_UNDELETE);
             stmt->setUInt32(0, GetBattlenetAccountId());
             LoginDatabase.Execute(stmt);
 
             sWorld->UpdateCharacterInfoDeleted(undeleteInfo->CharacterGuid, false, &undeleteInfo->Name);
 
             SendUndeleteCharacterResponse(CHARACTER_UNDELETE_RESULT_OK, undeleteInfo);
             _charUndeleteCallback.Reset();
             break;
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleCharUndeleteEnum ( PreparedQueryResult result )

 {
     WorldPackets::Character::EnumCharactersResult charEnum;
     charEnum.Success = true;
     charEnum.IsDeletedCharacters = true;
 
     if (result)
     {
         do
         {
             Field* fields = result->Fetch();
             WorldPackets::Character::EnumCharactersResult::CharacterInfo charInfo(fields);
 
             TC_LOG_INFO("network", "Loading undeleted char guid %s from account %u.", charInfo.Guid.ToString().c_str(), GetAccountId());
 
             if (!sWorld->HasCharacterInfo(charInfo.Guid)) // This can happen if characters are inserted into the database manually. Core hasn't loaded name data yet.
                 sWorld->AddCharacterInfo(charInfo.Guid, GetAccountId(), charInfo.Name, charInfo.Sex, charInfo.Race, charInfo.Class, charInfo.Level, true);
 
             charEnum.Characters.emplace_back(charInfo);
         }
         while (result->NextRow());
     }
 
     SendPacket(charEnum.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

get all the data necessary for loading all undeleted characters (along with their pets) on the account

 {
     PreparedStatement* stmt = nullptr;
     if (sWorld->getBoolConfig(CONFIG_DECLINED_NAMES_USED))
         stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_UNDELETE_ENUM_DECLINED_NAME);
     else
         stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_UNDELETE_ENUM);
 
     stmt->setUInt8(0, PET_SAVE_AS_CURRENT);
     stmt->setUInt32(1, GetAccountId());
 
     _charEnumCallback.SetParam(true);
     _charEnumCallback.SetFutureResult(CharacterDatabase.AsyncQuery(stmt));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (!sWorld->getBoolConfig(CONFIG_FEATURE_SYSTEM_CHARACTER_UNDELETE_ENABLED))
     {
         SendUndeleteCharacterResponse(CHARACTER_UNDELETE_RESULT_ERROR_DISABLED, undeleteInfo.UndeleteInfo.get());
         return;
     }
 
     PreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_LAST_CHAR_UNDELETE);
     stmt->setUInt32(0, GetBattlenetAccountId());
 
     _charUndeleteCallback.SetParam(undeleteInfo.UndeleteInfo);
     _charUndeleteCallback.SetFutureResult(LoginDatabase.AsyncQuery(stmt));
     _charUndeleteCallback.NextStage();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleChatAddonMessage	(	ChatMsg	type,
		std::string	prefix,
		std::string	text,
		std::string	target = `""`
	)

 {
     Player* sender = GetPlayer();
 
     if (prefix.empty() || prefix.length() > 16)
         return;
 
     // Disabled addon channel?
     if (!sWorld->getBoolConfig(CONFIG_ADDON_CHANNEL))
         return;
 
     switch (type)
     {
         case CHAT_MSG_GUILD:
         case CHAT_MSG_OFFICER:
         {
             if (sender->GetGuildId())
                 if (Guild* guild = sGuildMgr->GetGuildById(sender->GetGuildId()))
                     guild->BroadcastAddonToGuild(this, type == CHAT_MSG_OFFICER, text, prefix);
             break;
         }
         case CHAT_MSG_WHISPER:
         {
             if (!normalizePlayerName(target))
                 break;
 
             Player* receiver = ObjectAccessor::FindPlayerByName(target);
             if (!receiver)
                 break;
 
             sender->WhisperAddon(text, prefix, receiver);
             break;
         }
         // Messages sent to "RAID" while in a party will get delivered to "PARTY"
         case CHAT_MSG_PARTY:
         case CHAT_MSG_RAID:
         case CHAT_MSG_INSTANCE_CHAT:
         {
             Group* group = nullptr;
             int32 subGroup = -1;
             if (type != CHAT_MSG_INSTANCE_CHAT)
                 group = sender->GetOriginalGroup();
 
             if (!group)
             {
                 group = sender->GetGroup();
                 if (!group)
                     break;
 
                 if (type == CHAT_MSG_PARTY)
                     subGroup = sender->GetSubGroup();
             }
 
             WorldPackets::Chat::Chat packet;
             packet.Initialize(type, LANG_ADDON, sender, nullptr, text, 0, "", DEFAULT_LOCALE, prefix);
             group->BroadcastAddonMessagePacket(packet.Write(), prefix, true, subGroup, sender->GetGUID());
             break;
         }
         case CHAT_MSG_CHANNEL:
         {
             if (ChannelMgr* cMgr = ChannelMgr::ForTeam(sender->GetTeam()))
                 if (Channel* chn = cMgr->GetChannel(target, sender, false))
                     chn->Say(sender->GetGUID(), text.c_str(), uint32(LANG_ADDON));
             break;
         }
         default:
         {
             TC_LOG_ERROR("misc", "HandleAddonMessagechatOpcode: unknown addon message type %u", type);
             break;
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleChatAddonMessageChannelOpcode ( WorldPackets::Chat::ChatAddonMessageChannel & chatAddonMessageChannel )

 {
     HandleChatAddonMessage(CHAT_MSG_CHANNEL, chatAddonMessageChannel.Prefix, chatAddonMessageChannel.Text, chatAddonMessageChannel.Target);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     ChatMsg type;
 
     switch (chatAddonMessage.GetOpcode())
     {
         case CMSG_CHAT_ADDON_MESSAGE_GUILD:
             type = CHAT_MSG_GUILD;
             break;
         case CMSG_CHAT_ADDON_MESSAGE_OFFICER:
             type = CHAT_MSG_OFFICER;
             break;
         case CMSG_CHAT_ADDON_MESSAGE_PARTY:
             type = CHAT_MSG_PARTY;
             break;
         case CMSG_CHAT_ADDON_MESSAGE_RAID:
             type = CHAT_MSG_RAID;
             break;
         case CMSG_CHAT_ADDON_MESSAGE_INSTANCE_CHAT:
             type = CHAT_MSG_INSTANCE_CHAT;
             break;
         default:
             TC_LOG_ERROR("network", "HandleChatAddonMessageOpcode: Unknown addon chat opcode (%u)", chatAddonMessage.GetOpcode());
             return;
     }
 
     HandleChatAddonMessage(type, chatAddonMessage.Prefix, chatAddonMessage.Text);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleChatAddonMessageWhisperOpcode ( WorldPackets::Chat::ChatAddonMessageWhisper & chatAddonMessageWhisper )

 {
     HandleChatAddonMessage(CHAT_MSG_WHISPER, chatAddonMessageWhisper.Prefix, chatAddonMessageWhisper.Text, chatAddonMessageWhisper.Target);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     Player* player = ObjectAccessor::FindConnectedPlayer(chatReportIgnored.IgnoredGUID);
     if (!player || !player->GetSession())
         return;
 
     WorldPackets::Chat::Chat packet;
     packet.Initialize(CHAT_MSG_IGNORED, LANG_UNIVERSAL, _player, _player, GetPlayer()->GetName());
     player->SendDirectMessage(packet.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleChatMessage	(	ChatMsg	type,
		uint32	lang,
		std::string	msg,
		std::string	target = `""`
	)

Todo:: implement cross realm whispers (someday)

 {
     Player* sender = GetPlayer();
 
     if (lang == LANG_UNIVERSAL && type != CHAT_MSG_EMOTE)
     {
         TC_LOG_ERROR("network", "CMSG_MESSAGECHAT: Possible hacking-attempt: %s tried to send a message in universal language", GetPlayerInfo().c_str());
         SendNotification(LANG_UNKNOWN_LANGUAGE);
         return;
     }
 
     // prevent talking at unknown language (cheating)
     LanguageDesc const* langDesc = GetLanguageDescByID(lang);
     if (!langDesc)
     {
         SendNotification(LANG_UNKNOWN_LANGUAGE);
         return;
     }
 
     if (langDesc->skill_id != 0 && !sender->HasSkill(langDesc->skill_id))
     {
         // also check SPELL_AURA_COMPREHEND_LANGUAGE (client offers option to speak in that language)
         Unit::AuraEffectList const& langAuras = sender->GetAuraEffectsByType(SPELL_AURA_COMPREHEND_LANGUAGE);
         bool foundAura = false;
         for (Unit::AuraEffectList::const_iterator i = langAuras.begin(); i != langAuras.end(); ++i)
         {
             if ((*i)->GetMiscValue() == int32(lang))
             {
                 foundAura = true;
                 break;
             }
         }
         if (!foundAura)
         {
             SendNotification(LANG_NOT_LEARNED_LANGUAGE);
             return;
         }
     }
 
     // send in universal language if player in .gm on mode (ignore spell effects)
     if (sender->IsGameMaster())
         lang = LANG_UNIVERSAL;
     else
     {
         // send in universal language in two side iteration allowed mode
         if (HasPermission(rbac::RBAC_PERM_TWO_SIDE_INTERACTION_CHAT))
             lang = LANG_UNIVERSAL;
         else
         {
             switch (type)
             {
                 case CHAT_MSG_PARTY:
                 case CHAT_MSG_RAID:
                 case CHAT_MSG_RAID_WARNING:
                     // allow two side chat at group channel if two side group allowed
                     if (sWorld->getBoolConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_GROUP))
                         lang = LANG_UNIVERSAL;
                     break;
                 case CHAT_MSG_GUILD:
                 case CHAT_MSG_OFFICER:
                     // allow two side chat at guild channel if two side guild allowed
                     if (sWorld->getBoolConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_GUILD))
                         lang = LANG_UNIVERSAL;
                     break;
                 default:
                     break;
             }
         }
 
         // but overwrite it by SPELL_AURA_MOD_LANGUAGE auras (only single case used)
         Unit::AuraEffectList const& ModLangAuras = sender->GetAuraEffectsByType(SPELL_AURA_MOD_LANGUAGE);
         if (!ModLangAuras.empty())
             lang = ModLangAuras.front()->GetMiscValue();
     }
 
     if (!sender->CanSpeak())
     {
         std::string timeStr = secsToTimeString(m_muteTime - time(NULL));
         SendNotification(GetTrinityString(LANG_WAIT_BEFORE_SPEAKING), timeStr.c_str());
         return;
     }
 
     if (sender->HasAura(GM_SILENCE_AURA) && type != CHAT_MSG_WHISPER)
     {
         SendNotification(GetTrinityString(LANG_GM_SILENCE), sender->GetName().c_str());
         return;
     }
 
     if (msg.empty())
         return;
 
     if (ChatHandler(this).ParseCommands(msg.c_str()))
         return;
 
     // Strip invisible characters for non-addon messages
     if (sWorld->getBoolConfig(CONFIG_CHAT_FAKE_MESSAGE_PREVENTING))
         stripLineInvisibleChars(msg);
 
     if (sWorld->getIntConfig(CONFIG_CHAT_STRICT_LINK_CHECKING_SEVERITY) && !ChatHandler(this).isValidChatMessage(msg.c_str()))
     {
         TC_LOG_ERROR("network", "Player %s (%s) sent a chatmessage with an invalid link: %s", GetPlayer()->GetName().c_str(),
             GetPlayer()->GetGUID().ToString().c_str(), msg.c_str());
 
         if (sWorld->getIntConfig(CONFIG_CHAT_STRICT_LINK_CHECKING_KICK))
             KickPlayer();
 
         return;
     }
 
     switch (type)
     {
         case CHAT_MSG_SAY:
         case CHAT_MSG_EMOTE:
         case CHAT_MSG_YELL:
         {
             // Prevent cheating
             if (!sender->IsAlive())
                 return;
 
             if (sender->getLevel() < sWorld->getIntConfig(CONFIG_CHAT_SAY_LEVEL_REQ))
             {
                 SendNotification(GetTrinityString(LANG_SAY_REQ), sWorld->getIntConfig(CONFIG_CHAT_SAY_LEVEL_REQ));
                 return;
             }
 
             if (type == CHAT_MSG_SAY)
                 sender->Say(msg, Language(lang));
             else if (type == CHAT_MSG_EMOTE)
                 sender->TextEmote(msg);
             else if (type == CHAT_MSG_YELL)
                 sender->Yell(msg, Language(lang));
             break;
         }
         case CHAT_MSG_WHISPER:
         {
             ExtendedPlayerName extName = ExtractExtendedPlayerName(target);
 
             if (!normalizePlayerName(extName.Name))
             {
                 SendChatPlayerNotfoundNotice(target);
                 break;
             }
 
             Player* receiver = ObjectAccessor::FindConnectedPlayerByName(extName.Name);
             if (!receiver || (lang != LANG_ADDON && !receiver->isAcceptWhispers() && receiver->GetSession()->HasPermission(rbac::RBAC_PERM_CAN_FILTER_WHISPERS) && !receiver->IsInWhisperWhiteList(sender->GetGUID())))
             {
                 SendChatPlayerNotfoundNotice(target);
                 return;
             }
             if (!sender->IsGameMaster() && sender->getLevel() < sWorld->getIntConfig(CONFIG_CHAT_WHISPER_LEVEL_REQ) && !receiver->IsInWhisperWhiteList(sender->GetGUID()))
             {
                 SendNotification(GetTrinityString(LANG_WHISPER_REQ), sWorld->getIntConfig(CONFIG_CHAT_WHISPER_LEVEL_REQ));
                 return;
             }
 
             if (GetPlayer()->GetTeam() != receiver->GetTeam() && !HasPermission(rbac::RBAC_PERM_TWO_SIDE_INTERACTION_CHAT) && !receiver->IsInWhisperWhiteList(sender->GetGUID()))
             {
                 SendChatPlayerNotfoundNotice(target);
                 return;
             }
 
             if (GetPlayer()->HasAura(1852) && !receiver->IsGameMaster())
             {
                 SendNotification(GetTrinityString(LANG_GM_SILENCE), GetPlayer()->GetName().c_str());
                 return;
             }
 
             // If player is a Gamemaster and doesn't accept whisper, we auto-whitelist every player that the Gamemaster is talking to
             // We also do that if a player is under the required level for whispers.
             if (receiver->getLevel() < sWorld->getIntConfig(CONFIG_CHAT_WHISPER_LEVEL_REQ) ||
                 (HasPermission(rbac::RBAC_PERM_CAN_FILTER_WHISPERS) && !sender->isAcceptWhispers() && !sender->IsInWhisperWhiteList(receiver->GetGUID())))
                 sender->AddWhisperWhiteList(receiver->GetGUID());
 
             GetPlayer()->Whisper(msg, Language(lang), receiver);
             break;
         }
         case CHAT_MSG_PARTY:
         {
             // if player is in battleground, he cannot say to battleground members by /p
             Group* group = GetPlayer()->GetOriginalGroup();
             if (!group)
             {
                 group = sender->GetGroup();
                 if (!group || group->isBGGroup())
                     return;
             }
 
             if (group->IsLeader(GetPlayer()->GetGUID()))
                 type = CHAT_MSG_PARTY_LEADER;
 
             sScriptMgr->OnPlayerChat(GetPlayer(), type, lang, msg, group);
 
             WorldPackets::Chat::Chat packet;
             packet.Initialize(ChatMsg(type), Language(lang), sender, nullptr, msg);
             group->BroadcastPacket(packet.Write(), false, group->GetMemberGroup(GetPlayer()->GetGUID()));
             break;
         }
         case CHAT_MSG_GUILD:
         {
             if (GetPlayer()->GetGuildId())
             {
                 if (Guild* guild = sGuildMgr->GetGuildById(GetPlayer()->GetGuildId()))
                 {
                     sScriptMgr->OnPlayerChat(GetPlayer(), type, lang, msg, guild);
 
                     guild->BroadcastToGuild(this, false, msg, lang == LANG_ADDON ? LANG_ADDON : LANG_UNIVERSAL);
                 }
             }
             break;
         }
         case CHAT_MSG_OFFICER:
         {
             if (GetPlayer()->GetGuildId())
             {
                 if (Guild* guild = sGuildMgr->GetGuildById(GetPlayer()->GetGuildId()))
                 {
                     sScriptMgr->OnPlayerChat(GetPlayer(), type, lang, msg, guild);
 
                     guild->BroadcastToGuild(this, true, msg, lang == LANG_ADDON ? LANG_ADDON : LANG_UNIVERSAL);
                 }
             }
             break;
         }
         case CHAT_MSG_RAID:
         {
             Group* group = GetPlayer()->GetGroup();
             if (!group || !group->isRaidGroup() || group->isBGGroup())
                 return;
 
             if (group->IsLeader(GetPlayer()->GetGUID()))
                 type = CHAT_MSG_RAID_LEADER;
 
             sScriptMgr->OnPlayerChat(GetPlayer(), type, lang, msg, group);
 
             WorldPackets::Chat::Chat packet;
             packet.Initialize(ChatMsg(type), Language(lang), sender, nullptr, msg);
             group->BroadcastPacket(packet.Write(), false);
             break;
         }
         case CHAT_MSG_RAID_WARNING:
         {
             Group* group = GetPlayer()->GetGroup();
             if (!group || !group->isRaidGroup() || !(group->IsLeader(GetPlayer()->GetGUID()) || group->IsAssistant(GetPlayer()->GetGUID())) || group->isBGGroup())
                 return;
 
             sScriptMgr->OnPlayerChat(GetPlayer(), type, lang, msg, group);
 
             WorldPackets::Chat::Chat packet;
             //in battleground, raid warning is sent only to players in battleground - code is ok
             packet.Initialize(CHAT_MSG_RAID_WARNING, Language(lang), sender, NULL, msg);
             group->BroadcastPacket(packet.Write(), false);
             break;
         }
         case CHAT_MSG_CHANNEL:
         {
             if (!HasPermission(rbac::RBAC_PERM_SKIP_CHECK_CHAT_CHANNEL_REQ))
             {
                 if (sender->getLevel() < sWorld->getIntConfig(CONFIG_CHAT_CHANNEL_LEVEL_REQ))
                 {
                     SendNotification(GetTrinityString(LANG_CHANNEL_REQ), sWorld->getIntConfig(CONFIG_CHAT_CHANNEL_LEVEL_REQ));
                     return;
                 }
             }
 
             if (ChannelMgr* cMgr = ChannelMgr::ForTeam(sender->GetTeam()))
             {
                 if (Channel* chn = cMgr->GetChannel(target, sender))
                 {
                     sScriptMgr->OnPlayerChat(sender, type, lang, msg, chn);
                     chn->Say(sender->GetGUID(), msg.c_str(), lang);
                 }
             }
             break;
         }
         case CHAT_MSG_INSTANCE_CHAT:
         {
             Group* group = GetPlayer()->GetGroup();
             if (!group)
                 return;
 
             if (group->IsLeader(GetPlayer()->GetGUID()))
                 type = CHAT_MSG_INSTANCE_CHAT_LEADER;
 
             sScriptMgr->OnPlayerChat(GetPlayer(), type, lang, msg, group);
 
             WorldPackets::Chat::Chat packet;
             packet.Initialize(ChatMsg(type), Language(lang), sender, nullptr, msg);
             group->BroadcastPacket(packet.Write(), false);
             break;
         }
         default:
             TC_LOG_ERROR("network", "CHAT: unknown message type %u, lang: %u", type, lang);
             break;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     Player* sender = GetPlayer();
 
     if (sender->IsInCombat())
         return;
 
     if (sender->HasAura(GM_SILENCE_AURA))
     {
         SendNotification(GetTrinityString(LANG_GM_SILENCE), sender->GetName().c_str());
         return;
     }
 
     if (sender->isAFK()) // Already AFK
     {
         if (chatMessageAFK.Text.empty())
             sender->ToggleAFK(); // Remove AFK
         else
             sender->autoReplyMsg = chatMessageAFK.Text; // Update message
     }
     else // New AFK mode
     {
         sender->autoReplyMsg = chatMessageAFK.Text.empty() ? GetTrinityString(LANG_PLAYER_AFK_DEFAULT) : chatMessageAFK.Text;
 
         if (sender->isDND())
             sender->ToggleDND();
 
         sender->ToggleAFK();
     }
 
     sScriptMgr->OnPlayerChat(sender, CHAT_MSG_AFK, LANG_UNIVERSAL, chatMessageAFK.Text);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     HandleChatMessage(CHAT_MSG_CHANNEL, chatMessageChannel.Language, chatMessageChannel.Text, chatMessageChannel.Target);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     Player* sender = GetPlayer();
 
     if (sender->IsInCombat())
         return;
 
     if (sender->HasAura(GM_SILENCE_AURA))
     {
         SendNotification(GetTrinityString(LANG_GM_SILENCE), sender->GetName().c_str());
         return;
     }
 
     if (sender->isDND()) // Already DND
     {
         if (chatMessageDND.Text.empty())
             sender->ToggleDND(); // Remove DND
         else
             sender->autoReplyMsg = chatMessageDND.Text; // Update message
     }
     else // New DND mode
     {
         sender->autoReplyMsg = chatMessageDND.Text.empty() ? GetTrinityString(LANG_PLAYER_DND_DEFAULT) : chatMessageDND.Text;
 
         if (sender->isAFK())
             sender->ToggleAFK();
 
         sender->ToggleDND();
     }
 
     sScriptMgr->OnPlayerChat(sender, CHAT_MSG_DND, LANG_UNIVERSAL, chatMessageDND.Text);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     HandleChatMessage(CHAT_MSG_EMOTE, LANG_UNIVERSAL, chatMessageEmote.Text);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     ChatMsg type;
 
     switch (chatMessage.GetOpcode())
     {
         case CMSG_CHAT_MESSAGE_SAY:
             type = CHAT_MSG_SAY;
             break;
         case CMSG_CHAT_MESSAGE_YELL:
             type = CHAT_MSG_YELL;
             break;
         case CMSG_CHAT_MESSAGE_GUILD:
             type = CHAT_MSG_GUILD;
             break;
         case CMSG_CHAT_MESSAGE_OFFICER:
             type = CHAT_MSG_OFFICER;
             break;
         case CMSG_CHAT_MESSAGE_PARTY:
             type = CHAT_MSG_PARTY;
             break;
         case CMSG_CHAT_MESSAGE_RAID:
             type = CHAT_MSG_RAID;
             break;
         case CMSG_CHAT_MESSAGE_RAID_WARNING:
             type = CHAT_MSG_RAID_WARNING;
             break;
         case CMSG_CHAT_MESSAGE_INSTANCE_CHAT:
             type = CHAT_MSG_INSTANCE_CHAT;
             break;
         default:
             TC_LOG_ERROR("network", "HandleMessagechatOpcode : Unknown chat opcode (%u)", chatMessage.GetOpcode());
             return;
     }
 
     HandleChatMessage(type, chatMessage.Language, chatMessage.Text);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     HandleChatMessage(CHAT_MSG_WHISPER, chatMessageWhisper.Language, chatMessageWhisper.Text, chatMessageWhisper.Target);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     Group* group = GetPlayer()->GetGroup();
     if (!group)
         return;
 
     if (group->isRaidGroup() && !group->IsLeader(GetPlayer()->GetGUID()) && !group->IsAssistant(GetPlayer()->GetGUID()))
         return;
 
     group->DeleteRaidMarker(packet.MarkerId);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     TradeData* my_trade = _player->m_trade;
     if (!my_trade)
         return;
 
     my_trade->UpdateClientStateIndex();
 
     // invalid slot number
     if (clearTradeItem.TradeSlot >= TRADE_SLOT_COUNT)
         return;
 
     my_trade->SetItem(TradeSlots(clearTradeItem.TradeSlot), NULL);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {    // NOTE: all chat messages from this spammer are automatically ignored by the spam reporter until logout in case of chat spam.
      // if it's mail spam - ALL mails from this spammer are automatically removed by client
 
     WorldPackets::Ticket::ComplaintResult result;
     result.ComplaintType = packet.ComplaintType;
     result.Result = 0;
     SendPacket(result.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

690 {

691 }

Here is the caller graph for this function:

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

 {
     Creature* unit = GetPlayer()->GetNPCIfCanInteractWith(confirmRespecWipe.RespecMaster, UNIT_NPC_FLAG_TRAINER);
     if (!unit)
     {
         TC_LOG_DEBUG("network", "WORLD: HandleConfirmRespecWipeOpcode - %s not found or you can't interact with him.", confirmRespecWipe.RespecMaster.ToString().c_str());
         return;
     }
 
     if (confirmRespecWipe.RespecType != SPEC_RESET_TALENTS)
     {
         TC_LOG_DEBUG("network", "WORLD: HandleConfirmRespecWipeOpcode - reset type %d is not implemented.", confirmRespecWipe.RespecType);
         return;
     }
 
     if (!unit->isCanTrainingAndResetTalentsOf(_player))
         return;
 
     // remove fake death
     if (GetPlayer()->HasUnitState(UNIT_STATE_DIED))
         GetPlayer()->RemoveAurasByType(SPELL_AURA_FEIGN_DEATH);
 
     if (!_player->ResetTalents())
     {
         GetPlayer()->SendRespecWipeConfirm(ObjectGuid::Empty, 0);
         return;
     }
 
     _player->SendTalentsInfoData();
     unit->CastSpell(_player, 14867, true);                  //spell: "Untalent Visual Effect"
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     TC_LOG_DEBUG("network", "WorldSession::HandleContactListOpcode: Flags: %u", packet.Flags);
     _player->GetSocial()->SendSocialList(_player, packet.Flags);
 }

Here is the caller graph for this function:

void WorldSession::HandleContinuePlayerLogin ( )

 {
     if (!PlayerLoading() || GetPlayer())
     {
         KickPlayer();
         return;
     }
 
     LoginQueryHolder* holder = new LoginQueryHolder(GetAccountId(), m_playerLoading);
     if (!holder->Initialize())
     {
         delete holder;                                      // delete all unprocessed queries
         m_playerLoading.Clear();
         return;
     }
 
     SendPacket(WorldPackets::Auth::ResumeComms(CONNECTION_TYPE_INSTANCE).Write());
 
     _charLoginCallback = CharacterDatabase.DelayQueryHolder(holder);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     Group* group = GetPlayer()->GetGroup();
     if (!group)
         return;
 
     if (_player->InBattleground())
         return;
 
     // error handling
     if (!group->IsLeader(GetPlayer()->GetGUID()) || group->GetMembersCount() < 2)
         return;
 
     // everything's fine, do it (is it 0 (PARTY_OP_INVITE) correct code)
     SendPartyResult(PARTY_OP_INVITE, "", ERR_PARTY_RESULT_OK);
 
     // New 4.x: it is now possible to convert a raid to a group if member count is 5 or less
     if (packet.Raid)
         group->ConvertToRaid();
     else
         group->ConvertToGroup();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleCreatureQuery ( WorldPackets::Query::QueryCreature & packet )

Only static data is sent in this packet !!!

 {
     WorldPackets::Query::QueryCreatureResponse response;
 
     CreatureTemplate const* creatureInfo = sObjectMgr->GetCreatureTemplate(packet.CreatureID);
 
     response.CreatureID = packet.CreatureID;
 
     if (creatureInfo)
     {
         response.Allow = true;
 
         WorldPackets::Query::CreatureStats& stats = response.Stats;
 
         stats.Leader = creatureInfo->RacialLeader;
 
         stats.Name[0] = creatureInfo->Name;
         stats.NameAlt[0] = creatureInfo->FemaleName;
 
         stats.Flags[0] = creatureInfo->type_flags;
         stats.Flags[1] = creatureInfo->type_flags2;
 
         stats.CreatureType = creatureInfo->type;
         stats.CreatureFamily = creatureInfo->family;
         stats.Classification = creatureInfo->rank;
 
         for (uint32 i = 0; i < MAX_KILL_CREDIT; ++i)
             stats.ProxyCreatureID[i] = creatureInfo->KillCredit[i];
 
         stats.CreatureDisplayID[0] = creatureInfo->Modelid1;
         stats.CreatureDisplayID[1] = creatureInfo->Modelid2;
         stats.CreatureDisplayID[2] = creatureInfo->Modelid3;
         stats.CreatureDisplayID[3] = creatureInfo->Modelid4;
 
         stats.HpMulti = creatureInfo->ModHealth;
         stats.EnergyMulti = creatureInfo->ModMana;
 
         stats.CreatureMovementInfoID = creatureInfo->movementId;
         stats.RequiredExpansion = creatureInfo->expansionUnknown;
 
         stats.Title = creatureInfo->SubName;
         //stats.TitleAlt = ;
         stats.CursorName = creatureInfo->IconName;
 
         if (CreatureQuestItemList const* items = sObjectMgr->GetCreatureQuestItemList(packet.CreatureID))
             for (uint32 item : *items)
                 stats.QuestItems.push_back(item);
 
         LocaleConstant localeConstant = GetSessionDbLocaleIndex();
         if (localeConstant >= LOCALE_enUS)
             if (CreatureLocale const* creatureLocale = sObjectMgr->GetCreatureLocale(packet.CreatureID))
             {
                 ObjectMgr::GetLocaleString(creatureLocale->Name, localeConstant, stats.Name[0]);
                 ObjectMgr::GetLocaleString(creatureLocale->NameAlt, localeConstant, stats.NameAlt[0]);
                 ObjectMgr::GetLocaleString(creatureLocale->Title, localeConstant, stats.Title);
                 ObjectMgr::GetLocaleString(creatureLocale->TitleAlt, localeConstant, stats.TitleAlt);
             }
     }
 
     SendPacket(response.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleDBQueryBulk ( WorldPackets::Query::DBQueryBulk & packet )

 {
     DB2StorageBase const* store = sDB2Manager.GetStorage(packet.TableHash);
     if (!store)
     {
         TC_LOG_ERROR("network", "CMSG_DB_QUERY_BULK: %s requested unsupported unknown hotfix type: %u", GetPlayerInfo().c_str(), packet.TableHash);
         return;
     }
 
     for (WorldPackets::Query::DBQueryBulk::DBQueryRecord const& rec : packet.Queries)
     {
         WorldPackets::Query::DBReply response;
         response.TableHash = packet.TableHash;
         response.RecordID = rec.RecordID;
 
         if (store->HasRecord(rec.RecordID))
         {
             response.Allow = true;
             response.Timestamp = sDB2Manager.GetHotfixDate(rec.RecordID, packet.TableHash);
             store->WriteRecord(rec.RecordID, GetSessionDbcLocale(), response.Data);
         }
         else
         {
             TC_LOG_TRACE("network", "CMSG_DB_QUERY_BULK: %s requested non-existing entry %u in datastore: %u", GetPlayerInfo().c_str(), rec.RecordID, packet.TableHash);
             response.Timestamp = time(NULL);
         }
 
         SendPacket(response.Write());
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     GetPlayer()->ApplyModFlag(PLAYER_FLAGS, PLAYER_FLAGS_AUTO_DECLINE_GUILD, packet.Allow);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     TC_LOG_DEBUG("network", "Petition %s declined by %s", packet.PetitionGUID.ToString().c_str(), _player->GetGUID().ToString().c_str());
 
     PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_PETITION_OWNER_BY_GUID);
     stmt->setUInt64(0, packet.PetitionGUID.GetCounter());
     PreparedQueryResult result = CharacterDatabase.Query(stmt);
 
     if (!result)
         return;
 
     Field* fields = result->Fetch();
     ObjectGuid ownerguid = ObjectGuid::Create<HighGuid::Player>(fields[0].GetUInt64());
 
     Player* owner = ObjectAccessor::FindConnectedPlayer(ownerguid);
     if (owner)                                               // petition owner online
     {
         // Disabled because packet isn't handled by the client in any way
         /*
         WorldPackets::Petition::PetitionDeclined packet;
         packet.Decliner = _player->GetGUID();
         owner->GetSession()->SendPacket(packet.Write());
         */
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     _player->DeleteEquipmentSet(deleteEquipmentSet.ID);
 }

Here is the caller graph for this function:

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

Todo:: : handle VirtualRealmAddress

 {
     TC_LOG_DEBUG("network", "WorldSession::HandleDelFriendOpcode: %s", packet.Player.Guid.ToString().c_str());
 
     GetPlayer()->GetSocial()->RemoveFromSocialList(packet.Player.Guid, SOCIAL_FLAG_FRIEND);
 
     sSocialMgr->SendFriendStatus(GetPlayer(), FRIEND_REMOVED, packet.Player.Guid);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Todo:: : handle VirtualRealmAddress

 {
     TC_LOG_DEBUG("network", "WorldSession::HandleDelIgnoreOpcode: %s", packet.Player.Guid.ToString().c_str());
 
     GetPlayer()->GetSocial()->RemoveFromSocialList(packet.Player.Guid, SOCIAL_FLAG_IGNORED);
 
     sSocialMgr->SendFriendStatus(GetPlayer(), FRIEND_IGNORE_REMOVED, packet.Player.Guid);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     TC_LOG_DEBUG("network", "HandleDestroyItemOpcode: receive ContainerId: %u, SlotNum: %u, Count: %u",
         destroyItem.ContainerId, destroyItem.SlotNum, destroyItem.Count);
 
     uint16 pos = (destroyItem.ContainerId << 8) | destroyItem.SlotNum;
 
     // prevent drop unequipable items (in combat, for example) and non-empty bags
     if (_player->IsEquipmentPos(pos) || _player->IsBagPos(pos))
     {
         InventoryResult msg = _player->CanUnequipItem(pos, false);
         if (msg != EQUIP_ERR_OK)
         {
             _player->SendEquipError(msg, _player->GetItemByPos(pos));
             return;
         }
     }
 
     Item* item  = _player->GetItemByPos(destroyItem.ContainerId, destroyItem.SlotNum);
     if (!item)
     {
         _player->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND);
         return;
     }
 
     if (item->GetTemplate()->GetFlags() & ITEM_FLAG_INDESTRUCTIBLE)
     {
         _player->SendEquipError(EQUIP_ERR_DROP_BOUND_ITEM, NULL, NULL);
         return;
     }
 
     if (destroyItem.Count)
     {
         uint32 i_count = destroyItem.Count;
         _player->DestroyItemCount(item, i_count, true);
     }
     else
         _player->DestroyItem(destroyItem.ContainerId, destroyItem.SlotNum, true);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleDFGetJoinStatus ( WorldPacket & recvData )

 {
     TC_LOG_DEBUG("lfg", "CMSG_DF_GET_JOIN_STATUS %s", GetPlayerInfo().c_str());
 
     if (!GetPlayer()->isUsingLfg())
         return;
 
     ObjectGuid guid = GetPlayer()->GetGUID();
     lfg::LfgUpdateData updateData = sLFGMgr->GetLfgStatus(guid);
 
     if (GetPlayer()->GetGroup())
     {
         SendLfgUpdateStatus(updateData, true);
         updateData.dungeons.clear();
         SendLfgUpdateStatus(updateData, false);
     }
     else
     {
         SendLfgUpdateStatus(updateData, false);
         updateData.dungeons.clear();
         SendLfgUpdateStatus(updateData, true);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleDFGetSystemInfo ( WorldPacket & recvData )

 {
     bool forPlayer = recvData.ReadBit();
     TC_LOG_DEBUG("lfg", "CMSG_DF_GET_SYSTEM_INFO %s for %s", GetPlayerInfo().c_str(), (forPlayer ? "player" : "party"));
 
     if (forPlayer)
         SendLfgPlayerLockInfo();
     else
         SendLfgPartyLockInfo();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     Unit* pet = ObjectAccessor::GetCreatureOrPetOrVehicle(*_player, packet.CritterGUID);
 
     if (!pet)
     {
         TC_LOG_DEBUG("network", "Vanitypet (%s) does not exist - player '%s' (%s / account: %u) attempted to dismiss it (possibly lagged out)",
             packet.CritterGUID.ToString().c_str(), GetPlayer()->GetName().c_str(), GetPlayer()->GetGUID().ToString().c_str(), GetAccountId());
         return;
     }
 
     if (_player->GetCritterGUID() == pet->GetGUID())
     {
          if (pet->GetTypeId() == TYPEID_UNIT && pet->IsSummon())
              pet->ToTempSummon()->UnSummon();
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

error handling

 {
     Group* group = GetPlayer()->GetGroup();
     if (!group)
         return;
 
     if (!group->IsLeader(GetPlayer()->GetGUID()) && !group->IsAssistant(GetPlayer()->GetGUID()))
         return;
     /********************/
 
     // everything's fine, do it
     group->StartReadyCheck(GetPlayer()->GetGUID(), packet.PartyIndex);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleDuelAccepted ( )

 {
     if (!GetPlayer()->duel)                                  // ignore accept from duel-sender
         return;
 
     Player* player = GetPlayer();
     Player* plTarget = player->duel->opponent;
 
     if (player == player->duel->initiator || !plTarget || player == plTarget || player->duel->startTime != 0 || plTarget->duel->startTime != 0)
         return;
 
     TC_LOG_DEBUG("network", "Player 1 is: %s (%s)", player->GetGUID().ToString().c_str(), player->GetName().c_str());
     TC_LOG_DEBUG("network", "Player 2 is: %s (%s)", plTarget->GetGUID().ToString().c_str(), plTarget->GetName().c_str());
 
     time_t now = time(NULL);
     player->duel->startTimer = now;
     plTarget->duel->startTimer = now;
 
     WorldPackets::Duel::DuelCountdown packet(3000); // milliseconds
     WorldPacket const* worldPacket = packet.Write();
     player->GetSession()->SendPacket(worldPacket);
     plTarget->GetSession()->SendPacket(worldPacket);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleDuelCancelled ( )

 {
     // no duel requested
     if (!GetPlayer()->duel)
         return;
 
     // player surrendered in a duel using /forfeit
     if (GetPlayer()->duel->startTime != 0)
     {
         GetPlayer()->CombatStopWithPets(true);
         if (GetPlayer()->duel->opponent)
             GetPlayer()->duel->opponent->CombatStopWithPets(true);
 
         GetPlayer()->CastSpell(GetPlayer(), 7267, true);    // beg
         GetPlayer()->DuelComplete(DUEL_WON);
         return;
     }
 
     GetPlayer()->DuelComplete(DUEL_INTERRUPTED);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (duelResponse.Accepted)
         HandleDuelAccepted();
     else
         HandleDuelCancelled();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     Vehicle* vehicle = _player->GetVehicleKit();
     if (!vehicle)
     {
         TC_LOG_ERROR("network", "HandleEjectPassenger: %s is not in a vehicle!", GetPlayer()->GetGUID().ToString().c_str());
         return;
     }
 
     if (ejectPassenger.Passenger.IsUnit())
     {
         Unit* unit = ObjectAccessor::GetUnit(*_player, ejectPassenger.Passenger);
         if (!unit) // creatures can be ejected too from player mounts
         {
             TC_LOG_ERROR("network", "%s tried to eject %s from vehicle, but the latter was not found in world!", GetPlayer()->GetGUID().ToString().c_str(), ejectPassenger.Passenger.ToString().c_str());
             return;
         }
 
         if (!unit->IsOnVehicle(vehicle->GetBase()))
         {
             TC_LOG_ERROR("network", "%s tried to eject %s, but they are not in the same vehicle", GetPlayer()->GetGUID().ToString().c_str(), ejectPassenger.Passenger.ToString().c_str());
             return;
         }
 
         VehicleSeatEntry const* seat = vehicle->GetSeatForPassenger(unit);
         ASSERT(seat);
         if (seat->IsEjectable())
             unit->ExitVehicle();
         else
             TC_LOG_ERROR("network", "%s attempted to eject %s from non-ejectable seat.", GetPlayer()->GetGUID().ToString().c_str(), ejectPassenger.Passenger.ToString().c_str());
     }
     else
         TC_LOG_ERROR("network", "HandleEjectPassenger: %s tried to eject invalid %s ", GetPlayer()->GetGUID().ToString().c_str(), ejectPassenger.Passenger.ToString().c_str());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (!GetPlayer()->IsAlive() || GetPlayer()->HasUnitState(UNIT_STATE_DIED))
         return;
 
     sScriptMgr->OnPlayerClearEmote(GetPlayer());
 
     if (_player->GetUInt32Value(UNIT_NPC_EMOTESTATE))
         _player->SetUInt32Value(UNIT_NPC_EMOTESTATE, 0);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     Creature* unit = GetPlayer()->GetMap()->GetCreature(enableTaxiNode.Unit);
     SendLearnNewTaxiNode(unit);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

cheating check 1 (item equipped but sent empty guid)

cheating check 2 (sent guid does not match equipped item)

clear invalid bits (i > EQUIPMENT_SLOT_END)

 {
     if (saveEquipmentSet.Set.SetID >= MAX_EQUIPMENT_SET_INDEX) // client set slots amount
         return;
 
     for (uint8 i = 0; i < EQUIPMENT_SLOT_END; ++i)
     {
         if (!(saveEquipmentSet.Set.IgnoreMask & (1 << i)))
         {
             ObjectGuid const& itemGuid = saveEquipmentSet.Set.Pieces[i];
 
             Item* item = _player->GetItemByPos(INVENTORY_SLOT_BAG_0, i);
 
             if (!item && !itemGuid.IsEmpty())
                 return;
 
             if (item && item->GetGUID() != itemGuid)
                 return;
         }
         else
             saveEquipmentSet.Set.Pieces[i].Clear();
     }
 
     saveEquipmentSet.Set.IgnoreMask &= 0x7FFFF; 
 
     _player->SetEquipmentSet(std::move(saveEquipmentSet.Set));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (packet.Enable)
     {
         TC_LOG_DEBUG("network", "Added FarSight %s to %s", _player->GetGuidValue(PLAYER_FARSIGHT).ToString().c_str(), _player->GetGUID().ToString().c_str());
         if (WorldObject* target = _player->GetViewpoint())
             _player->SetSeer(target);
         else
             TC_LOG_ERROR("network", "Player %s (%s) requests non-existing seer %s", _player->GetName().c_str(), _player->GetGUID().ToString().c_str(), _player->GetGuidValue(PLAYER_FARSIGHT).ToString().c_str());
     }
     else
     {
         TC_LOG_DEBUG("network", "%s set vision to self", _player->GetGUID().ToString().c_str());
         _player->SetSeer(_player);
     }
 
     GetPlayer()->UpdateVisibilityForPlayer();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
 
     GetPlayer()->ValidateMovementInfo(&packet.Ack.movementInfo);
 
     // now can skip not our packet
     if (_player->GetGUID() != packet.Ack.movementInfo.guid)
         return;
 
     /*----------------*/
 
     // client ACK send one packet for mounted/run case and need skip all except last from its
     // in other cases anti-cheat check can be fail in false case
     UnitMoveType move_type;
 
     static char const* const move_type_name[MAX_MOVE_TYPE] =
     {
         "Walk",
         "Run",
         "RunBack",
         "Swim",
         "SwimBack",
         "TurnRate",
         "Flight",
         "FlightBack",
         "PitchRate"
     };
 
     OpcodeClient opcode = packet.GetOpcode();
     switch (opcode)
     {
 
         case CMSG_MOVE_FORCE_WALK_SPEED_CHANGE_ACK:        move_type = MOVE_WALK;        break;
         case CMSG_MOVE_FORCE_RUN_SPEED_CHANGE_ACK:         move_type = MOVE_RUN;         break;
         case CMSG_MOVE_FORCE_RUN_BACK_SPEED_CHANGE_ACK:    move_type = MOVE_RUN_BACK;    break;
         case CMSG_MOVE_FORCE_SWIM_SPEED_CHANGE_ACK:        move_type = MOVE_SWIM;        break;
         case CMSG_MOVE_FORCE_SWIM_BACK_SPEED_CHANGE_ACK:   move_type = MOVE_SWIM_BACK;   break;
         case CMSG_MOVE_FORCE_TURN_RATE_CHANGE_ACK:         move_type = MOVE_TURN_RATE;   break;
         case CMSG_MOVE_FORCE_FLIGHT_SPEED_CHANGE_ACK:      move_type = MOVE_FLIGHT;      break;
         case CMSG_MOVE_FORCE_FLIGHT_BACK_SPEED_CHANGE_ACK: move_type = MOVE_FLIGHT_BACK; break;
         case CMSG_MOVE_FORCE_PITCH_RATE_CHANGE_ACK:        move_type = MOVE_PITCH_RATE;  break;
 
         default:
             TC_LOG_ERROR("network", "WorldSession::HandleForceSpeedChangeAck: Unknown move type opcode: %u", opcode);
             return;
     }
 
     // skip all forced speed changes except last and unexpected
     // in run/mounted case used one ACK and it must be skipped. m_forced_speed_changes[MOVE_RUN] store both.
     if (_player->m_forced_speed_changes[move_type] > 0)
     {
         --_player->m_forced_speed_changes[move_type];
         if (_player->m_forced_speed_changes[move_type] > 0)
             return;
     }
 
     if (!_player->GetTransport() && std::fabs(_player->GetSpeed(move_type) - packet.Speed) > 0.01f)
     {
         if (_player->GetSpeed(move_type) > packet.Speed)         // must be greater - just correct
         {
             TC_LOG_ERROR("network", "%sSpeedChange player %s is NOT correct (must be %f instead %f), force set to correct value",
                 move_type_name[move_type], _player->GetName().c_str(), _player->GetSpeed(move_type), packet.Speed);
             _player->SetSpeed(move_type, _player->GetSpeedRate(move_type), true);
         }
         else                                                // must be lesser - cheating
         {
             TC_LOG_DEBUG("misc", "Player %s from account id %u kicked for incorrect speed (must be %f instead %f)",
                 _player->GetName().c_str(), _player->GetSession()->GetAccountId(), _player->GetSpeed(move_type), packet.Speed);
             _player->GetSession()->KickPlayer();
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleGameObjectQueryOpcode ( WorldPackets::Query::QueryGameObject & packet )

Only static data is sent in this packet !!!

 {
     WorldPackets::Query::QueryGameObjectResponse response;
 
     response.GameObjectID = packet.GameObjectID;
 
     if (GameObjectTemplate const* gameObjectInfo = sObjectMgr->GetGameObjectTemplate(packet.GameObjectID))
     {
         response.Allow = true;
         WorldPackets::Query::GameObjectStats& stats = response.Stats;
 
         stats.Type = gameObjectInfo->type;
         stats.DisplayID = gameObjectInfo->displayId;
 
         stats.Name[0] = gameObjectInfo->name;
         stats.IconName = gameObjectInfo->IconName;
         stats.CastBarCaption = gameObjectInfo->castBarCaption;
         stats.UnkString = gameObjectInfo->unk1;
 
         LocaleConstant localeConstant = GetSessionDbLocaleIndex();
         if (localeConstant >= LOCALE_enUS)
             if (GameObjectLocale const* gameObjectLocale = sObjectMgr->GetGameObjectLocale(packet.GameObjectID))
             {
                 ObjectMgr::GetLocaleString(gameObjectLocale->Name, localeConstant, stats.Name[0]);
                 ObjectMgr::GetLocaleString(gameObjectLocale->CastBarCaption, localeConstant, stats.CastBarCaption);
                 ObjectMgr::GetLocaleString(gameObjectLocale->Unk1, localeConstant, stats.UnkString);
             }
 
         stats.Size = gameObjectInfo->size;
 
         if (GameObjectQuestItemList const* items = sObjectMgr->GetGameObjectQuestItemList(packet.GameObjectID))
             for (uint32 item : *items)
                 stats.QuestItems.push_back(item);
 
         for (uint32 i = 0; i < MAX_GAMEOBJECT_DATA; i++)
             stats.Data[i] = gameObjectInfo->raw.data[i];
     }
 
     SendPacket(response.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     // ignore for remote control state
     if (_player->m_mover != _player)
         return;
 
     if (GameObject* go = GetPlayer()->GetGameObjectIfCanInteractWith(packet.Guid))
     {
         if (go->AI()->GossipHello(_player))
             return;
 
         _player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_USE_GAMEOBJECT, go->GetEntry());
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (GameObject* obj = GetPlayer()->GetGameObjectIfCanInteractWith(packet.Guid))
     {
         // ignore for remote control state
         if (GetPlayer()->m_mover != GetPlayer())
             if (!(GetPlayer()->IsOnVehicle(GetPlayer()->m_mover) || GetPlayer()->IsMounted()) && !obj->GetGOInfo()->IsUsableMounted())
                 return;
 
         obj->Use(GetPlayer());
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (!_player->GetNPCIfCanInteractWith(garrisonCancelConstruction.NpcGUID, UNIT_NPC_FLAG_GARRISON_ARCHITECT))
         return;
 
     if (Garrison* garrison = _player->GetGarrison())
         garrison->CancelBuildingConstruction(garrisonCancelConstruction.PlotInstanceID);
 }

Here is the caller graph for this function:

void WorldSession::HandleGarrisonGetBuildingLandmarks ( WorldPackets::Garrison::GarrisonGetBuildingLandmarks & garrisonGetBuildingLandmarks )

 {
     if (Garrison* garrison = _player->GetGarrison())
         garrison->SendBuildingLandmarks(_player);
 }

Here is the caller graph for this function:

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

 {
     if (!_player->GetNPCIfCanInteractWith(garrisonPurchaseBuilding.NpcGUID, UNIT_NPC_FLAG_GARRISON_ARCHITECT))
         return;
 
     if (Garrison* garrison = _player->GetGarrison())
         garrison->PlaceBuilding(garrisonPurchaseBuilding.PlotInstanceID, garrisonPurchaseBuilding.BuildingID);
 }

Here is the caller graph for this function:

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

 {
     if (Garrison* garrison = _player->GetGarrison())
         garrison->SendBlueprintAndSpecializationData();
 }

Here is the caller graph for this function:

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

 {
     if (Garrison* garrison = _player->GetGarrison())
         garrison->SendInfo();
 }

Here is the caller graph for this function:

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

 {
     Item* item = _player->GetItemByGuid(packet.ItemGUID);
     if (!item)
     {
         TC_LOG_DEBUG("network", "HandleGetItemPurchaseData: Item %s not found!", packet.ItemGUID.ToString().c_str());
         return;
     }
 
     TC_LOG_DEBUG("network", "HandleGetItemPurchaseData: Item %s", packet.ItemGUID.ToString().c_str());
 
     GetPlayer()->SendRefundInfo(item);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleGetMailList ( WorldPackets::Mail::MailGetList & packet )

 {
     if (!CanOpenMailBox(packet.Mailbox))
         return;
 
     Player* player = _player;
 
     //load players mails, and mailed items
     if (!player->m_mailsLoaded)
         player->_LoadMail();
 
     WorldPackets::Mail::MailListResult response;
     time_t curTime = time(nullptr);
 
     for (Mail* m : player->GetMails())
     {
         // skip deleted or not delivered (deliver delay not expired) mails
         if (m->state == MAIL_STATE_DELETED || curTime < m->deliver_time)
             continue;
 
         // max. 50 mails can be sent
         if (response.Mails.size() < 50)
             response.Mails.emplace_back(m, player);
 
         ++response.TotalNumRecords;
     }
 
     SendPacket(response.Write());
 
     // recalculate m_nextMailDelivereTime and unReadMails
     _player->UpdateNextMailTimeAndUnreads();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     // This packet is completely irrelevant, it triggers PVP_TYPES_ENABLED lua event but that is not handled in interface code as of 6.1.2
     WorldPackets::Battleground::PVPOptionsEnabled pvpOptionsEnabled;
     pvpOptionsEnabled.WargameArenas = false;
     pvpOptionsEnabled.RatedArenas = false;
     pvpOptionsEnabled.WargameBattlegrounds = false;
     pvpOptionsEnabled.ArenaSkirmish = false;
     pvpOptionsEnabled.PugBattlegrounds = true;
     pvpOptionsEnabled.RatedBattlegrounds = false;
     SendPacket(pvpOptionsEnabled.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

empty result to force wait

 {
     PreparedQueryResultPromise result;
     result.set_value(PreparedQueryResult(nullptr));
     _undeleteCooldownStatusCallback.SetFutureResult(result.get_future());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     // TODO: Implement GmCase and handle this packet properly
     WorldPackets::Ticket::GMTicketCaseStatus status;
     SendPacket(status.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     // Note: This only disables the ticket UI at client side and is not fully reliable
     // Note: This disables the whole customer support UI after trying to send a ticket in disabled state (MessageBox: "GM Help Tickets are currently unavaiable."). UI remains disabled until the character relogs.
     WorldPackets::Ticket::GMTicketSystemStatus response;
     response.Status = sSupportMgr->GetSupportSystemStatus() ? GMTICKET_QUEUE_STATUS_ENABLED : GMTICKET_QUEUE_STATUS_DISABLED;
     SendPacket(response.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     Creature* unit = GetPlayer()->GetNPCIfCanInteractWith(packet.Unit, UNIT_NPC_FLAG_GOSSIP);
     if (!unit)
     {
         TC_LOG_DEBUG("network", "WORLD: HandleGossipHelloOpcode - %s not found or you can not interact with him.", packet.Unit.ToString().c_str());
         return;
     }
 
     // set faction visible if needed
     if (FactionTemplateEntry const* factionTemplateEntry = sFactionTemplateStore.LookupEntry(unit->getFaction()))
         _player->GetReputationMgr().SetVisible(factionTemplateEntry);
 
     GetPlayer()->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_TALK);
     // remove fake death
     //if (GetPlayer()->HasUnitState(UNIT_STATE_DIED))
     //    GetPlayer()->RemoveAurasByType(SPELL_AURA_FEIGN_DEATH);
 
     if (unit->IsArmorer() || unit->IsCivilian() || unit->IsQuestGiver() || unit->IsServiceProvider() || unit->IsGuard())
         unit->StopMoving();
 
     // If spiritguide, no need for gossip menu, just put player into resurrect queue
     if (unit->IsSpiritGuide())
     {
         Battleground* bg = _player->GetBattleground();
         if (bg)
         {
             bg->AddPlayerToResurrectQueue(unit->GetGUID(), _player->GetGUID());
             sBattlegroundMgr->SendAreaSpiritHealerQueryOpcode(_player, bg, unit->GetGUID());
             return;
         }
     }
 
     if (!sScriptMgr->OnGossipHello(_player, unit))
     {
 //        _player->TalkedToCreature(unit->GetEntry(), unit->GetGUID());
         _player->PrepareGossipMenu(unit, unit->GetCreatureTemplate()->GossipMenuId, true);
         _player->SendPreparedGossip(unit);
     }
     unit->AI()->sGossipHello(_player);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (!_player->PlayerTalkClass->GetGossipMenu().GetItem(packet.GossipIndex))
         return;
 
     // Prevent cheating on C++ scripted menus
     if (_player->PlayerTalkClass->GetGossipMenu().GetSenderGUID() != packet.GossipUnit)
         return;
 
     Creature* unit = nullptr;
     GameObject* go = nullptr;
     if (packet.GossipUnit.IsCreatureOrVehicle())
     {
         unit = GetPlayer()->GetNPCIfCanInteractWith(packet.GossipUnit, UNIT_NPC_FLAG_GOSSIP);
         if (!unit)
         {
             TC_LOG_DEBUG("network", "WORLD: HandleGossipSelectOptionOpcode - %s not found or you can't interact with him.", packet.GossipUnit.ToString().c_str());
             return;
         }
     }
     else if (packet.GossipUnit.IsGameObject())
     {
         go = _player->GetGameObjectIfCanInteractWith(packet.GossipUnit);
         if (!go)
         {
             TC_LOG_DEBUG("network", "WORLD: HandleGossipSelectOptionOpcode - %s not found or you can't interact with it.", packet.GossipUnit.ToString().c_str());
             return;
         }
     }
     else
     {
 
         TC_LOG_DEBUG("network", "WORLD: HandleGossipSelectOptionOpcode - unsupported %s.", packet.GossipUnit.ToString().c_str());
         return;
     }
 
     // remove fake death
     if (GetPlayer()->HasUnitState(UNIT_STATE_DIED))
         GetPlayer()->RemoveAurasByType(SPELL_AURA_FEIGN_DEATH);
 
     if ((unit && unit->GetCreatureTemplate()->ScriptID != unit->LastUsedScriptID) || (go && go->GetGOInfo()->ScriptId != go->LastUsedScriptID))
     {
         TC_LOG_DEBUG("network", "WORLD: HandleGossipSelectOptionOpcode - Script reloaded while in use, ignoring and set new scipt id");
         if (unit)
             unit->LastUsedScriptID = unit->GetCreatureTemplate()->ScriptID;
 
         if (go)
             go->LastUsedScriptID = go->GetGOInfo()->ScriptId;
         _player->PlayerTalkClass->SendCloseGossip();
         return;
     }
 
     if (!packet.PromotionCode.empty())
     {
         if (unit)
         {
             unit->AI()->sGossipSelectCode(_player, packet.GossipID, packet.GossipIndex, packet.PromotionCode.c_str());
             if (!sScriptMgr->OnGossipSelectCode(_player, unit, _player->PlayerTalkClass->GetGossipOptionSender(packet.GossipIndex), _player->PlayerTalkClass->GetGossipOptionAction(packet.GossipIndex), packet.PromotionCode.c_str()))
                 _player->OnGossipSelect(unit, packet.GossipIndex, packet.GossipID);
         }
         else
         {
             go->AI()->GossipSelectCode(_player, packet.GossipID, packet.GossipIndex, packet.PromotionCode.c_str());
             if (!sScriptMgr->OnGossipSelectCode(_player, go, _player->PlayerTalkClass->GetGossipOptionSender(packet.GossipIndex), _player->PlayerTalkClass->GetGossipOptionAction(packet.GossipIndex), packet.PromotionCode.c_str()))
                 _player->OnGossipSelect(go, packet.GossipIndex, packet.GossipID);
         }
     }
     else
     {
         if (unit)
         {
             unit->AI()->sGossipSelect(_player, packet.GossipID, packet.GossipIndex);
             if (!sScriptMgr->OnGossipSelect(_player, unit, _player->PlayerTalkClass->GetGossipOptionSender(packet.GossipIndex), _player->PlayerTalkClass->GetGossipOptionAction(packet.GossipIndex)))
                 _player->OnGossipSelect(unit, packet.GossipIndex, packet.GossipID);
         }
         else
         {
             go->AI()->GossipSelect(_player, packet.GossipID, packet.GossipIndex);
             if (!sScriptMgr->OnGossipSelect(_player, go, _player->PlayerTalkClass->GetGossipOptionSender(packet.GossipIndex), _player->PlayerTalkClass->GetGossipOptionAction(packet.GossipIndex)))
                 _player->OnGossipSelect(go, packet.GossipIndex, packet.GossipID);
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleGrantLevel ( WorldPackets::RaF::GrantLevel & grantLevel )

 {
     Player* target = ObjectAccessor::GetPlayer(*_player, grantLevel.Target);
 
     // check cheating
     uint8 levels = _player->GetGrantableLevels();
     uint8 error = 0;
     if (!target)
         error = ERR_REFER_A_FRIEND_NO_TARGET;
     else if (levels == 0)
         error = ERR_REFER_A_FRIEND_INSUFFICIENT_GRANTABLE_LEVELS;
     else if (GetRecruiterId() != target->GetSession()->GetAccountId())
         error = ERR_REFER_A_FRIEND_NOT_REFERRED_BY;
     else if (target->GetTeamId() != _player->GetTeamId())
         error = ERR_REFER_A_FRIEND_DIFFERENT_FACTION;
     else if (target->getLevel() >= _player->getLevel())
         error = ERR_REFER_A_FRIEND_TARGET_TOO_HIGH;
     else if (target->getLevel() >= sWorld->getIntConfig(CONFIG_MAX_RECRUIT_A_FRIEND_BONUS_PLAYER_LEVEL))
         error = ERR_REFER_A_FRIEND_GRANT_LEVEL_MAX_I;
     else if (target->GetGroup() != _player->GetGroup())
         error = ERR_REFER_A_FRIEND_NOT_IN_GROUP;
     else if (target->getLevel() >= GetMaxLevelForExpansion(target->GetSession()->GetExpansion()))
         error = ERR_REFER_A_FRIEND_INSUF_EXPAN_LVL;
 
     if (error)
     {
         WorldPackets::RaF::ReferAFriendFailure failure;
         failure.Reason = error;
         if (error == ERR_REFER_A_FRIEND_NOT_IN_GROUP)
             failure.Str = target->GetName();
 
         SendPacket(failure.Write());
         return;
     }
 
     WorldPackets::RaF::ProposeLevelGrant proposeLevelGrant;
     proposeLevelGrant.Sender = _player->GetGUID();
     target->SendDirectMessage(proposeLevelGrant.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (!GetPlayer()->GetGuildId())
         if (Guild* guild = sGuildMgr->GetGuildById(GetPlayer()->GetGuildIdInvited()))
             guild->HandleAcceptMember(this);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     TC_LOG_DEBUG("guild", "CMSG_GUILD_ADD_RANK [%s]: Rank: %s", GetPlayerInfo().c_str(), packet.Name.c_str());
 
     if (Guild* guild = GetPlayer()->GetGuild())
         guild->HandleAddNewRank(this, packet.Name);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     ObjectGuid setterGuid = GetPlayer()->GetGUID();
 
     TC_LOG_DEBUG("guild", "CMSG_GUILD_ASSIGN_MEMBER_RANK [%s]: Target: %s Rank: %u, Issuer: %s",
         GetPlayerInfo().c_str(), packet.Member.ToString().c_str(), packet.RankOrder, setterGuid.ToString().c_str());
 
     if (Guild* guild = GetPlayer()->GetGuild())
         guild->HandleSetMemberRank(this, packet.Member, setterGuid, packet.RankOrder);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     TC_LOG_DEBUG("guild", "CMSG_GUILD_BANK_ACTIVATE [%s]: [%s] AllSlots: %u"
         , GetPlayerInfo().c_str(), packet.Banker.ToString().c_str(), packet.FullUpdate);
 
     GameObject const* const go = GetPlayer()->GetGameObjectIfCanInteractWith(packet.Banker, GAMEOBJECT_TYPE_GUILD_BANK);
     if (!go)
         return;
 
     Guild* const guild = GetPlayer()->GetGuild();
     if (!guild)
     {
         Guild::SendCommandResult(this, GUILD_COMMAND_VIEW_TAB, ERR_GUILD_PLAYER_NOT_IN_GUILD);
         return;
     }
 
     guild->SendBankList(this, 0, packet.FullUpdate);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     TC_LOG_DEBUG("guild", "CMSG_GUILD_BANK_BUY_TAB [%s]: [%s[, TabId: %u", GetPlayerInfo().c_str(), packet.Banker.ToString().c_str(), packet.BankTab);
 
     if (!packet.Banker || GetPlayer()->GetGameObjectIfCanInteractWith(packet.Banker, GAMEOBJECT_TYPE_GUILD_BANK))
         if (Guild* guild = GetPlayer()->GetGuild())
             guild->HandleBuyBankTab(this, packet.BankTab);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     TC_LOG_DEBUG("guild", "CMSG_GUILD_BANK_DEPOSIT_MONEY [%s]: [%s], money: " UI64FMTD,
         GetPlayerInfo().c_str(), packet.Banker.ToString().c_str(), packet.Money);
 
     if (GetPlayer()->GetGameObjectIfCanInteractWith(packet.Banker, GAMEOBJECT_TYPE_GUILD_BANK))
         if (packet.Money && GetPlayer()->HasEnoughMoney(packet.Money))
             if (Guild* guild = GetPlayer()->GetGuild())
                 guild->HandleMemberDepositMoney(this, packet.Money);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     TC_LOG_DEBUG("guild", "CMSG_GUILD_BANK_LOG_QUERY [%s]: TabId: %u", GetPlayerInfo().c_str(), packet.Tab);
 
     if (Guild* guild = GetPlayer()->GetGuild())
         guild->SendBankLog(this, packet.Tab);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (Guild* guild = GetPlayer()->GetGuild())
         guild->SendMoneyInfo(this);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     TC_LOG_DEBUG("guild", "CMSG_GUILD_BANK_QUERY_TAB [%s]: %s, TabId: %u, ShowTabs: %u"
         , GetPlayerInfo().c_str(), packet.Banker.ToString().c_str(), packet.Tab, packet.FullUpdate);
 
     if (GetPlayer()->GetGameObjectIfCanInteractWith(packet.Banker, GAMEOBJECT_TYPE_GUILD_BANK))
         if (Guild* guild = GetPlayer()->GetGuild())
             guild->SendBankList(this, packet.Tab, packet.FullUpdate);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     TC_LOG_DEBUG("guild", "CMSG_SET_GUILD_BANK_TEXT [%s]: TabId: %u, Text: %s", GetPlayerInfo().c_str(), packet.Tab, packet.TabText.c_str());
 
     if (Guild* guild = GetPlayer()->GetGuild())
         guild->SetBankTabText(packet.Tab, packet.TabText);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleGuildBankSwapItems ( WorldPackets::Guild::GuildBankSwapItems & packet )

 {
     if (!GetPlayer()->GetGameObjectIfCanInteractWith(packet.Banker, GAMEOBJECT_TYPE_GUILD_BANK))
         return;
 
     Guild* guild = GetPlayer()->GetGuild();
     if (!guild)
         return;
 
     if (packet.BankOnly)
     {
         guild->SwapItems(GetPlayer(), packet.BankTab1, packet.BankSlot1, packet.BankTab, packet.BankSlot, packet.StackCount);
     }
     else
     {
         // Player <-> Bank
         // Allow to work with inventory only
         if (!Player::IsInventoryPos(packet.ContainerSlot, packet.ContainerItemSlot) && !packet.AutoStore)
             GetPlayer()->SendEquipError(EQUIP_ERR_INTERNAL_BAG_ERROR, NULL);
         else
             guild->SwapItemsWithInventory(GetPlayer(), packet.ToSlot != 0, packet.BankTab, packet.BankSlot, packet.ContainerSlot, packet.ContainerItemSlot, packet.StackCount);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     TC_LOG_DEBUG("guild", "CMSG_GUILD_BANK_QUERY_TEXT [%s]: TabId: %u", GetPlayerInfo().c_str(), packet.Tab);
 
     if (Guild* guild = GetPlayer()->GetGuild())
         guild->SendBankTabText(this, packet.Tab);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     TC_LOG_DEBUG("guild", "CMSG_GUILD_BANK_UPDATE_TAB [%s]: [%s], TabId: %u, Name: %s, Icon: %s"
         , GetPlayerInfo().c_str(), packet.Banker.ToString().c_str(), packet.BankTab, packet.Name.c_str(), packet.Icon.c_str());
 
     if (!packet.Name.empty() && !packet.Icon.empty())
         if (GetPlayer()->GetGameObjectIfCanInteractWith(packet.Banker, GAMEOBJECT_TYPE_GUILD_BANK))
             if (Guild* guild = GetPlayer()->GetGuild())
                 guild->HandleSetBankTabInfo(this, packet.BankTab, packet.Name, packet.Icon);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     TC_LOG_DEBUG("guild", "CMSG_GUILD_BANK_WITHDRAW_MONEY [%s]: [%s], money: " UI64FMTD,
         GetPlayerInfo().c_str(), packet.Banker.ToString().c_str(), packet.Money);
 
     if (packet.Money && GetPlayer()->GetGameObjectIfCanInteractWith(packet.Banker, GAMEOBJECT_TYPE_GUILD_BANK))
         if (Guild* guild = GetPlayer()->GetGuild())
             guild->HandleMemberWithdrawMoney(this, packet.Money);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (Guild* guild = _player->GetGuild())
         guild->HandleGuildRequestChallengeUpdate(this);
 }

Here is the caller graph for this function:

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

 {
     GetPlayer()->SetGuildIdInvited(UI64LIT(0));
     GetPlayer()->SetInGuild(UI64LIT(0));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (Guild* guild = GetPlayer()->GetGuild())
         guild->HandleDelete(this);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     TC_LOG_DEBUG("guild", "CMSG_GUILD_DELETE_RANK [%s]: Rank: %u", GetPlayerInfo().c_str(), packet.RankOrder);
 
     if (Guild* guild = GetPlayer()->GetGuild())
         guild->HandleRemoveRank(this, packet.RankOrder);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     TC_LOG_DEBUG("guild", "CMSG_GUILD_DEMOTE [%s]: Target: %s", GetPlayerInfo().c_str(), demote.Demotee.ToString().c_str());
 
     if (Guild* guild = GetPlayer()->GetGuild())
         guild->HandleUpdateMemberRank(this, demote.Demotee, true);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     TC_LOG_DEBUG("guild", "MSG_GUILD_EVENT_LOG_QUERY [%s]", GetPlayerInfo().c_str());
 
     if (Guild* guild = GetPlayer()->GetGuild())
         guild->SendEventLog(this);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleGuildFinderAddRecruit ( WorldPackets::GuildFinder::LFGuildAddRecruit & lfGuildAddRecruit )

 {
     if (sGuildFinderMgr->CountRequestsFromPlayer(GetPlayer()->GetGUID()) >= 10)
         return;
 
     if (!lfGuildAddRecruit.GuildGUID.IsGuild())
         return;
     if (!(lfGuildAddRecruit.ClassRoles & GUILDFINDER_ALL_ROLES) || lfGuildAddRecruit.ClassRoles > GUILDFINDER_ALL_ROLES)
         return;
     if (!(lfGuildAddRecruit.Availability & AVAILABILITY_ALWAYS) || lfGuildAddRecruit.Availability > AVAILABILITY_ALWAYS)
         return;
     if (!(lfGuildAddRecruit.PlayStyle & ALL_INTERESTS) || lfGuildAddRecruit.PlayStyle > ALL_INTERESTS)
         return;
 
     MembershipRequest request = MembershipRequest(GetPlayer()->GetGUID(), lfGuildAddRecruit.GuildGUID, lfGuildAddRecruit.Availability,
         lfGuildAddRecruit.ClassRoles, lfGuildAddRecruit.PlayStyle, lfGuildAddRecruit.Comment, time(NULL));
     sGuildFinderMgr->AddMembershipRequest(lfGuildAddRecruit.GuildGUID, request);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleGuildFinderBrowse ( WorldPackets::GuildFinder::LFGuildBrowse & lfGuildBrowse )

 {
     if (!(lfGuildBrowse.ClassRoles & GUILDFINDER_ALL_ROLES) || lfGuildBrowse.ClassRoles > GUILDFINDER_ALL_ROLES)
         return;
     if (!(lfGuildBrowse.Availability & AVAILABILITY_ALWAYS) || lfGuildBrowse.Availability > AVAILABILITY_ALWAYS)
         return;
     if (!(lfGuildBrowse.PlayStyle & ALL_INTERESTS) || lfGuildBrowse.PlayStyle > ALL_INTERESTS)
         return;
     if (lfGuildBrowse.CharacterLevel > int32(sWorld->getIntConfig(CONFIG_MAX_PLAYER_LEVEL)) || lfGuildBrowse.CharacterLevel < 1)
         return;
 
     Player* player = GetPlayer();
 
     LFGuildPlayer settings(player->GetGUID(), lfGuildBrowse.ClassRoles, lfGuildBrowse.Availability, lfGuildBrowse.PlayStyle, ANY_FINDER_LEVEL);
     std::vector<LFGuildSettings const*> guildList = sGuildFinderMgr->GetGuildsMatchingSetting(settings, player->GetTeamId());
 
     WorldPackets::GuildFinder::LFGuildBrowseResult lfGuildBrowseResult;
     lfGuildBrowseResult.Post.resize(guildList.size());
 
     for (std::size_t i = 0; i < guildList.size(); ++i)
     {
         LFGuildSettings const* guildSettings = guildList[i];
         WorldPackets::GuildFinder::LFGuildBrowseData& guildData = lfGuildBrowseResult.Post[i];
         Guild* guild = ASSERT_NOTNULL(sGuildMgr->GetGuildByGuid(guildSettings->GetGUID()));
 
         guildData.GuildName = guild->GetName();
         guildData.GuildGUID = guild->GetGUID();
         guildData.GuildVirtualRealm = GetVirtualRealmAddress();
         guildData.GuildMembers = guild->GetMembersCount();
         guildData.GuildAchievementPoints = guild->GetAchievementMgr().GetAchievementPoints();
         guildData.PlayStyle = guildSettings->GetInterests();
         guildData.Availability = guildSettings->GetAvailability();
         guildData.ClassRoles = guildSettings->GetClassRoles();
         guildData.LevelRange = guildSettings->GetLevel();
         guildData.EmblemStyle = guild->GetEmblemInfo().GetStyle();
         guildData.EmblemColor = guild->GetEmblemInfo().GetColor();
         guildData.BorderStyle = guild->GetEmblemInfo().GetBorderStyle();
         guildData.BorderColor = guild->GetEmblemInfo().GetBorderColor();
         guildData.Background = guild->GetEmblemInfo().GetBackgroundColor();
         guildData.Comment = guildSettings->GetComment();
         guildData.Cached = 0;
         guildData.MembershipRequested = sGuildFinderMgr->HasRequest(player->GetGUID(), guild->GetGUID());
     }
 
     player->SendDirectMessage(lfGuildBrowseResult.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleGuildFinderDeclineRecruit ( WorldPackets::GuildFinder::LFGuildDeclineRecruit & lfGuildDeclineRecruit )

 {
     if (!GetPlayer()->GetGuild())
         return;
 
     if (!lfGuildDeclineRecruit.RecruitGUID.IsPlayer())
         return;
 
     sGuildFinderMgr->RemoveMembershipRequest(lfGuildDeclineRecruit.RecruitGUID, GetPlayer()->GetGuild()->GetGUID());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleGuildFinderGetApplications ( WorldPackets::GuildFinder::LFGuildGetApplications & lfGuildGetApplications )

 {
     std::vector<MembershipRequest const*> applicatedGuilds = sGuildFinderMgr->GetAllMembershipRequestsForPlayer(GetPlayer()->GetGUID());
     WorldPackets::GuildFinder::LFGuildApplications lfGuildApplications;
     lfGuildApplications.Application.resize(applicatedGuilds.size());
     lfGuildApplications.NumRemaining = 10 - sGuildFinderMgr->CountRequestsFromPlayer(GetPlayer()->GetGUID());
 
     for (std::size_t i = 0; i < applicatedGuilds.size(); ++i)
     {
         MembershipRequest const* application = applicatedGuilds[i];
         WorldPackets::GuildFinder::LFGuildApplicationData& applicationData = lfGuildApplications.Application[i];
 
         Guild* guild = ASSERT_NOTNULL(sGuildMgr->GetGuildByGuid(application->GetGuildGuid()));
         LFGuildSettings const& guildSettings = sGuildFinderMgr->GetGuildSettings(application->GetGuildGuid());
 
         applicationData.GuildGUID = application->GetGuildGuid();
         applicationData.GuildVirtualRealm = GetVirtualRealmAddress();
         applicationData.GuildName = guild->GetName();
         applicationData.ClassRoles = guildSettings.GetClassRoles();
         applicationData.PlayStyle = guildSettings.GetInterests();
         applicationData.Availability = guildSettings.GetAvailability();
         applicationData.SecondsSinceCreated = time(NULL) - application->GetSubmitTime();
         applicationData.SecondsUntilExpiration = application->GetExpiryTime() - time(NULL);
         applicationData.Comment = application->GetComment();
     }
 
     GetPlayer()->SendDirectMessage(lfGuildApplications.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleGuildFinderGetGuildPost ( WorldPackets::GuildFinder::LFGuildGetGuildPost & lfGuildGetGuildPost )

 {
     Player* player = GetPlayer();
 
     Guild* guild = player->GetGuild();
     if (!guild) // Player must be in guild
         return;
 
     WorldPackets::GuildFinder::LFGuildPost lfGuildPost;
     if (guild->GetLeaderGUID() == player->GetGUID())
     {
         LFGuildSettings const& settings = sGuildFinderMgr->GetGuildSettings(guild->GetGUID());
         lfGuildPost.Post = boost::in_place();
         lfGuildPost.Post->Active = settings.IsListed();
         lfGuildPost.Post->PlayStyle = settings.GetInterests();
         lfGuildPost.Post->Availability = settings.GetAvailability();
         lfGuildPost.Post->ClassRoles = settings.GetClassRoles();
         lfGuildPost.Post->LevelRange = settings.GetLevel();
         lfGuildPost.Post->Comment = settings.GetComment();
     }
 
     player->SendDirectMessage(lfGuildPost.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleGuildFinderGetRecruits ( WorldPackets::GuildFinder::LFGuildGetRecruits & lfGuildGetRecruits )

 {
     Player* player = GetPlayer();
     Guild* guild = player->GetGuild();
     if (!guild)
         return;
 
     time_t now = time(nullptr);
     WorldPackets::GuildFinder::LFGuildRecruits lfGuildRecruits;
     lfGuildRecruits.UpdateTime = now;
     if (std::unordered_map<ObjectGuid, MembershipRequest> const* recruitsList = sGuildFinderMgr->GetAllMembershipRequestsForGuild(guild->GetGUID()))
     {
         lfGuildRecruits.Recruits.resize(recruitsList->size());
         std::size_t i = 0;
         for (auto const& recruitRequestPair : *recruitsList)
         {
             WorldPackets::GuildFinder::LFGuildRecruitData& recruitData = lfGuildRecruits.Recruits[i++];
             recruitData.RecruitGUID = recruitRequestPair.first;
             recruitData.RecruitVirtualRealm = GetVirtualRealmAddress();
             recruitData.Comment = recruitRequestPair.second.GetComment();
             recruitData.ClassRoles = recruitRequestPair.second.GetClassRoles();
             recruitData.PlayStyle = recruitRequestPair.second.GetInterests();
             recruitData.Availability = recruitRequestPair.second.GetAvailability();
             recruitData.SecondsSinceCreated = now - recruitRequestPair.second.GetSubmitTime();
             recruitData.SecondsUntilExpiration = recruitRequestPair.second.GetExpiryTime() - now;
             if (CharacterInfo const* charInfo = sWorld->GetCharacterInfo(recruitRequestPair.first))
             {
                 recruitData.Name = charInfo->Name;
                 recruitData.CharacterClass = charInfo->Class;
                 recruitData.CharacterGender = charInfo->Sex;
                 recruitData.CharacterLevel = charInfo->Level;
             }
         }
     }
 
     player->SendDirectMessage(lfGuildRecruits.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleGuildFinderRemoveRecruit ( WorldPackets::GuildFinder::LFGuildRemoveRecruit & lfGuildRemoveRecruit )

 {
     if (!lfGuildRemoveRecruit.GuildGUID.IsGuild())
         return;
 
     sGuildFinderMgr->RemoveMembershipRequest(GetPlayer()->GetGUID(), lfGuildRemoveRecruit.GuildGUID);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleGuildFinderSetGuildPost ( WorldPackets::GuildFinder::LFGuildSetGuildPost & lfGuildSetGuildPost )

 {
     // Level sent is zero if untouched, force to any (from interface). Idk why
     if (!lfGuildSetGuildPost.LevelRange)
         lfGuildSetGuildPost.LevelRange = ANY_FINDER_LEVEL;
 
     if (!(lfGuildSetGuildPost.ClassRoles & GUILDFINDER_ALL_ROLES) || lfGuildSetGuildPost.ClassRoles > GUILDFINDER_ALL_ROLES)
         return;
     if (!(lfGuildSetGuildPost.Availability & AVAILABILITY_ALWAYS) || lfGuildSetGuildPost.Availability > AVAILABILITY_ALWAYS)
         return;
     if (!(lfGuildSetGuildPost.PlayStyle & ALL_INTERESTS) || lfGuildSetGuildPost.PlayStyle > ALL_INTERESTS)
         return;
     if (!(lfGuildSetGuildPost.LevelRange & ALL_GUILDFINDER_LEVELS) || lfGuildSetGuildPost.LevelRange > ALL_GUILDFINDER_LEVELS)
         return;
 
     Player* player = GetPlayer();
 
     if (!player->GetGuildId()) // Player must be in guild
         return;
 
     Guild* guild = sGuildMgr->GetGuildById(player->GetGuildId());
     // Player must be guild master
     if (guild->GetLeaderGUID() != player->GetGUID())
         return;
 
     LFGuildSettings settings(lfGuildSetGuildPost.Active, player->GetTeamId(), guild->GetGUID(), lfGuildSetGuildPost.ClassRoles,
         lfGuildSetGuildPost.Availability, lfGuildSetGuildPost.PlayStyle, lfGuildSetGuildPost.LevelRange, lfGuildSetGuildPost.Comment);
     sGuildFinderMgr->SetGuildSettings(guild->GetGUID(), settings);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     TC_LOG_DEBUG("guild", "CMSG_GUILD_GET_RANKS [%s]: Guild: %s",
         GetPlayerInfo().c_str(), packet.GuildGUID.ToString().c_str());
 
     if (Guild* guild = sGuildMgr->GetGuildByGuid(packet.GuildGUID))
         if (guild->IsMember(_player->GetGUID()))
             guild->SendGuildRankInfo(this);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (Guild* guild = GetPlayer()->GetGuild())
         guild->HandleRoster(this);
     else
         Guild::SendCommandResult(this, GUILD_COMMAND_GET_ROSTER, ERR_GUILD_PLAYER_NOT_IN_GUILD);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     TC_LOG_DEBUG("guild", "CMSG_GUILD_INVITE [%s]: Invited: %s", GetPlayerInfo().c_str(), packet.Name.c_str());
     if (normalizePlayerName(packet.Name))
         if (Guild* guild = GetPlayer()->GetGuild())
             guild->HandleInviteMember(this, packet.Name);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (Guild* guild = GetPlayer()->GetGuild())
         guild->HandleLeaveMember(this);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (Guild* guild = GetPlayer()->GetGuild())
         guild->HandleNewsSetSticky(this, packet.NewsID, packet.Sticky);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     TC_LOG_DEBUG("guild", "CMSG_GUILD_REMOVE [%s]: Target: %s", GetPlayerInfo().c_str(), packet.Removee.ToString().c_str());
 
     if (Guild* guild = GetPlayer()->GetGuild())
         guild->HandleRemoveMember(this, packet.Removee);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (Guild* guild = GetPlayer()->GetGuild())
         guild->SendPermissions(this);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     TC_LOG_DEBUG("guild", "CMSG_GUILD_PROMOTE [%s]: Target: %s", GetPlayerInfo().c_str(), promote.Promotee.ToString().c_str());
 
     if (Guild* guild = GetPlayer()->GetGuild())
         guild->HandleUpdateMemberRank(this, promote.Promotee, false);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (Guild* guild = GetPlayer()->GetGuild())
         if (guild->GetGUID() == newsQuery.GuildGUID)
             guild->SendNewsUpdate(this);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     TC_LOG_DEBUG("guild", "CMSG_GUILD_QUERY [%s]: Guild: %s Target: %s",
         GetPlayerInfo().c_str(), query.GuildGuid.ToString().c_str(), query.PlayerGuid.ToString().c_str());
 
     if (Guild* guild = sGuildMgr->GetGuildByGuid(query.GuildGuid))
         if (guild->IsMember(query.PlayerGuid))
         {
             guild->SendQueryResponse(this);
             return;
         }
 
     WorldPackets::Guild::QueryGuildInfoResponse response;
     response.GuildGuid = query.GuildGuid;
     SendPacket(response.Write());
 
     TC_LOG_DEBUG("guild", "SMSG_GUILD_QUERY_RESPONSE [%s]", GetPlayerInfo().c_str());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (Guild* guild = sGuildMgr->GetGuildByGuid(packet.GuildGUID))
         guild->HandleGuildPartyRequest(this);
 }

Here is the caller graph for this function:

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

 {
     if (Guild* guild = GetPlayer()->GetGuild())
         guild->HandleSetAchievementTracking(this, packet.AchievementIDs);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (Guild* guild = sGuildMgr->GetGuildById(_player->GetGuildId()))
         guild->GetAchievementMgr().SendAchievementInfo(_player, setFocusedAchievement.AchievementID);
 }

Here is the caller graph for this function:

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

 {
     if (Guild* guild = GetPlayer()->GetGuild())
         guild->HandleSetNewGuildMaster(this, packet.NewMasterName);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     TC_LOG_DEBUG("guild", "CMSG_GUILD_SET_NOTE [%s]: Target: %s, Note: %s, Public: %u",
         GetPlayerInfo().c_str(), packet.NoteeGUID.ToString().c_str(), packet.Note.c_str(), packet.IsPublic);
 
     if (Guild* guild = GetPlayer()->GetGuild())
         guild->HandleSetMemberNote(this, packet.Note, packet.NoteeGUID, packet.IsPublic);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     Guild* guild = GetPlayer()->GetGuild();
     if (!guild)
         return;
 
     GuildBankRightsAndSlotsVec rightsAndSlots(GUILD_BANK_MAX_TABS);
     for (uint8 tabId = 0; tabId < GUILD_BANK_MAX_TABS; ++tabId)
         rightsAndSlots[tabId] = GuildBankRightsAndSlots(tabId, uint8(packet.TabFlags[tabId]), uint32(packet.TabWithdrawItemLimit[tabId]));
 
     TC_LOG_DEBUG("guild", "CMSG_GUILD_SET_RANK_PERMISSIONS [%s]: Rank: %s (%u)", GetPlayerInfo().c_str(), packet.RankName.c_str(), packet.RankOrder);
 
     guild->HandleSetRankInfo(this, packet.RankOrder, packet.RankName, packet.Flags, packet.WithdrawGoldLimit, rightsAndSlots);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     TC_LOG_DEBUG("guild", "CMSG_GUILD_UPDATE_INFO_TEXT [%s]: %s", GetPlayerInfo().c_str(), packet.InfoText.c_str());
 
     if (Guild* guild = GetPlayer()->GetGuild())
         guild->HandleSetInfo(this, packet.InfoText);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     TC_LOG_DEBUG("guild", "CMSG_GUILD_UPDATE_MOTD_TEXT [%s]: MOTD: %s", GetPlayerInfo().c_str(), packet.MotdText.c_str());
 
     if (Guild* guild = GetPlayer()->GetGuild())
         guild->HandleSetMOTD(this, packet.MotdText);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (_player->IsInFlight())
         return;
 
     if (/*Battlefield* bf = */sBattlefieldMgr->GetBattlefieldToZoneId(_player->GetZoneId()))
     {
         // bf->PlayerAskToLeave(_player); FIXME
         return;
     }
 
     AreaTableEntry const* atEntry = sAreaTableStore.LookupEntry(_player->GetAreaId());
     if (!atEntry || !(atEntry->Flags[0] & AREA_FLAG_CAN_HEARTH_AND_RESURRECT))
         return;
 
     _player->BuildPlayerRepop();
     _player->ResurrectPlayer(1.0f);
     _player->TeleportTo(_player->m_homebindMapId, _player->m_homebindX, _player->m_homebindY, _player->m_homebindZ, _player->GetOrientation());
 }

Here is the caller graph for this function:

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

43 {

44 }

Here is the caller graph for this function:

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

 {
     Group* group = GetPlayer()->GetGroup();
     if (!group)
         return;
 
     ObjectGuid guid = GetPlayer()->GetGUID();
     if (!group->IsLeader(guid) && !group->IsAssistant(guid))
         return;
 
     WorldPackets::Party::RolePollInform rolePollInform;
     rolePollInform.From = GetPlayer()->GetGUID();
     rolePollInform.PartyIndex = packet.PartyIndex;
     group->BroadcastPacket(rolePollInform.Write(), true);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (GetPlayer()->m_trade)
         return;
 
     WorldPackets::Trade::TradeStatus info;
     if (!GetPlayer()->IsAlive())
     {
         info.Status = TRADE_STATUS_DEAD;
         SendTradeStatus(info);
         return;
     }
 
     if (GetPlayer()->HasUnitState(UNIT_STATE_STUNNED))
     {
         info.Status = TRADE_STATUS_STUNNED;
         SendTradeStatus(info);
         return;
     }
 
     if (isLogingOut())
     {
         info.Status = TRADE_STATUS_LOGGING_OUT;
         SendTradeStatus(info);
         return;
     }
 
     if (GetPlayer()->IsInFlight())
     {
         info.Status = TRADE_STATUS_TOO_FAR_AWAY;
         SendTradeStatus(info);
         return;
     }
 
     if (GetPlayer()->getLevel() < sWorld->getIntConfig(CONFIG_TRADE_LEVEL_REQ))
     {
         SendNotification(GetTrinityString(LANG_TRADE_REQ), sWorld->getIntConfig(CONFIG_TRADE_LEVEL_REQ));
         return;
     }
 
     Player* pOther = ObjectAccessor::FindPlayer(initiateTrade.Guid);
     if (!pOther)
     {
         info.Status = TRADE_STATUS_NO_TARGET;
         SendTradeStatus(info);
         return;
     }
 
     if (pOther == GetPlayer() || pOther->m_trade)
     {
         info.Status = TRADE_STATUS_PLAYER_BUSY;
         SendTradeStatus(info);
         return;
     }
 
     if (!pOther->IsAlive())
     {
         info.Status = TRADE_STATUS_TARGET_DEAD;
         SendTradeStatus(info);
         return;
     }
 
     if (pOther->IsInFlight())
     {
         info.Status = TRADE_STATUS_TOO_FAR_AWAY;
         SendTradeStatus(info);
         return;
     }
 
     if (pOther->HasUnitState(UNIT_STATE_STUNNED))
     {
         info.Status = TRADE_STATUS_TARGET_STUNNED;
         SendTradeStatus(info);
         return;
     }
 
     if (pOther->GetSession()->isLogingOut())
     {
         info.Status = TRADE_STATUS_TARGET_LOGGING_OUT;
         SendTradeStatus(info);
         return;
     }
 
     if (pOther->GetSocial()->HasIgnore(GetPlayer()->GetGUID()))
     {
         info.Status = TRADE_STATUS_PLAYER_IGNORED;
         SendTradeStatus(info);
         return;
     }
 
     if ((pOther->GetTeam() != _player->GetTeam() ||
         pOther->HasFlag(PLAYER_FLAGS_EX, PLAYER_FLAGS_EX_MERCENARY_MODE) ||
         _player->HasFlag(PLAYER_FLAGS_EX, PLAYER_FLAGS_EX_MERCENARY_MODE)) &&
         (!sWorld->getBoolConfig(CONFIG_ALLOW_TWO_SIDE_TRADE) &&
         !HasPermission(rbac::RBAC_PERM_ALLOW_TWO_SIDE_TRADE)))
     {
         info.Status = TRADE_STATUS_WRONG_FACTION;
         SendTradeStatus(info);
         return;
     }
 
     if (!pOther->IsWithinDistInMap(_player, TRADE_DISTANCE, false))
     {
         info.Status = TRADE_STATUS_TOO_FAR_AWAY;
         SendTradeStatus(info);
         return;
     }
 
     if (pOther->getLevel() < sWorld->getIntConfig(CONFIG_TRADE_LEVEL_REQ))
     {
         SendNotification(GetTrinityString(LANG_TRADE_OTHER_REQ), sWorld->getIntConfig(CONFIG_TRADE_LEVEL_REQ));
         return;
     }
 
     // OK start trade
     _player->m_trade = new TradeData(_player, pOther);
     pOther->m_trade = new TradeData(pOther, _player);
 
     info.Status = TRADE_STATUS_PROPOSED;
     info.Partner = _player->GetGUID();
     pOther->GetSession()->SendTradeStatus(info);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     Player* player = ObjectAccessor::FindPlayer(inspect.Target);
     if (!player)
     {
         TC_LOG_DEBUG("network", "WorldSession::HandleInspectOpcode: Target %s not found.", inspect.Target.ToString().c_str());
         return;
     }
 
     TC_LOG_DEBUG("network", "WorldSession::HandleInspectOpcode: Target %s.", inspect.Target.ToString().c_str());
 
     if (!GetPlayer()->IsWithinDistInMap(player, INSPECT_DISTANCE, false))
         return;
 
     if (GetPlayer()->IsValidAttackTarget(player))
         return;
 
     WorldPackets::Inspect::InspectResult inspectResult;
     inspectResult.InspecteeGUID = inspect.Target;
 
     for (uint8 i = 0; i < EQUIPMENT_SLOT_END; ++i)
     {
         if (Item* item = player->GetItemByPos(INVENTORY_SLOT_BAG_0, i))
             inspectResult.Items.emplace_back(item, i);
     }
 
     inspectResult.ClassID = player->getClass();
     inspectResult.GenderID = player->GetByteValue(PLAYER_BYTES_3, PLAYER_BYTES_3_OFFSET_GENDER);
 
     if (sWorld->getBoolConfig(CONFIG_TALENTS_INSPECTING) || GetPlayer()->IsGameMaster())
     {
         PlayerTalentMap const* talents = player->GetTalentMap(player->GetActiveTalentGroup());
         for (PlayerTalentMap::value_type const& v : *talents)
         {
             if (v.second != PLAYERSPELL_REMOVED)
                 inspectResult.Talents.push_back(v.first);
         }
 
         for (uint8 i = 0; i < MAX_GLYPH_SLOT_INDEX; ++i)
             inspectResult.Glyphs.push_back(player->GetGlyph(player->GetActiveTalentGroup(), i));
     }
 
     if (Guild* guild = sGuildMgr->GetGuildById(player->GetGuildId()))
     {
         inspectResult.GuildData = boost::in_place();
         inspectResult.GuildData->GuildGUID = guild->GetGUID();
         inspectResult.GuildData->NumGuildMembers = guild->GetMembersCount();
         inspectResult.GuildData->AchievementPoints = guild->GetAchievementMgr().GetAchievementPoints();
     }
 
     inspectResult.InspecteeGUID = inspect.Target;
     inspectResult.SpecializationID = player->GetSpecId(player->GetActiveTalentGroup());
 
     SendPacket(inspectResult.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleInspectPVP ( WorldPackets::Inspect::InspectPVPRequest & request )

Todo:: : deal with request.InspectRealmAddress

Todo:: : fill brackets

 {
 
     Player* player = ObjectAccessor::FindPlayer(request.InspectTarget);
     if (!player)
     {
         TC_LOG_DEBUG("network", "WorldSession::HandleInspectPVP: Target %s not found.", request.InspectTarget.ToString().c_str());
         return;
     }
 
     TC_LOG_DEBUG("network", "WorldSession::HandleInspectPVP: Target %s, InspectRealmAddress %u.", request.InspectTarget.ToString().c_str(), request.InspectRealmAddress);
 
     if (!GetPlayer()->IsWithinDistInMap(player, INSPECT_DISTANCE, false))
         return;
 
     if (GetPlayer()->IsValidAttackTarget(player))
         return;
 
     WorldPackets::Inspect::InspectPVPResponse response;
     response.ClientGUID = request.InspectTarget;
 
     SendPacket(response.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (!_player->HasPendingBind())
     {
         TC_LOG_INFO("network", "InstanceLockResponse: Player %s (%s) tried to bind himself/teleport to graveyard without a pending bind!",
             _player->GetName().c_str(), _player->GetGUID().ToString().c_str());
         return;
     }
 
     if (packet.AcceptLock)
         _player->BindToInstance();
     else
         _player->RepopAtGraveyard();
 
     _player->SetPendingBind(0, 0);
 }

Here is the caller graph for this function:

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

 {
     Item* item = _player->GetItemByGuid(packet.ItemGUID);
     if (!item)
     {
         TC_LOG_DEBUG("network", "WorldSession::HandleItemRefund: Item (%s) not found!", packet.ItemGUID.ToString().c_str());
         return;
     }
 
     // Don't try to refund item currently being disenchanted
     if (_player->GetLootGUID() == packet.ItemGUID)
         return;
 
     GetPlayer()->RefundItem(item);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Handles the packet sent by the client when requesting information about item text.

This function is called when player clicks on item which has some flag set

 {
     WorldPackets::Query::QueryItemTextResponse queryItemTextResponse;
     queryItemTextResponse.Id = itemTextQuery.Id;
 
     if (Item* item = _player->GetItemByGuid(itemTextQuery.Id))
     {
         queryItemTextResponse.Valid = true;
         queryItemTextResponse.Item.Text = item->GetText();
     }
 
     SendPacket(queryItemTextResponse.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     TC_LOG_DEBUG("chat.system", "CMSG_JOIN_CHANNEL %s ChatChannelId: %u, CreateVoiceSession: %u, Internal: %u, ChannelName: %s, Password: %s",
         GetPlayerInfo().c_str(), packet.ChatChannelId, packet.CreateVoiceSession, packet.Internal, packet.ChannelName.c_str(), packet.Password.c_str());
 
     if (packet.ChatChannelId)
     {
         ChatChannelsEntry const* channel = sChatChannelsStore.LookupEntry(packet.ChatChannelId);
         if (!channel)
             return;
 
         AreaTableEntry const* zone = sAreaTableStore.LookupEntry(GetPlayer()->GetZoneId());
         if (!zone || !GetPlayer()->CanJoinConstantChannelInZone(channel, zone))
             return;
     }
 
     if (packet.ChannelName.empty())
         return;
 
     if (isdigit(packet.ChannelName[0]))
         return;
 
     if (ChannelMgr* cMgr = ChannelMgr::ForTeam(GetPlayer()->GetTeam()))
     {
         cMgr->SetTeam(GetPlayer()->GetTeam());
         if (Channel* channel = cMgr->GetJoinChannel(packet.ChannelName, packet.ChatChannelId))
             channel->JoinChannel(GetPlayer(), packet.Password);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     bool anythingLearned = false;
     for (uint32 talentId : packet.Talents)
         if (_player->LearnTalent(talentId))
             anythingLearned = true;
 
     if (anythingLearned)
         _player->SendTalentsInfoData();
 }

Here is the caller graph for this function:

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

 {
     TC_LOG_DEBUG("chat.system", "CMSG_LEAVE_CHANNEL %s ChannelName: %s, ZoneChannelID: %u",
         GetPlayerInfo().c_str(), packet.ChannelName.c_str(), packet.ZoneChannelID);
 
     if (packet.ChannelName.empty())
         return;
 
     if (ChannelMgr* cMgr = ChannelMgr::ForTeam(GetPlayer()->GetTeam()))
     {
         if (Channel* channel = cMgr->GetChannel(packet.ChannelName, GetPlayer()))
             channel->LeaveChannel(GetPlayer(), true);
         cMgr->LeftChannel(packet.ChannelName);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

error handling

 {
     Group* grp = GetPlayer()->GetGroup();
     if (!grp)
         return;
 
     if (_player->InBattleground())
     {
         SendPartyResult(PARTY_OP_INVITE, "", ERR_INVITE_RESTRICTED);
         return;
     }
 
     /********************/
 
     // everything's fine, do it
     SendPartyResult(PARTY_OP_LEAVE, GetPlayer()->GetName(), ERR_PARTY_RESULT_OK);
 
     GetPlayer()->RemoveFromGroup(GROUP_REMOVEMETHOD_LEAVE);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleLfgJoinOpcode ( WorldPacket & recvData )

 {
     if (!sLFGMgr->isOptionEnabled(lfg::LFG_OPTION_ENABLE_DUNGEON_FINDER | lfg::LFG_OPTION_ENABLE_RAID_BROWSER) ||
         (GetPlayer()->GetGroup() && GetPlayer()->GetGroup()->GetLeaderGUID() != GetPlayer()->GetGUID() &&
         (GetPlayer()->GetGroup()->GetMembersCount() == MAX_GROUP_SIZE || !GetPlayer()->GetGroup()->isLFGGroup())))
     {
         recvData.rfinish();
         return;
     }
 
     uint32 roles;
 
     recvData >> roles;
     for (int32 i = 0; i < 3; ++i)
         recvData.read_skip<uint32>();
 
     uint32 commentLen = recvData.ReadBits(9);
     uint32 numDungeons = recvData.ReadBits(24);
 
     if (!numDungeons)
     {
         TC_LOG_DEBUG("lfg", "CMSG_DF_JOIN %s no dungeons selected", GetPlayerInfo().c_str());
         recvData.rfinish();
         return;
     }
 
     std::string comment = recvData.ReadString(commentLen);
 
     lfg::LfgDungeonSet newDungeons;
     for (uint32 i = 0; i < numDungeons; ++i)
     {
         uint32 dungeon;
         recvData >> dungeon;
         dungeon &= 0x00FFFFFF;                             // remove the type from the dungeon entry
         if (dungeon)
             newDungeons.insert(dungeon);
     }
 
     TC_LOG_DEBUG("lfg", "CMSG_DF_JOIN %s roles: %u, Dungeons: %u, Comment: %s",
         GetPlayerInfo().c_str(), roles, uint8(newDungeons.size()), comment.c_str());
 
     sLFGMgr->JoinLfg(GetPlayer(), uint8(roles), newDungeons, comment);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleLfgLeaveOpcode ( WorldPacket & recvData )

 {
     ObjectGuid leaveGuid;
     Group* group = GetPlayer()->GetGroup();
     ObjectGuid guid = GetPlayer()->GetGUID();
     ObjectGuid gguid = group ? group->GetGUID() : guid;
 
     recvData.read_skip<uint32>();                          // Always 8
     recvData.read_skip<uint32>();                          // Join date
     recvData.read_skip<uint32>();                          // Always 3
     recvData.read_skip<uint32>();                          // Queue Id
 
     leaveGuid[4] = recvData.ReadBit();
     leaveGuid[5] = recvData.ReadBit();
     leaveGuid[0] = recvData.ReadBit();
     leaveGuid[6] = recvData.ReadBit();
     leaveGuid[2] = recvData.ReadBit();
     leaveGuid[7] = recvData.ReadBit();
     leaveGuid[1] = recvData.ReadBit();
     leaveGuid[3] = recvData.ReadBit();
 
     recvData.ReadByteSeq(leaveGuid[7]);
     recvData.ReadByteSeq(leaveGuid[4]);
     recvData.ReadByteSeq(leaveGuid[3]);
     recvData.ReadByteSeq(leaveGuid[2]);
     recvData.ReadByteSeq(leaveGuid[6]);
     recvData.ReadByteSeq(leaveGuid[0]);
     recvData.ReadByteSeq(leaveGuid[1]);
     recvData.ReadByteSeq(leaveGuid[5]);
 
     TC_LOG_DEBUG("lfg", "CMSG_DF_LEAVE %s in group: %u sent guid %s.",
         GetPlayerInfo().c_str(), group ? 1 : 0, leaveGuid.ToString().c_str());
 
     // Check cheating - only leader can leave the queue
     if (!group || group->GetLeaderGUID() == guid)
         sLFGMgr->LeaveLfg(gguid);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleLfgProposalResultOpcode ( WorldPacket & recvData )

 {
     uint32 proposalID;  // Proposal ID
     bool accept;
 
     ObjectGuid guid1;
     ObjectGuid guid2;
 
     recvData >> proposalID;
     recvData.read_skip<uint32>();
     recvData.read_skip<uint32>();
     recvData.read_skip<uint32>();
 
     guid2[4] = recvData.ReadBit();
     guid2[5] = recvData.ReadBit();
     guid2[0] = recvData.ReadBit();
     guid2[6] = recvData.ReadBit();
     guid2[2] = recvData.ReadBit();
     guid2[7] = recvData.ReadBit();
     guid2[1] = recvData.ReadBit();
     guid2[3] = recvData.ReadBit();
 
     recvData.ReadByteSeq(guid2[7]);
     recvData.ReadByteSeq(guid2[4]);
     recvData.ReadByteSeq(guid2[3]);
     recvData.ReadByteSeq(guid2[2]);
     recvData.ReadByteSeq(guid2[6]);
     recvData.ReadByteSeq(guid2[0]);
     recvData.ReadByteSeq(guid2[1]);
     recvData.ReadByteSeq(guid2[5]);
 
     guid1[7] = recvData.ReadBit();
     accept =  recvData.ReadBit();
     guid1[1] = recvData.ReadBit();
     guid1[3] = recvData.ReadBit();
     guid1[0] = recvData.ReadBit();
     guid1[5] = recvData.ReadBit();
     guid1[4] = recvData.ReadBit();
     guid1[6] = recvData.ReadBit();
     guid1[2] = recvData.ReadBit();
 
     recvData.ReadByteSeq(guid1[7]);
     recvData.ReadByteSeq(guid1[1]);
     recvData.ReadByteSeq(guid1[5]);
     recvData.ReadByteSeq(guid1[6]);
     recvData.ReadByteSeq(guid1[3]);
     recvData.ReadByteSeq(guid1[4]);
     recvData.ReadByteSeq(guid1[0]);
     recvData.ReadByteSeq(guid1[2]);
 
     TC_LOG_DEBUG("lfg", "CMSG_LFG_PROPOSAL_RESULT %s proposal: %u accept: %u",
         GetPlayerInfo().c_str(), proposalID, accept ? 1 : 0);
     sLFGMgr->UpdateProposal(proposalID, GetPlayer()->GetGUID(), accept);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleLfgSetBootVoteOpcode ( WorldPacket & recvData )

 {
     bool agree;                                            // Agree to kick player
     recvData >> agree;
 
     ObjectGuid guid = GetPlayer()->GetGUID();
     TC_LOG_DEBUG("lfg", "CMSG_LFG_SET_BOOT_VOTE %s agree: %u",
         GetPlayerInfo().c_str(), agree ? 1 : 0);
     sLFGMgr->UpdateBoot(guid, agree);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleLfgSetCommentOpcode ( WorldPacket & recvData )

 {
     uint32 length = recvData.ReadBits(9);
     std::string comment = recvData.ReadString(length);
 
     TC_LOG_DEBUG("lfg", "CMSG_LFG_SET_COMMENT %s comment: %s",
         GetPlayerInfo().c_str(), comment.c_str());
 
     sLFGMgr->SetComment(GetPlayer()->GetGUID(), comment);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleLfgSetRolesOpcode ( WorldPacket & recvData )

 {
     uint8 roles;
     recvData >> roles;                                     // Player Group Roles
     ObjectGuid guid = GetPlayer()->GetGUID();
     Group* group = GetPlayer()->GetGroup();
     if (!group)
     {
         TC_LOG_DEBUG("lfg", "CMSG_DF_SET_ROLES %s Not in group",
             GetPlayerInfo().c_str());
         return;
     }
     ObjectGuid gguid = group->GetGUID();
     TC_LOG_DEBUG("lfg", "CMSG_DF_SET_ROLES: Group %s, Player %s, Roles: %u",
         gguid.ToString().c_str(), GetPlayerInfo().c_str(), roles);
     sLFGMgr->UpdateRoleCheck(gguid, guid, roles);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleLfgTeleportOpcode ( WorldPacket & recvData )

 {
     bool out;
     recvData >> out;
 
     TC_LOG_DEBUG("lfg", "CMSG_DF_TELEPORT %s out: %u",
         GetPlayerInfo().c_str(), out ? 1 : 0);
     sLFGMgr->TeleportPlayer(GetPlayer(), out, true);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleLfrJoinOpcode ( WorldPacket & recvData )

 {
     uint32 entry;                                          // Raid id to search
     recvData >> entry;
     TC_LOG_DEBUG("lfg", "CMSG_LFG_LFR_JOIN %s dungeon entry: %u",
         GetPlayerInfo().c_str(), entry);
     //SendLfrUpdateListOpcode(entry);
 }

Here is the call graph for this function:

void WorldSession::HandleLfrLeaveOpcode ( WorldPacket & recvData )

 {
     uint32 dungeonId;                                      // Raid id queue to leave
     recvData >> dungeonId;
     TC_LOG_DEBUG("lfg", "CMSG_LFG_LFR_LEAVE %s dungeonId: %u",
         GetPlayerInfo().c_str(), dungeonId);
     //sLFGMgr->LeaveLfr(GetPlayer(), dungeonId);
 }

Here is the call graph for this function:

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

 {
     if (!GetPlayer()->IsAlive())
         return;
 
     SendListInventory(packet.Unit);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     // TODO: Do something with this packet
 }

Here is the caller graph for this function:

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

we can move again

Stand Up

DISABLE_ROTATE

 {
     // Player have already logged out serverside, too late to cancel
     if (!GetPlayer())
         return;
 
     SetLogoutStartTime(0);
 
     SendPacket(WorldPackets::Character::LogoutCancelAck().Write());
 
     // not remove flags if can't free move - its not set in Logout request code.
     if (GetPlayer()->CanFreeMove())
     {
         GetPlayer()->SetRooted(false);
 
         GetPlayer()->SetStandState(UNIT_STAND_STATE_STAND);
 
         GetPlayer()->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_STUNNED);
     }
 
     TC_LOG_DEBUG("network", "WORLD: Sent SMSG_LOGOUT_CANCEL_ACK Message");
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

TODO: Possibly add RBAC permission to log out in combat

 {
     ObjectGuid lguid = GetPlayer()->GetLootGUID();
     if (!lguid.IsEmpty())
         DoLootRelease(lguid);
 
     bool instantLogout = (GetPlayer()->HasFlag(PLAYER_FLAGS, PLAYER_FLAGS_RESTING) && !GetPlayer()->IsInCombat()) ||
                          GetPlayer()->IsInFlight() || HasPermission(rbac::RBAC_PERM_INSTANT_LOGOUT);
 
     bool canLogoutInCombat = GetPlayer()->HasFlag(PLAYER_FLAGS, PLAYER_FLAGS_RESTING);
 
     uint32 reason = 0;
     if (GetPlayer()->IsInCombat() && !canLogoutInCombat)
         reason = 1;
     else if (GetPlayer()->IsFalling())
         reason = 3;                                         // is jumping or falling
     else if (GetPlayer()->duel || GetPlayer()->HasAura(9454)) // is dueling or frozen by GM via freeze command
         reason = 2;                                         // FIXME - Need the correct value
 
     WorldPackets::Character::LogoutResponse logoutResponse;
     logoutResponse.LogoutResult = reason;
     logoutResponse.Instant = instantLogout;
     SendPacket(logoutResponse.Write());
 
     if (reason)
     {
         SetLogoutStartTime(0);
         return;
     }
 
     // instant logout in taverns/cities or on taxi or for admins, gm's, mod's if its enabled in worldserver.conf
     if (instantLogout)
     {
         LogoutPlayer(true);
         return;
     }
 
     // not set flags if player can't free move to prevent lost state at logout cancel
     if (GetPlayer()->CanFreeMove())
     {
         if (GetPlayer()->GetStandState() == UNIT_STAND_STATE_STAND)
             GetPlayer()->SetStandState(UNIT_STAND_STATE_SIT);
         GetPlayer()->SetRooted(true);
         GetPlayer()->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_STUNNED);
     }
 
     SetLogoutStartTime(time(NULL));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleLookingForGroup ( WorldPacket & recvPacket )

void WorldSession::HandleLootMasterGiveOpcode ( WorldPacket & recvPacket )

 {
     uint8 slotid;
     ObjectGuid lootguid, target_playerguid;
 
     recvData >> lootguid >> slotid >> target_playerguid;
 
     if (!_player->GetGroup() || _player->GetGroup()->GetMasterLooterGuid() != _player->GetGUID() || _player->GetGroup()->GetLootMethod() != MASTER_LOOT)
     {
         _player->SendLootError(lootguid, LOOT_ERROR_DIDNT_KILL);
         return;
     }
 
     Player* target = ObjectAccessor::FindPlayer(target_playerguid);
     if (!target)
     {
         _player->SendLootError(lootguid, LOOT_ERROR_PLAYER_NOT_FOUND);
         return;
     }
 
     TC_LOG_DEBUG("network", "WorldSession::HandleLootMasterGiveOpcode (CMSG_LOOT_MASTER_GIVE, 0x02A3) Target = [%s].", target->GetName().c_str());
 
     if (_player->GetLootGUID() != lootguid)
     {
         _player->SendLootError(lootguid, LOOT_ERROR_DIDNT_KILL);
         return;
     }
 
     if (!_player->IsInRaidWith(target) || !_player->IsInMap(target))
     {
         _player->SendLootError(lootguid, LOOT_ERROR_MASTER_OTHER);
         TC_LOG_INFO("loot", "MasterLootItem: Player %s tried to give an item to ineligible player %s !", GetPlayer()->GetName().c_str(), target->GetName().c_str());
         return;
     }
 
     Loot* loot = NULL;
 
     if (GetPlayer()->GetLootGUID().IsCreatureOrVehicle())
     {
         Creature* creature = GetPlayer()->GetMap()->GetCreature(lootguid);
         if (!creature)
             return;
 
         loot = &creature->loot;
     }
     else if (GetPlayer()->GetLootGUID().IsGameObject())
     {
         GameObject* pGO = GetPlayer()->GetMap()->GetGameObject(lootguid);
         if (!pGO)
             return;
 
         loot = &pGO->loot;
     }
 
     if (!loot)
         return;
 
     if (slotid >= loot->items.size() + loot->quest_items.size())
     {
         TC_LOG_DEBUG("loot", "MasterLootItem: Player %s might be using a hack! (slot %d, size %lu)",
             GetPlayer()->GetName().c_str(), slotid, (unsigned long)loot->items.size());
         return;
     }
 
     LootItem& item = slotid >= loot->items.size() ? loot->quest_items[slotid - loot->items.size()] : loot->items[slotid];
 
     ItemPosCountVec dest;
     InventoryResult msg = target->CanStoreNewItem(NULL_BAG, NULL_SLOT, dest, item.itemid, item.count);
     if (item.follow_loot_rules && !item.AllowedForPlayer(target))
         msg = EQUIP_ERR_CANT_EQUIP_EVER;
     if (msg != EQUIP_ERR_OK)
     {
         if (msg == EQUIP_ERR_ITEM_MAX_COUNT)
             _player->SendLootError(lootguid, LOOT_ERROR_MASTER_UNIQUE_ITEM);
         else if (msg == EQUIP_ERR_INV_FULL)
             _player->SendLootError(lootguid, LOOT_ERROR_MASTER_INV_FULL);
         else
             _player->SendLootError(lootguid, LOOT_ERROR_MASTER_OTHER);
 
         target->SendEquipError(msg, NULL, NULL, item.itemid);
         return;
     }
 
     // now move item from loot to target inventory
     Item* newitem = target->StoreNewItem(dest, item.itemid, true, item.randomPropertyId, item.GetAllowedLooters(), item.BonusListIDs);
     target->SendNewItem(newitem, uint32(item.count), false, false, true);
     target->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_LOOT_ITEM, item.itemid, item.count);
     target->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_LOOT_TYPE, item.itemid, item.count, loot->loot_type);
     target->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_LOOT_EPIC_ITEM, item.itemid, item.count);
 
     // mark as looted
     item.count = 0;
     item.is_looted = true;
 
     loot->NotifyItemRemoved(slotid);
     --loot->unlootedCount;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     Player* player = GetPlayer();
     ObjectGuid guid = player->GetLootGUID();
     if (!guid)
         return;
 
     Loot* loot = NULL;
     bool shareMoney = true;
 
     switch (guid.GetHigh())
     {
         case HighGuid::GameObject:
         {
             GameObject* go = GetPlayer()->GetMap()->GetGameObject(guid);
 
             // do not check distance for GO if player is the owner of it (ex. fishing bobber)
             if (go && ((go->GetOwnerGUID() == player->GetGUID() || go->IsWithinDistInMap(player, INTERACTION_DISTANCE))))
                 loot = &go->loot;
 
             break;
         }
         case HighGuid::Corpse:                               // remove insignia ONLY in BG
         {
             Corpse* bones = ObjectAccessor::GetCorpse(*player, guid);
 
             if (bones && bones->IsWithinDistInMap(player, INTERACTION_DISTANCE))
             {
                 loot = &bones->loot;
                 shareMoney = false;
             }
 
             break;
         }
         case HighGuid::Item:
         {
             if (Item* item = player->GetItemByGuid(guid))
             {
                 loot = &item->loot;
                 shareMoney = false;
             }
             break;
         }
         case HighGuid::Creature:
         case HighGuid::Vehicle:
         {
             Creature* creature = player->GetMap()->GetCreature(guid);
             bool lootAllowed = creature && creature->IsAlive() == (player->getClass() == CLASS_ROGUE && creature->loot.loot_type == LOOT_PICKPOCKETING);
             if (lootAllowed && creature->IsWithinDistInMap(player, INTERACTION_DISTANCE))
             {
                 loot = &creature->loot;
                 if (creature->IsAlive())
                     shareMoney = false;
             }
             else
                 player->SendLootError(guid, lootAllowed ? LOOT_ERROR_TOO_FAR : LOOT_ERROR_DIDNT_KILL);
             break;
         }
         default:
             return;                                         // unlootable type
     }
 
     if (loot)
     {
         loot->NotifyMoneyRemoved();
         if (shareMoney && player->GetGroup())      //item, pickpocket and players can be looted only single player
         {
             Group* group = player->GetGroup();
 
             std::vector<Player*> playersNear;
             for (GroupReference* itr = group->GetFirstMember(); itr != NULL; itr = itr->next())
             {
                 Player* member = itr->GetSource();
                 if (!member)
                     continue;
 
                 if (player->IsAtGroupRewardDistance(member))
                     playersNear.push_back(member);
             }
 
             uint32 goldPerPlayer = uint32((loot->gold) / (playersNear.size()));
 
             for (std::vector<Player*>::const_iterator i = playersNear.begin(); i != playersNear.end(); ++i)
             {
                 (*i)->ModifyMoney(goldPerPlayer);
                 (*i)->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_LOOT_MONEY, goldPerPlayer);
 
                 if (Guild* guild = sGuildMgr->GetGuildById((*i)->GetGuildId()))
                     if (uint32 guildGold = CalculatePct(goldPerPlayer, (*i)->GetTotalAuraModifier(SPELL_AURA_DEPOSIT_BONUS_MONEY_IN_GUILD_BANK_ON_LOOT)))
                         guild->HandleMemberDepositMoney(this, guildGold, true);
 
                 WorldPackets::Loot::LootMoneyNotify packet;
                 packet.Money = goldPerPlayer;
                 packet.SoleLooter = playersNear.size() <= 1 ? true : false;
                 (*i)->SendDirectMessage(packet.Write());
             }
         }
         else
         {
             player->ModifyMoney(loot->gold);
             player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_LOOT_MONEY, loot->gold);
 
             if (Guild* guild = sGuildMgr->GetGuildById(player->GetGuildId()))
                 if (uint32 guildGold = CalculatePct(loot->gold, player->GetTotalAuraModifier(SPELL_AURA_DEPOSIT_BONUS_MONEY_IN_GUILD_BANK_ON_LOOT)))
                     guild->HandleMemberDepositMoney(this, guildGold, true);
 
             WorldPackets::Loot::LootMoneyNotify packet;
             packet.Money = loot->gold;
             packet.SoleLooter = true; // "You loot..."
             SendPacket(packet.Write());
         }
 
         loot->gold = 0;
 
         // Delete the money loot record from the DB
         if (!loot->containerID.IsEmpty())
             loot->DeleteLootMoneyFromContainerItemDB();
 
         // Delete container if empty
         if (loot->isLooted() && guid.IsItem())
             player->GetSession()->DoLootRelease(guid);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     // Check possible cheat
     if (!GetPlayer()->IsAlive() || !packet.Unit.IsCreatureOrVehicle())
         return;
 
     GetPlayer()->SendLoot(packet.Unit, LOOT_CORPSE);
 
     // interrupt cast
     if (GetPlayer()->IsNonMeleeSpellCast(false))
         GetPlayer()->InterruptNonMeleeSpells(false);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     // cheaters can modify lguid to prevent correct apply loot release code and re-loot
     // use internal stored guid
     ObjectGuid lguid = GetPlayer()->GetLootGUID();
     if (!lguid.IsEmpty())
         if (lguid == packet.Unit)
             DoLootRelease(lguid);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     Group* group = GetPlayer()->GetGroup();
     if (!group)
         return;
 
     group->CountRollVote(GetPlayer()->GetGUID(), packet.LootObj, packet.RollType);
 
     switch (packet.RollType)
     {
         case ROLL_NEED:
             GetPlayer()->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_ROLL_NEED, 1);
             break;
         case ROLL_GREED:
             GetPlayer()->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_ROLL_GREED, 1);
             break;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleMailCreateTextItem ( WorldPackets::Mail::MailCreateTextItem & packet )

 {
     if (!CanOpenMailBox(packet.Mailbox))
         return;
 
     Player* player = _player;
 
     Mail* m = player->GetMail(packet.MailID);
     if (!m || (m->body.empty() && !m->mailTemplateId) || m->state == MAIL_STATE_DELETED || m->deliver_time > time(nullptr) || (m->checked & MAIL_CHECK_MASK_COPIED))
     {
         player->SendMailResult(packet.MailID, MAIL_MADE_PERMANENT, MAIL_ERR_INTERNAL_ERROR);
         return;
     }
 
     Item* bodyItem = new Item;                              // This is not bag and then can be used new Item.
     if (!bodyItem->Create(sObjectMgr->GetGenerator<HighGuid::Item>().Generate(), MAIL_BODY_ITEM_TEMPLATE, player))
     {
         delete bodyItem;
         return;
     }
 
     // in mail template case we need create new item text
     if (m->mailTemplateId)
     {
         MailTemplateEntry const* mailTemplateEntry = sMailTemplateStore.LookupEntry(m->mailTemplateId);
         if (!mailTemplateEntry)
         {
             player->SendMailResult(packet.MailID, MAIL_MADE_PERMANENT, MAIL_ERR_INTERNAL_ERROR);
             return;
         }
 
         bodyItem->SetText(mailTemplateEntry->Body->Str[GetSessionDbcLocale()]);
     }
     else
         bodyItem->SetText(m->body);
 
     if (m->messageType == MAIL_NORMAL)
         bodyItem->SetGuidValue(ITEM_FIELD_CREATOR, ObjectGuid::Create<HighGuid::Player>(m->sender));
 
     bodyItem->SetFlag(ITEM_FIELD_FLAGS, ITEM_FIELD_FLAG_MAIL_TEXT_MASK);
 
     ItemPosCountVec dest;
     uint8 msg = _player->CanStoreItem(NULL_BAG, NULL_SLOT, dest, bodyItem, false);
     if (msg == EQUIP_ERR_OK)
     {
         m->checked = m->checked | MAIL_CHECK_MASK_COPIED;
         m->state = MAIL_STATE_CHANGED;
         player->m_mailsUpdated = true;
 
         player->StoreItem(dest, bodyItem, true);
         player->SendMailResult(packet.MailID, MAIL_MADE_PERMANENT, MAIL_OK);
     }
     else
     {
         player->SendMailResult(packet.MailID, MAIL_MADE_PERMANENT, MAIL_ERR_EQUIP_ERROR, msg);
         delete bodyItem;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleMailDelete ( WorldPackets::Mail::MailDelete & packet )

 {
     Mail* m = _player->GetMail(packet.MailID);
     Player* player = _player;
     player->m_mailsUpdated = true;
     if (m)
     {
         // delete shouldn't show up for COD mails
         if (m->COD)
         {
             player->SendMailResult(packet.MailID, MAIL_DELETED, MAIL_ERR_INTERNAL_ERROR);
             return;
         }
 
         m->state = MAIL_STATE_DELETED;
     }
     player->SendMailResult(packet.MailID, MAIL_DELETED, MAIL_OK);
 }

Here is the caller graph for this function:

void WorldSession::HandleMailMarkAsRead ( WorldPackets::Mail::MailMarkAsRead & packet )

 {
     if (!CanOpenMailBox(packet.Mailbox))
         return;
 
     Player* player = _player;
     Mail* m = player->GetMail(packet.MailID);
     if (m && m->state != MAIL_STATE_DELETED)
     {
         if (player->unReadMails)
             --player->unReadMails;
         m->checked = m->checked | MAIL_CHECK_MASK_READ;
         player->m_mailsUpdated = true;
         m->state = MAIL_STATE_CHANGED;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleMailReturnToSender ( WorldPackets::Mail::MailReturnToSender & packet )

 {
     //TODO: find a proper way to replace this check. Idea: Save Guid form MailGetList until CMSG_CLOSE_INTERACTION is sent
     /*if (!CanOpenMailBox(mailbox))
         return;*/
 
     Player* player = _player;
     Mail* m = player->GetMail(packet.MailID);
     if (!m || m->state == MAIL_STATE_DELETED || m->deliver_time > time(nullptr) || m->sender != packet.SenderGUID.GetCounter())
     {
         player->SendMailResult(packet.MailID, MAIL_RETURNED_TO_SENDER, MAIL_ERR_INTERNAL_ERROR);
         return;
     }
     //we can return mail now, so firstly delete the old one
     SQLTransaction trans = CharacterDatabase.BeginTransaction();
 
     PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_MAIL_BY_ID);
     stmt->setUInt32(0, packet.MailID);
     trans->Append(stmt);
 
     stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_MAIL_ITEM_BY_ID);
     stmt->setUInt32(0, packet.MailID);
     trans->Append(stmt);
 
     player->RemoveMail(packet.MailID);
 
     // only return mail if the player exists (and delete if not existing)
     if (m->messageType == MAIL_NORMAL && m->sender)
     {
         MailDraft draft(m->subject, m->body);
         if (m->mailTemplateId)
             draft = MailDraft(m->mailTemplateId, false);     // items already included
 
         if (m->HasItems())
         {
             for (MailItemInfoVec::iterator itr2 = m->items.begin(); itr2 != m->items.end(); ++itr2)
             {
                 if (Item* const item = player->GetMItem(itr2->item_guid))
                     draft.AddItem(item);
                 player->RemoveMItem(itr2->item_guid);
             }
         }
         draft.AddMoney(m->money).SendReturnToSender(GetAccountId(), m->receiver, m->sender, trans);
     }
 
     CharacterDatabase.CommitTransaction(trans);
 
     delete m;                                               //we can deallocate old mail
     player->SendMailResult(packet.MailID, MAIL_RETURNED_TO_SENDER, MAIL_OK);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleMailTakeItem ( WorldPackets::Mail::MailTakeItem & packet )

 {
     uint32 AttachID = packet.AttachID;
 
     if (!CanOpenMailBox(packet.Mailbox))
         return;
 
     Player* player = _player;
 
     Mail* m = player->GetMail(packet.MailID);
     if (!m || m->state == MAIL_STATE_DELETED || m->deliver_time > time(nullptr))
     {
         player->SendMailResult(packet.MailID, MAIL_ITEM_TAKEN, MAIL_ERR_INTERNAL_ERROR);
         return;
     }
 
     // verify that the mail has the item to avoid cheaters taking COD items without paying
     if (std::find_if(m->items.begin(), m->items.end(), [AttachID](MailItemInfo info){ return info.item_guid == AttachID; }) == m->items.end())
     {
         player->SendMailResult(packet.MailID, MAIL_ITEM_TAKEN, MAIL_ERR_INTERNAL_ERROR);
         return;
     }
 
     // prevent cheating with skip client money check
     if (!player->HasEnoughMoney(uint64(m->COD)))
     {
         player->SendMailResult(packet.MailID, MAIL_ITEM_TAKEN, MAIL_ERR_NOT_ENOUGH_MONEY);
         return;
     }
 
     Item* it = player->GetMItem(packet.AttachID);
 
     ItemPosCountVec dest;
     uint8 msg = _player->CanStoreItem(NULL_BAG, NULL_SLOT, dest, it, false);
     if (msg == EQUIP_ERR_OK)
     {
         SQLTransaction trans = CharacterDatabase.BeginTransaction();
         m->RemoveItem(packet.AttachID);
         m->removedItems.push_back(packet.AttachID);
 
         if (m->COD > 0)                                     //if there is COD, take COD money from player and send them to sender by mail
         {
             ObjectGuid sender_guid = ObjectGuid::Create<HighGuid::Player>(m->sender);
             Player* receiver = ObjectAccessor::FindConnectedPlayer(sender_guid);
 
             uint32 sender_accId = 0;
 
             if (HasPermission(rbac::RBAC_PERM_LOG_GM_TRADE))
             {
                 std::string sender_name;
                 if (receiver)
                 {
                     sender_accId = receiver->GetSession()->GetAccountId();
                     sender_name = receiver->GetName();
                 }
                 else
                 {
                     // can be calculated early
                     sender_accId = ObjectMgr::GetPlayerAccountIdByGUID(sender_guid);
 
                     if (!ObjectMgr::GetPlayerNameByGUID(sender_guid, sender_name))
                         sender_name = sObjectMgr->GetTrinityStringForDBCLocale(LANG_UNKNOWN);
                 }
                 sLog->outCommand(GetAccountId(), "GM %s (Account: %u) receiver mail item: %s (Entry: %u Count: %u) and send COD money: " UI64FMTD " to player: %s (Account: %u)",
                     GetPlayerName().c_str(), GetAccountId(), it->GetTemplate()->GetDefaultLocaleName(), it->GetEntry(), it->GetCount(), m->COD, sender_name.c_str(), sender_accId);
             }
             else if (!receiver)
                 sender_accId = ObjectMgr::GetPlayerAccountIdByGUID(sender_guid);
 
             // check player existence
             if (receiver || sender_accId)
             {
                 MailDraft(m->subject, "")
                     .AddMoney(m->COD)
                     .SendMailTo(trans, MailReceiver(receiver, m->sender), MailSender(MAIL_NORMAL, m->receiver), MAIL_CHECK_MASK_COD_PAYMENT);
             }
 
             player->ModifyMoney(-int32(m->COD));
         }
         m->COD = 0;
         m->state = MAIL_STATE_CHANGED;
         player->m_mailsUpdated = true;
         player->RemoveMItem(it->GetGUID().GetCounter());
 
         uint32 count = it->GetCount();                      // save counts before store and possible merge with deleting
         it->SetState(ITEM_UNCHANGED);                       // need to set this state, otherwise item cannot be removed later, if neccessary
         player->MoveItemToInventory(dest, it, true);
 
         player->SaveInventoryAndGoldToDB(trans);
         player->_SaveMail(trans);
         CharacterDatabase.CommitTransaction(trans);
 
         player->SendMailResult(packet.MailID, MAIL_ITEM_TAKEN, MAIL_OK, 0, packet.AttachID, count);
     }
     else
         player->SendMailResult(packet.MailID, MAIL_ITEM_TAKEN, MAIL_ERR_EQUIP_ERROR, msg);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleMailTakeMoney ( WorldPackets::Mail::MailTakeMoney & packet )

 {
     if (!CanOpenMailBox(packet.Mailbox))
         return;
 
     Player* player = _player;
 
     Mail* m = player->GetMail(packet.MailID);
     if ((!m || m->state == MAIL_STATE_DELETED || m->deliver_time > time(NULL)) ||
         (packet.Money > 0 && m->money != uint64(packet.Money)))
     {
         player->SendMailResult(packet.MailID, MAIL_MONEY_TAKEN, MAIL_ERR_INTERNAL_ERROR);
         return;
     }
 
     if (!player->ModifyMoney(m->money, false))
     {
         player->SendMailResult(packet.MailID, MAIL_MONEY_TAKEN, MAIL_ERR_EQUIP_ERROR, EQUIP_ERR_TOO_MUCH_GOLD);
         return;
     }
 
     m->money = 0;
     m->state = MAIL_STATE_CHANGED;
     player->m_mailsUpdated = true;
 
     player->SendMailResult(packet.MailID, MAIL_MONEY_TAKEN, MAIL_OK);
 
     // save money and mail to prevent cheating
     SQLTransaction trans = CharacterDatabase.BeginTransaction();
     player->SaveGoldToDB(trans);
     player->_SaveMail(trans);
     CharacterDatabase.CommitTransaction(trans);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleMeetingStoneInfo ( WorldPacket & recPacket )

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

 {
     if (!GetPlayer()->GetGroup())
         return;
 
     WorldPackets::Party::MinimapPing minimapPing;
     minimapPing.Sender = GetPlayer()->GetGUID();
     minimapPing.PositionX = packet.PositionX;
     minimapPing.PositionY = packet.PositionY;
     GetPlayer()->GetGroup()->BroadcastPacket(minimapPing.Write(), true, -1, GetPlayer()->GetGUID());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     ObjectGuid guid = getMirrorImageData.UnitGUID;
 
     // Get unit for which data is needed by client
     Unit* unit = ObjectAccessor::GetUnit(*_player, guid);
     if (!unit)
         return;
 
     if (!unit->HasAuraType(SPELL_AURA_CLONE_CASTER))
         return;
 
     // Get creator of the unit (SPELL_AURA_CLONE_CASTER does not stack)
     Unit* creator = unit->GetAuraEffectsByType(SPELL_AURA_CLONE_CASTER).front()->GetCaster();
     if (!creator)
         return;
 
     if (Player* player = creator->ToPlayer())
     {
         WorldPackets::Spells::MirrorImageComponentedData mirrorImageComponentedData;
         mirrorImageComponentedData.UnitGUID = guid;
         mirrorImageComponentedData.DisplayID = creator->GetDisplayId();
         mirrorImageComponentedData.RaceID = creator->getRace();
         mirrorImageComponentedData.Gender = creator->getGender();
         mirrorImageComponentedData.ClassID = creator->getClass();
 
         Guild* guild = player->GetGuild();
 
         mirrorImageComponentedData.SkinColor = player->GetByteValue(PLAYER_BYTES, PLAYER_BYTES_OFFSET_SKIN_ID);
         mirrorImageComponentedData.FaceVariation = player->GetByteValue(PLAYER_BYTES, PLAYER_BYTES_OFFSET_FACE_ID);
         mirrorImageComponentedData.HairVariation = player->GetByteValue(PLAYER_BYTES, PLAYER_BYTES_OFFSET_HAIR_STYLE_ID);
         mirrorImageComponentedData.HairColor = player->GetByteValue(PLAYER_BYTES, PLAYER_BYTES_OFFSET_HAIR_COLOR_ID);
         mirrorImageComponentedData.BeardVariation = player->GetByteValue(PLAYER_BYTES_2, PLAYER_BYTES_2_OFFSET_FACIAL_STYLE);
         mirrorImageComponentedData.GuildGUID = (guild ? guild->GetGUID() : ObjectGuid::Empty);
 
         mirrorImageComponentedData.ItemDisplayID.reserve(11);
 
         static EquipmentSlots const itemSlots[] =
         {
             EQUIPMENT_SLOT_HEAD,
             EQUIPMENT_SLOT_SHOULDERS,
             EQUIPMENT_SLOT_BODY,
             EQUIPMENT_SLOT_CHEST,
             EQUIPMENT_SLOT_WAIST,
             EQUIPMENT_SLOT_LEGS,
             EQUIPMENT_SLOT_FEET,
             EQUIPMENT_SLOT_WRISTS,
             EQUIPMENT_SLOT_HANDS,
             EQUIPMENT_SLOT_TABARD,
             EQUIPMENT_SLOT_BACK,
             EQUIPMENT_SLOT_END
         };
 
         // Display items in visible slots
         for (auto const& slot : itemSlots)
         {
             uint32 itemDisplayId;
             if ((slot == EQUIPMENT_SLOT_HEAD && player->HasFlag(PLAYER_FLAGS, PLAYER_FLAGS_HIDE_HELM)) ||
                 (slot == EQUIPMENT_SLOT_BACK && player->HasFlag(PLAYER_FLAGS, PLAYER_FLAGS_HIDE_CLOAK)))
                 itemDisplayId = 0;
             else if (Item const* item = player->GetItemByPos(INVENTORY_SLOT_BAG_0, slot))
                 itemDisplayId = item->GetDisplayId();
             else
                 itemDisplayId = 0;
 
             mirrorImageComponentedData.ItemDisplayID.push_back(itemDisplayId);
         }
         SendPacket(mirrorImageComponentedData.Write());
     }
     else
     {
         WorldPackets::Spells::MirrorImageCreatureData mirrorImageCreatureData;
         mirrorImageCreatureData.UnitGUID = guid;
         mirrorImageCreatureData.DisplayID = creator->GetDisplayId();
         SendPacket(mirrorImageCreatureData.Write());
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     Unit* caster = ObjectAccessor::GetUnit(*_player, packet.Target);
     if (!caster)
         return;
 
     Spell* spell = caster->FindCurrentSpellBySpellId(packet.SpellID);
     if (!spell || !spell->m_targets.HasDst())
         return;
 
     Position pos = *spell->m_targets.GetDstPos();
     pos.Relocate(packet.CollisionPos);
     spell->m_targets.ModDst(pos);
 
     WorldPackets::Spells::NotifyMissileTrajectoryCollision notify;
     notify.Caster = packet.Target;
     notify.CastID = packet.CastID;
     notify.CollisionPos = packet.CollisionPos;
     caster->SendMessageToSet(notify.Write(), true);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     WorldPackets::Misc::SpecialMountAnim specialMountAnim;
     specialMountAnim.UnitGUID = _player->GetGUID();
     GetPlayer()->SendMessageToSet(specialMountAnim.Write(), false);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     Unit* vehicle_base = GetPlayer()->GetVehicleBase();
     if (!vehicle_base)
         return;
 
     VehicleSeatEntry const* seat = GetPlayer()->GetVehicle()->GetSeatForPassenger(GetPlayer());
     if (!seat->CanSwitchFromSeat())
     {
         TC_LOG_ERROR("network", "HandleMoveChangeVehicleSeats: %s tried to switch seats but current seatflags %u don't permit that.",
             GetPlayer()->GetGUID().ToString().c_str(), seat->Flags);
         return;
     }
 
     GetPlayer()->ValidateMovementInfo(&moveChangeVehicleSeats.Status);
 
     if (vehicle_base->GetGUID() != moveChangeVehicleSeats.Status.guid)
         return;
 
     vehicle_base->m_movementInfo = moveChangeVehicleSeats.Status;
 
     if (moveChangeVehicleSeats.DstVehicle.IsEmpty())
         GetPlayer()->ChangeSeat(-1, moveChangeVehicleSeats.DstSeatIndex != 255);
     else if (Unit* vehUnit = ObjectAccessor::GetUnit(*GetPlayer(), moveChangeVehicleSeats.DstVehicle))
         if (Vehicle* vehicle = vehUnit->GetVehicleKit())
             if (vehicle->HasEmptySeat(moveChangeVehicleSeats.DstSeatIndex))
                 vehUnit->HandleSpellClick(GetPlayer(), int8(moveChangeVehicleSeats.DstSeatIndex));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     ObjectGuid vehicleGUID = _player->GetCharmGUID();
     if (vehicleGUID.IsEmpty())
         return;
 
     _player->ValidateMovementInfo(&moveDismissVehicle.Status);
     _player->m_movementInfo = moveDismissVehicle.Status;
 
     _player->ExitVehicle();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleMoveKnockBackAck ( WorldPackets::Movement::MovementAckMessage & movementAck )

 {
     GetPlayer()->ValidateMovementInfo(&movementAck.Ack.movementInfo);
 
     if (_player->m_mover->GetGUID() != movementAck.Ack.movementInfo.guid)
         return;
 
     _player->m_movementInfo = movementAck.Ack.movementInfo;
 
     WorldPackets::Movement::MoveUpdateKnockBack updateKnockBack;
     updateKnockBack.movementInfo = &_player->m_movementInfo;
     _player->SendMessageToSet(updateKnockBack.Write(), false);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     GetPlayer()->ValidateMovementInfo(&movementAck.Ack.movementInfo);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Todo:: discard movement packets after the player is rooted

 {
     OpcodeClient opcode = packet.GetOpcode();
 
     Unit* mover = _player->m_mover;
 
     ASSERT(mover != nullptr);                      // there must always be a mover
 
     Player* plrMover = mover->ToPlayer();
 
     // ignore, waiting processing in WorldSession::HandleMoveWorldportAckOpcode and WorldSession::HandleMoveTeleportAck
     if (plrMover && plrMover->IsBeingTeleported())
         return;
 
     GetPlayer()->ValidateMovementInfo(&packet.movementInfo);
 
     MovementInfo& movementInfo = packet.movementInfo;
 
     // prevent tampered movement data
     if (movementInfo.guid != mover->GetGUID())
     {
         TC_LOG_ERROR("network", "HandleMovementOpcodes: guid error");
         return;
     }
 
     if (!movementInfo.pos.IsPositionValid())
     {
         TC_LOG_ERROR("network", "HandleMovementOpcodes: Invalid Position");
         return;
     }
 
     // stop some emotes at player move
     if (plrMover && (plrMover->GetUInt32Value(UNIT_NPC_EMOTESTATE) != 0))
         plrMover->SetUInt32Value(UNIT_NPC_EMOTESTATE, EMOTE_ONESHOT_NONE);
 
     /* handle special cases */
     if (!movementInfo.transport.guid.IsEmpty())
     {
         // transports size limited
         // (also received at zeppelin leave by some reason with t_* as absolute in continent coordinates, can be safely skipped)
         if (movementInfo.transport.pos.GetPositionX() > 50 || movementInfo.transport.pos.GetPositionY() > 50 || movementInfo.transport.pos.GetPositionZ() > 50)
         {
             return;
         }
 
         if (!Trinity::IsValidMapCoord(movementInfo.pos.GetPositionX() + movementInfo.transport.pos.GetPositionX(), movementInfo.pos.GetPositionY() + movementInfo.transport.pos.GetPositionY(),
             movementInfo.pos.GetPositionZ() + movementInfo.transport.pos.GetPositionZ(), movementInfo.pos.GetOrientation() + movementInfo.transport.pos.GetOrientation()))
         {
             return;
         }
 
         // if we boarded a transport, add us to it
         if (plrMover)
         {
             if (!plrMover->GetTransport())
             {
                 if (Transport* transport = plrMover->GetMap()->GetTransport(movementInfo.transport.guid))
                     transport->AddPassenger(plrMover);
             }
             else if (plrMover->GetTransport()->GetGUID() != movementInfo.transport.guid)
             {
                 plrMover->GetTransport()->RemovePassenger(plrMover);
                 if (Transport* transport = plrMover->GetMap()->GetTransport(movementInfo.transport.guid))
                     transport->AddPassenger(plrMover);
                 else
                     movementInfo.ResetTransport();
             }
         }
 
         if (!mover->GetTransport() && !mover->GetVehicle())
         {
             GameObject* go = mover->GetMap()->GetGameObject(movementInfo.transport.guid);
             if (!go || go->GetGoType() != GAMEOBJECT_TYPE_TRANSPORT)
                 movementInfo.transport.guid.Clear();
         }
     }
     else if (plrMover && plrMover->GetTransport())                // if we were on a transport, leave
         plrMover->m_transport->RemovePassenger(plrMover);
 
     // fall damage generation (ignore in flight case that can be triggered also at lags in moment teleportation to another map).
     if (opcode == CMSG_MOVE_FALL_LAND && plrMover && !plrMover->IsInFlight())
         plrMover->HandleFall(movementInfo);
 
     if (plrMover && ((movementInfo.flags & MOVEMENTFLAG_SWIMMING) != 0) != plrMover->IsInWater())
     {
         // now client not include swimming flag in case jumping under water
         plrMover->SetInWater(!plrMover->IsInWater() || plrMover->GetBaseMap()->IsUnderWater(movementInfo.pos.GetPositionX(), movementInfo.pos.GetPositionY(), movementInfo.pos.GetPositionZ()));
     }
 
     uint32 mstime = getMSTime();
     /*----------------------*/
     if (m_clientTimeDelay == 0)
         m_clientTimeDelay = mstime - movementInfo.time;
 
     /* process position-change */
     movementInfo.time = movementInfo.time + m_clientTimeDelay + MOVEMENT_PACKET_TIME_DELAY;
 
     movementInfo.guid = mover->GetGUID();
     mover->m_movementInfo = movementInfo;
 
     // Some vehicles allow the passenger to turn by himself
     if (Vehicle* vehicle = mover->GetVehicle())
     {
         if (VehicleSeatEntry const* seat = vehicle->GetSeatForPassenger(mover))
         {
             if (seat->Flags & VEHICLE_SEAT_FLAG_ALLOW_TURNING)
             {
                 if (movementInfo.pos.GetOrientation() != mover->GetOrientation())
                 {
                     mover->SetOrientation(movementInfo.pos.GetOrientation());
                     mover->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_TURNING);
                 }
             }
         }
         return;
     }
 
     mover->UpdatePosition(movementInfo.pos);
 
     WorldPackets::Movement::MoveUpdate moveUpdate;
     moveUpdate.movementInfo = &mover->m_movementInfo;
     mover->SendMessageToSet(moveUpdate.Write(), _player);
 
     if (plrMover)                                            // nothing is charmed, or player charmed
     {
         if (plrMover->IsSitState() && (movementInfo.flags & (MOVEMENTFLAG_MASK_MOVING | MOVEMENTFLAG_MASK_TURNING)))
             plrMover->SetStandState(UNIT_STAND_STATE_STAND);
 
         plrMover->UpdateFallInformationIfNeed(movementInfo, opcode);
 
         if (movementInfo.pos.GetPositionZ() < plrMover->GetMap()->GetMinHeight(movementInfo.pos.GetPositionX(), movementInfo.pos.GetPositionY()))
         {
             if (!(plrMover->GetBattleground() && plrMover->GetBattleground()->HandlePlayerUnderMap(_player)))
             {
                 // NOTE: this is actually called many times while falling
                 // even after the player has been teleported away
                 if (plrMover->IsAlive())
                 {
                     plrMover->SetFlag(PLAYER_FLAGS, PLAYER_FLAGS_IS_OUT_OF_BOUNDS);
                     plrMover->EnvironmentalDamage(DAMAGE_FALL_TO_VOID, GetPlayer()->GetMaxHealth());
                     // player can be alive if GM/etc
                     // change the death state to CORPSE to prevent the death timer from
                     // starting in the next player update
                     if (!plrMover->IsAlive())
                         plrMover->KillPlayer();
                 }
             }
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     GetPlayer()->ValidateMovementInfo(&setVehicleRecIdAck.Data.movementInfo);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     MovementInfo movementInfo = moveSplineDone.movementInfo;
     _player->ValidateMovementInfo(&movementInfo);
 
     // in taxi flight packet received in 2 case:
     // 1) end taxi path in far (multi-node) flight
     // 2) switch from one map to other in case multim-map taxi path
     // we need process only (1)
 
     uint32 curDest = GetPlayer()->m_taxi.GetTaxiDestination();
     if (curDest)
     {
         TaxiNodesEntry const* curDestNode = sTaxiNodesStore.LookupEntry(curDest);
 
         // far teleport case
         if (curDestNode && curDestNode->MapID != GetPlayer()->GetMapId())
         {
             if (GetPlayer()->GetMotionMaster()->GetCurrentMovementGeneratorType() == FLIGHT_MOTION_TYPE)
             {
                 // short preparations to continue flight
                 FlightPathMovementGenerator* flight = (FlightPathMovementGenerator*)(GetPlayer()->GetMotionMaster()->top());
 
                 flight->SetCurrentNodeAfterTeleport();
                 TaxiPathNodeEntry const* node = flight->GetPath()[flight->GetCurrentNode()];
                 flight->SkipCurrentNode();
 
                 GetPlayer()->TeleportTo(curDestNode->MapID, node->Loc.X, node->Loc.Y, node->Loc.Z, GetPlayer()->GetOrientation());
             }
         }
 
         return;
     }
 
     // at this point only 1 node is expected (final destination)
     if (GetPlayer()->m_taxi.GetPath().size() != 1)
         return;
 
     GetPlayer()->CleanupAfterTaxiFlight();
     GetPlayer()->SetFallInformation(0, GetPlayer()->GetPositionZ());
     if (GetPlayer()->pvpInfo.IsHostile)
         GetPlayer()->CastSpell(GetPlayer(), 2479, true);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     TC_LOG_DEBUG("network", "CMSG_MOVE_TELEPORT_ACK: Guid: %s, Sequence: %u, Time: %u", packet.MoverGUID.ToString().c_str(), packet.AckIndex, packet.MoveTime);
 
     Player* plMover = _player->m_mover->ToPlayer();
 
     if (!plMover || !plMover->IsBeingTeleportedNear())
         return;
 
     if (packet.MoverGUID != plMover->GetGUID())
         return;
 
     plMover->SetSemaphoreTeleportNear(false);
 
     uint32 old_zone = plMover->GetZoneId();
 
     WorldLocation const& dest = plMover->GetTeleportDest();
 
     plMover->UpdatePosition(dest, true);
 
     uint32 newzone, newarea;
     plMover->GetZoneAndAreaId(newzone, newarea);
     plMover->UpdateZone(newzone, newarea);
 
     // new zone
     if (old_zone != newzone)
     {
         // honorless target
         if (plMover->pvpInfo.IsHostile)
             plMover->CastSpell(plMover, 2479, true);
 
         // in friendly area
         else if (plMover->IsPvP() && !plMover->HasFlag(PLAYER_FLAGS, PLAYER_FLAGS_IN_PVP))
             plMover->UpdatePvP(false, false);
     }
 
     // resummon pet
     GetPlayer()->ResummonPetTemporaryUnSummonedIfAny();
 
     //lets process all delayed operations on successful teleport
     GetPlayer()->ProcessDelayedOperations();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

525 {

526 }

Here is the caller graph for this function:

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

 {
     HandleMoveWorldportAckOpcode();
 }

Here is the call graph for this function:

void WorldSession::HandleMoveWorldportAckOpcode ( )

 {
     // ignore unexpected far teleports
     if (!GetPlayer()->IsBeingTeleportedFar())
         return;
 
     bool seamlessTeleport = GetPlayer()->IsBeingTeleportedSeamlessly();
     GetPlayer()->SetSemaphoreTeleportFar(false);
 
     // get the teleport destination
     WorldLocation const& loc = GetPlayer()->GetTeleportDest();
 
     // possible errors in the coordinate validity check
     if (!MapManager::IsValidMapCoord(loc))
     {
         LogoutPlayer(false);
         return;
     }
 
     // get the destination map entry, not the current one, this will fix homebind and reset greeting
     MapEntry const* mEntry = sMapStore.LookupEntry(loc.GetMapId());
     InstanceTemplate const* mInstance = sObjectMgr->GetInstanceTemplate(loc.GetMapId());
 
     // reset instance validity, except if going to an instance inside an instance
     if (GetPlayer()->m_InstanceValid == false && !mInstance)
         GetPlayer()->m_InstanceValid = true;
 
     Map* oldMap = GetPlayer()->GetMap();
     Map* newMap = sMapMgr->CreateMap(loc.GetMapId(), GetPlayer());
 
     if (GetPlayer()->IsInWorld())
     {
         TC_LOG_ERROR("network", "%s %s is still in world when teleported from map %s (%u) to new map %s (%u)", GetPlayer()->GetGUID().ToString().c_str(), GetPlayer()->GetName().c_str(), oldMap->GetMapName(), oldMap->GetId(), newMap ? newMap->GetMapName() : "Unknown", loc.GetMapId());
         oldMap->RemovePlayerFromMap(GetPlayer(), false);
     }
 
     // relocate the player to the teleport destination
     // the CannotEnter checks are done in TeleporTo but conditions may change
     // while the player is in transit, for example the map may get full
     if (!newMap || newMap->CannotEnter(GetPlayer()))
     {
         TC_LOG_ERROR("network", "Map %d (%s) could not be created for %s (%s), porting player to homebind", loc.GetMapId(), newMap ? newMap->GetMapName() : "Unknown", GetPlayer()->GetGUID().ToString().c_str(), GetPlayer()->GetName().c_str());
         GetPlayer()->TeleportTo(GetPlayer()->m_homebindMapId, GetPlayer()->m_homebindX, GetPlayer()->m_homebindY, GetPlayer()->m_homebindZ, GetPlayer()->GetOrientation());
         return;
     }
 
     float z = loc.GetPositionZ();
     if (GetPlayer()->HasUnitMovementFlag(MOVEMENTFLAG_HOVER))
         z += GetPlayer()->GetFloatValue(UNIT_FIELD_HOVERHEIGHT);
 
     GetPlayer()->Relocate(loc.GetPositionX(), loc.GetPositionY(), z, loc.GetOrientation());
 
     GetPlayer()->ResetMap();
     GetPlayer()->SetMap(newMap);
 
     if (!seamlessTeleport)
         GetPlayer()->SendInitialPacketsBeforeAddToMap();
 
     if (!GetPlayer()->GetMap()->AddPlayerToMap(GetPlayer(), !seamlessTeleport))
     {
         TC_LOG_ERROR("network", "WORLD: failed to teleport player %s (%s) to map %d (%s) because of unknown reason!",
             GetPlayer()->GetName().c_str(), GetPlayer()->GetGUID().ToString().c_str(), loc.GetMapId(), newMap ? newMap->GetMapName() : "Unknown");
         GetPlayer()->ResetMap();
         GetPlayer()->SetMap(oldMap);
         GetPlayer()->TeleportTo(GetPlayer()->m_homebindMapId, GetPlayer()->m_homebindX, GetPlayer()->m_homebindY, GetPlayer()->m_homebindZ, GetPlayer()->GetOrientation());
         return;
     }
 
     // battleground state prepare (in case join to BG), at relogin/tele player not invited
     // only add to bg group and object, if the player was invited (else he entered through command)
     if (_player->InBattleground())
     {
         // cleanup setting if outdated
         if (!mEntry->IsBattlegroundOrArena())
         {
             // We're not in BG
             _player->SetBattlegroundId(0, BATTLEGROUND_TYPE_NONE);
             // reset destination bg team
             _player->SetBGTeam(0);
         }
         // join to bg case
         else if (Battleground* bg = _player->GetBattleground())
         {
             if (_player->IsInvitedForBattlegroundInstance(_player->GetBattlegroundId()))
                 bg->AddPlayer(_player);
         }
     }
 
     if (!seamlessTeleport)
         GetPlayer()->SendInitialPacketsAfterAddToMap();
     else
     {
         GetPlayer()->UpdateVisibilityForPlayer();
         if (Garrison* garrison = GetPlayer()->GetGarrison())
             garrison->SendRemoteInfo();
     }
 
     // flight fast teleport case
     if (GetPlayer()->GetMotionMaster()->GetCurrentMovementGeneratorType() == FLIGHT_MOTION_TYPE)
     {
         if (!_player->InBattleground())
         {
             if (!seamlessTeleport)
             {
                 // short preparations to continue flight
                 FlightPathMovementGenerator* flight = (FlightPathMovementGenerator*)(GetPlayer()->GetMotionMaster()->top());
                 flight->Initialize(GetPlayer());
             }
             return;
         }
 
         // battleground state prepare, stop flight
         GetPlayer()->GetMotionMaster()->MovementExpired();
         GetPlayer()->CleanupAfterTaxiFlight();
     }
 
     // resurrect character at enter into instance where his corpse exist after add to map
 
     if (mEntry->IsDungeon() && !GetPlayer()->IsAlive())
         if (GetPlayer()->GetCorpseLocation().GetMapId() == mEntry->ID)
         {
             GetPlayer()->ResurrectPlayer(0.5f, false);
             GetPlayer()->SpawnCorpseBones();
         }
 
     bool allowMount = !mEntry->IsDungeon() || mEntry->IsBattlegroundOrArena();
     if (mInstance)
     {
         // check if this instance has a reset time and send it to player if so
         Difficulty diff = GetPlayer()->GetDifficultyID(mEntry);
         if (MapDifficultyEntry const* mapDiff = GetMapDifficultyData(mEntry->ID, diff))
         {
             if (mapDiff->RaidDuration)
             {
                 if (time_t timeReset = sInstanceSaveMgr->GetResetTimeFor(mEntry->ID, diff))
                 {
                     uint32 timeleft = uint32(timeReset - time(NULL));
                     GetPlayer()->SendInstanceResetWarning(mEntry->ID, diff, timeleft, true);
                 }
             }
         }
 
         // check if instance is valid
         if (!GetPlayer()->CheckInstanceValidity(false))
             GetPlayer()->m_InstanceValid = false;
 
         // instance mounting is handled in InstanceTemplate
         allowMount = mInstance->AllowMount;
     }
 
     // mount allow check
     if (!allowMount)
         _player->RemoveAurasByType(SPELL_AURA_MOUNTED);
 
     // update zone immediately, otherwise leave channel will cause crash in mtmap
     uint32 newzone, newarea;
     GetPlayer()->GetZoneAndAreaId(newzone, newarea);
     GetPlayer()->UpdateZone(newzone, newarea);
 
     // honorless target
     if (GetPlayer()->pvpInfo.IsHostile)
         GetPlayer()->CastSpell(GetPlayer(), 2479, true);
 
     // in friendly area
     else if (GetPlayer()->IsPvP() && !GetPlayer()->HasFlag(PLAYER_FLAGS, PLAYER_FLAGS_IN_PVP))
         GetPlayer()->UpdatePvP(false, false);
 
     // resummon pet
     GetPlayer()->ResummonPetTemporaryUnSummonedIfAny();
 
     //lets process all delayed operations on successful teleport
     GetPlayer()->ProcessDelayedOperations();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleNameQueryOpcode ( WorldPackets::Query::QueryPlayerName & packet )

 {
     SendNameQueryOpcode(packet.Player);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

694 {

695 }

Here is the caller graph for this function:

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

 {
     TC_LOG_DEBUG("network", "WORLD: CMSG_NPC_TEXT_QUERY TextId: %u", packet.TextID);
 
     NpcText const* npcText = sObjectMgr->GetNpcText(packet.TextID);
 
     WorldPackets::Query::QueryNPCTextResponse response;
     response.TextID = packet.TextID;
 
     if (npcText)
     {
         for (uint8 i = 0; i < MAX_NPC_TEXT_OPTIONS; ++i)
         {
             response.Probabilities[i] = npcText->Data[i].Probability;
             response.BroadcastTextID[i] = npcText->Data[i].BroadcastTextID;
             if (!response.Allow && npcText->Data[i].BroadcastTextID)
                 response.Allow = true;
         }
     }
 
     if (!response.Allow)
         TC_LOG_ERROR("sql.sql", "HandleNpcTextQueryOpcode: no BroadcastTextID found for text %u in `npc_text table`", packet.TextID);
 
     TC_LOG_DEBUG("network", "WORLD: Sent SMSG_NPC_TEXT_UPDATE");
 
     SendPacket(response.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     TC_LOG_ERROR("network", "Object update failed for %s for player %s (%s)", objectUpdateFailed.ObjectGUID.ToString().c_str(), GetPlayerName().c_str(), _player->GetGUID().ToString().c_str());
 
     // If create object failed for current player then client will be stuck on loading screen
     if (_player->GetGUID() == objectUpdateFailed.ObjectGUID)
     {
         LogoutPlayer(true);
         return;
     }
 
     // Pretend we've never seen this object
     _player->m_clientGUIDs.erase(objectUpdateFailed.ObjectGUID);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     TC_LOG_ERROR("network", "Object update rescued for %s for player %s (%s)", objectUpdateRescued.ObjectGUID.ToString().c_str(), GetPlayerName().c_str(), _player->GetGUID().ToString().c_str());
 
     // Client received values update after destroying object
     // re-register object in m_clientGUIDs to send DestroyObject on next visibility update
     _player->m_clientGUIDs.insert(objectUpdateRescued.ObjectGUID);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     Player* player = ObjectAccessor::FindConnectedPlayer(packet.TargetPlayer);
     if (!player)
         return;
 
     TC_LOG_DEBUG("network", "OFFER PETITION: %s, to %s", packet.ItemGUID.ToString().c_str(), packet.TargetPlayer.ToString().c_str());
 
     if (!sWorld->getBoolConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_GUILD) && GetPlayer()->GetTeam() != player->GetTeam())
     {
         Guild::SendCommandResult(this, GUILD_COMMAND_CREATE_GUILD, ERR_GUILD_NOT_ALLIED);
         return;
     }
 
     if (player->GetGuildId())
     {
         Guild::SendCommandResult(this, GUILD_COMMAND_INVITE_PLAYER, ERR_ALREADY_IN_GUILD_S, _player->GetName());
         return;
     }
 
     if (player->GetGuildIdInvited())
     {
         Guild::SendCommandResult(this, GUILD_COMMAND_INVITE_PLAYER, ERR_ALREADY_INVITED_TO_GUILD_S, _player->GetName());
         return;
     }
 
     PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_PETITION_SIGNATURE);
     stmt->setUInt64(0, packet.ItemGUID.GetCounter());
     PreparedQueryResult result = CharacterDatabase.Query(stmt);
 
     uint8 signs = 0;
     // result == NULL also correct charter without signs
     if (result)
         signs = uint8(result->GetRowCount());
 
     WorldPackets::Petition::ServerPetitionShowSignatures signaturesPacket;
     signaturesPacket.Item = packet.ItemGUID;
     signaturesPacket.Owner = _player->GetGUID();
     signaturesPacket.OwnerAccountID = ObjectGuid::Create<HighGuid::WowAccount>(player->GetSession()->GetAccountId());
     signaturesPacket.PetitionID = int32(packet.ItemGUID.GetCounter());  // @todo verify that...
 
     signaturesPacket.Signatures.reserve(signs);
     for (uint8 i = 0; i < signs; ++i)
     {
         Field* fields2 = result->Fetch();
         ObjectGuid signerGUID = ObjectGuid::Create<HighGuid::Player>(fields2[0].GetUInt64());
 
         WorldPackets::Petition::ServerPetitionShowSignatures::PetitionSignature signature;
         signature.Signer = signerGUID;
         signature.Choice = 0;
         signaturesPacket.Signatures.push_back(signature);
 
         // Checking the return value just to be double safe
         if (!result->NextRow())
             break;
     }
 
     player->GetSession()->SendPacket(signaturesPacket.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     // Only players that has not yet gained any experience can use this
     if (_player->GetUInt32Value(PLAYER_XP))
         return;
 
     if (ChrClassesEntry const* classEntry = sChrClassesStore.LookupEntry(_player->getClass()))
     {
         if (classEntry->CinematicSequenceID)
             _player->SendCinematicStart(classEntry->CinematicSequenceID);
         else if (ChrRacesEntry const* raceEntry = sChrRacesStore.LookupEntry(_player->getRace()))
             _player->SendCinematicStart(raceEntry->CinematicSequenceID);
     }
 }

Here is the caller graph for this function:

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

 {
     Player* player = _player;
 
     // ignore for remote control state
     if (player->m_mover != player)
         return;
     TC_LOG_INFO("network", "bagIndex: %u, slot: %u", packet.Slot, packet.PackSlot);
 
     Item* item = player->GetItemByPos(packet.Slot, packet.PackSlot);
     if (!item)
     {
         player->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, NULL, NULL);
         return;
     }
 
     ItemTemplate const* proto = item->GetTemplate();
     if (!proto)
     {
         player->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, item, NULL);
         return;
     }
 
     // Verify that the bag is an actual bag or wrapped item that can be used "normally"
     if (!(proto->GetFlags() & ITEM_FLAG_OPENABLE) && !item->HasFlag(ITEM_FIELD_FLAGS, ITEM_FIELD_FLAG_WRAPPED))
     {
         player->SendEquipError(EQUIP_ERR_CLIENT_LOCKED_OUT, item, NULL);
         TC_LOG_ERROR("network", "Possible hacking attempt: Player %s [%s] tried to open item [%s, entry: %u] which is not openable!",
             player->GetName().c_str(), player->GetGUID().ToString().c_str(), item->GetGUID().ToString().c_str(), proto->GetId());
         return;
     }
 
     // locked item
     uint32 lockId = proto->GetLockID();
     if (lockId)
     {
         LockEntry const* lockInfo = sLockStore.LookupEntry(lockId);
 
         if (!lockInfo)
         {
             player->SendEquipError(EQUIP_ERR_ITEM_LOCKED, item, NULL);
             TC_LOG_ERROR("network", "WORLD::OpenItem: item [%s] has an unknown lockId: %u!", item->GetGUID().ToString().c_str(), lockId);
             return;
         }
 
         // was not unlocked yet
         if (item->IsLocked())
         {
             player->SendEquipError(EQUIP_ERR_ITEM_LOCKED, item, NULL);
             return;
         }
     }
 
     if (item->HasFlag(ITEM_FIELD_FLAGS, ITEM_FIELD_FLAG_WRAPPED))// wrapped?
     {
         PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHARACTER_GIFT_BY_ITEM);
 
         stmt->setUInt64(0, item->GetGUID().GetCounter());
 
         PreparedQueryResult result = CharacterDatabase.Query(stmt);
 
         if (result)
         {
             Field* fields = result->Fetch();
             uint32 entry = fields[0].GetUInt32();
             uint32 flags = fields[1].GetUInt32();
 
             item->SetGuidValue(ITEM_FIELD_GIFTCREATOR, ObjectGuid::Empty);
             item->SetEntry(entry);
             item->SetUInt32Value(ITEM_FIELD_FLAGS, flags);
             item->SetState(ITEM_CHANGED, player);
         }
         else
         {
             TC_LOG_ERROR("network", "Wrapped item %s don't have record in character_gifts table and will deleted", item->GetGUID().ToString().c_str());
             player->DestroyItem(item->GetBagSlot(), item->GetSlot(), true);
             return;
         }
 
         stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GIFT);
 
         stmt->setUInt64(0, item->GetGUID().GetCounter());
 
         CharacterDatabase.Execute(stmt);
     }
     else
         player->SendLoot(item->GetGUID(), LOOT_CORPSE);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     // ignore if player not loaded
     if (!GetPlayer())                                        // needed because STATUS_AUTHED
     {
         if (packet.PassOnLoot)
             TC_LOG_ERROR("network", "CMSG_OPT_OUT_OF_LOOT value<>0 for not-loaded character!");
         return;
     }
 
     GetPlayer()->SetPassOnGroupLoot(packet.PassOnLoot);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     Player* player = ObjectAccessor::FindPlayerByName(packet.TargetName);
 
     // no player
     if (!player)
     {
         SendPartyResult(PARTY_OP_INVITE, packet.TargetName, ERR_BAD_PLAYER_NAME_S);
         return;
     }
 
     // restrict invite to GMs
     if (!sWorld->getBoolConfig(CONFIG_ALLOW_GM_GROUP) && !GetPlayer()->IsGameMaster() && player->IsGameMaster())
     {
         SendPartyResult(PARTY_OP_INVITE, player->GetName(), ERR_BAD_PLAYER_NAME_S);
         return;
     }
 
     // can't group with
     if (!GetPlayer()->IsGameMaster() && !sWorld->getBoolConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_GROUP) && GetPlayer()->GetTeam() != player->GetTeam())
     {
         SendPartyResult(PARTY_OP_INVITE, player->GetName(), ERR_PLAYER_WRONG_FACTION);
         return;
     }
     if (GetPlayer()->GetInstanceId() != 0 && player->GetInstanceId() != 0 && GetPlayer()->GetInstanceId() != player->GetInstanceId() && GetPlayer()->GetMapId() == player->GetMapId())
     {
         SendPartyResult(PARTY_OP_INVITE, player->GetName(), ERR_TARGET_NOT_IN_INSTANCE_S);
         return;
     }
     // just ignore us
     if (player->GetInstanceId() != 0 && player->GetDungeonDifficultyID() != GetPlayer()->GetDungeonDifficultyID())
     {
         SendPartyResult(PARTY_OP_INVITE, player->GetName(), ERR_IGNORING_YOU_S);
         return;
     }
 
     if (player->GetSocial()->HasIgnore(GetPlayer()->GetGUID()))
     {
         SendPartyResult(PARTY_OP_INVITE, player->GetName(), ERR_IGNORING_YOU_S);
         return;
     }
 
     Group* group = GetPlayer()->GetGroup();
     if (group && group->isBGGroup())
         group = GetPlayer()->GetOriginalGroup();
 
     Group* group2 = player->GetGroup();
     if (group2 && group2->isBGGroup())
         group2 = player->GetOriginalGroup();
 
     // player already in another group or invited
     if (group2 || player->GetGroupInvite())
     {
         SendPartyResult(PARTY_OP_INVITE, player->GetName(), ERR_ALREADY_IN_GROUP_S);
 
         if (group2)
         {
             // tell the player that they were invited but it failed as they were already in a group
             WorldPackets::Party::PartyInvite partyInvite;
             partyInvite.Initialize(GetPlayer(), packet.ProposedRoles, false);
             player->GetSession()->SendPacket(partyInvite.Write());
         }
 
         return;
     }
 
     if (group)
     {
         // not have permissions for invite
         if (!group->IsLeader(GetPlayer()->GetGUID()) && !group->IsAssistant(GetPlayer()->GetGUID()))
         {
             SendPartyResult(PARTY_OP_INVITE, "", ERR_NOT_LEADER);
             return;
         }
         // not have place
         if (group->IsFull())
         {
             SendPartyResult(PARTY_OP_INVITE, "", ERR_GROUP_FULL);
             return;
         }
     }
 
     // ok, but group not exist, start a new group
     // but don't create and save the group to the DB until
     // at least one person joins
     if (!group)
     {
         group = new Group;
         // new group: if can't add then delete
         if (!group->AddLeaderInvite(GetPlayer()))
         {
             delete group;
             return;
         }
         if (!group->AddInvite(player))
         {
             delete group;
             return;
         }
     }
     else
     {
         // already existed group: if can't add then just leave
         if (!group->AddInvite(player))
         {
             return;
         }
     }
 
     WorldPackets::Party::PartyInvite partyInvite;
     partyInvite.Initialize(GetPlayer(), packet.ProposedRoles, true);
     player->GetSession()->SendPacket(partyInvite.Write());
 
     SendPartyResult(PARTY_OP_INVITE, player->GetName(), ERR_PARTY_RESULT_OK);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     Group* group = GetPlayer()->GetGroupInvite();
 
     if (!group)
         return;
 
     if (packet.Accept)
     {
         // Remove player from invitees in any case
         group->RemoveInvite(GetPlayer());
 
         if (group->GetLeaderGUID() == GetPlayer()->GetGUID())
         {
             TC_LOG_ERROR("network", "HandleGroupAcceptOpcode: player %s (%s) tried to accept an invite to his own group", GetPlayer()->GetName().c_str(), GetPlayer()->GetGUID().ToString().c_str());
             return;
         }
 
         // Group is full
         if (group->IsFull())
         {
             SendPartyResult(PARTY_OP_INVITE, "", ERR_GROUP_FULL);
             return;
         }
 
         Player* leader = ObjectAccessor::FindPlayer(group->GetLeaderGUID());
 
         // Forming a new group, create it
         if (!group->IsCreated())
         {
             // This can happen if the leader is zoning. To be removed once delayed actions for zoning are implemented
             if (!leader)
             {
                 group->RemoveAllInvites();
                 return;
             }
 
             // If we're about to create a group there really should be a leader present
             ASSERT(leader);
             group->RemoveInvite(leader);
             group->Create(leader);
             sGroupMgr->AddGroup(group);
         }
 
         // Everything is fine, do it, PLAYER'S GROUP IS SET IN ADDMEMBER!!!
         if (!group->AddMember(GetPlayer()))
             return;
 
         group->BroadcastGroupUpdate();
     }
     else
     {
         // Remember leader if online (group pointer will be invalid if group gets disbanded)
         Player* leader = ObjectAccessor::FindConnectedPlayer(group->GetLeaderGUID());
 
         // uninvite, group can be deleted
         GetPlayer()->UninviteFromGroup();
 
         if (!leader || !leader->GetSession())
             return;
 
         // report
         WorldPackets::Party::GroupDecline decline(GetPlayer()->GetName());
         leader->GetSession()->SendPacket(decline.Write());
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     // can't uninvite yourself
     if (packet.TargetGUID == GetPlayer()->GetGUID())
     {
         TC_LOG_ERROR("network", "WorldSession::HandleGroupUninviteGuidOpcode: leader %s (%s) tried to uninvite himself from the group.",
             GetPlayer()->GetName().c_str(), GetPlayer()->GetGUID().ToString().c_str());
         return;
     }
 
     PartyResult res = GetPlayer()->CanUninviteFromGroup(packet.TargetGUID);
     if (res != ERR_PARTY_RESULT_OK)
     {
         SendPartyResult(PARTY_OP_UNINVITE, "", res);
         return;
     }
 
     Group* grp = GetPlayer()->GetGroup();
     // grp is checked already above in CanUninviteFromGroup()
     ASSERT(grp);
 
     if (grp->IsMember(packet.TargetGUID))
     {
         Player::RemoveFromGroup(grp, packet.TargetGUID, GROUP_REMOVEMETHOD_KICK, GetPlayer()->GetGUID(), packet.Reason.c_str());
         return;
     }
 
     if (Player* player = grp->GetInvited(packet.TargetGUID))
     {
         player->UninviteFromGroup();
         return;
     }
 
     SendPartyResult(PARTY_OP_UNINVITE, "", ERR_TARGET_NOT_IN_GROUP_S);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (!_player->IsInWorld())
         return;
 
     Creature* pet = ObjectAccessor::GetCreatureOrPetOrVehicle(*_player, packet.Pet);
     if (pet)
     {
         if (pet->IsPet())
             _player->RemovePet(pet->ToPet(), PET_SAVE_AS_DELETED);
         else if (pet->GetGUID() == _player->GetCharmGUID())
             _player->StopCastingCharm();
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Todo:: allow control charmed player?

 {
     ObjectGuid guid1 = packet.PetGUID;         //pet guid
     ObjectGuid guid2 = packet.TargetGUID;      //tag guid
 
     uint32 spellid = UNIT_ACTION_BUTTON_ACTION(packet.Action);
     uint8 flag = UNIT_ACTION_BUTTON_TYPE(packet.Action);             //delete = 0x07 CastSpell = C1
 
     // used also for charmed creature
     Unit* pet = ObjectAccessor::GetUnit(*_player, guid1);
     TC_LOG_DEBUG("network", "HandlePetAction: %s - flag: %u, spellid: %u, target: %s.", guid1.ToString().c_str(), uint32(flag), spellid, guid2.ToString().c_str());
 
     if (!pet)
     {
         TC_LOG_DEBUG("network", "HandlePetAction: %s doesn't exist for %s %s", guid1.ToString().c_str(), GetPlayer()->GetGUID().ToString().c_str(), GetPlayer()->GetName().c_str());
         return;
     }
 
     if (pet != GetPlayer()->GetFirstControlled())
     {
         TC_LOG_DEBUG("network", "HandlePetAction: %s does not belong to %s %s", guid1.ToString().c_str(), GetPlayer()->GetGUID().ToString().c_str(), GetPlayer()->GetName().c_str());
         return;
     }
 
     if (!pet->IsAlive())
     {
         SpellInfo const* spell = (flag == ACT_ENABLED || flag == ACT_PASSIVE) ? sSpellMgr->GetSpellInfo(spellid) : NULL;
         if (!spell)
             return;
         if (!spell->HasAttribute(SPELL_ATTR0_CASTABLE_WHILE_DEAD))
             return;
     }
 
     if (pet->GetTypeId() == TYPEID_PLAYER && !(flag == ACT_COMMAND && spellid == COMMAND_ATTACK))
         return;
 
     if (GetPlayer()->m_Controlled.size() == 1)
         HandlePetActionHelper(pet, guid1, spellid, flag, guid2, packet.ActionPosition.x, packet.ActionPosition.y, packet.ActionPosition.z);
     else
     {
         //If a pet is dismissed, m_Controlled will change
         std::vector<Unit*> controlled;
         for (Unit::ControlList::iterator itr = GetPlayer()->m_Controlled.begin(); itr != GetPlayer()->m_Controlled.end(); ++itr)
             if ((*itr)->GetEntry() == pet->GetEntry() && (*itr)->IsAlive())
                 controlled.push_back(*itr);
         for (std::vector<Unit*>::iterator itr = controlled.begin(); itr != controlled.end(); ++itr)
             HandlePetActionHelper(*itr, guid1, spellid, flag, guid2, packet.ActionPosition.x, packet.ActionPosition.y, packet.ActionPosition.z);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandlePetActionHelper	(	Unit *	pet,
		ObjectGuid	guid1,
		uint32	spellid,
		uint16	flag,
		ObjectGuid	guid2,
		float	x,
		float	y,
		float	z
	)

Todo:: Send proper error message to client

Todo:: : confirm this check

 {
     CharmInfo* charmInfo = pet->GetCharmInfo();
     if (!charmInfo)
     {
         TC_LOG_DEBUG("network", "WorldSession::HandlePetAction(petGuid: %s, tagGuid: %s, spellId: %u, flag: %u): object (%s Entry: %u TypeId: %u) is considered pet-like but doesn't have a charminfo!",
             guid1.ToString().c_str(), guid2.ToString().c_str(), spellid, flag, pet->GetGUID().ToString().c_str(), pet->GetEntry(), pet->GetTypeId());
         return;
     }
 
     switch (flag)
     {
         case ACT_COMMAND:                                   //0x07
             switch (spellid)
             {
                 case COMMAND_STAY:                          //flat=1792  //STAY
                     pet->StopMoving();
                     pet->GetMotionMaster()->Clear(false);
                     pet->GetMotionMaster()->MoveIdle();
                     charmInfo->SetCommandState(COMMAND_STAY);
 
                     charmInfo->SetIsCommandAttack(false);
                     charmInfo->SetIsAtStay(true);
                     charmInfo->SetIsCommandFollow(false);
                     charmInfo->SetIsFollowing(false);
                     charmInfo->SetIsReturning(false);
                     charmInfo->SaveStayPosition();
                     break;
                 case COMMAND_FOLLOW:                        //spellid=1792  //FOLLOW
                     pet->AttackStop();
                     pet->InterruptNonMeleeSpells(false);
                     pet->GetMotionMaster()->MoveFollow(_player, PET_FOLLOW_DIST, pet->GetFollowAngle());
                     charmInfo->SetCommandState(COMMAND_FOLLOW);
 
                     charmInfo->SetIsCommandAttack(false);
                     charmInfo->SetIsAtStay(false);
                     charmInfo->SetIsReturning(true);
                     charmInfo->SetIsCommandFollow(true);
                     charmInfo->SetIsFollowing(false);
                     break;
                 case COMMAND_ATTACK:                        //spellid=1792  //ATTACK
                 {
                     // Can't attack if owner is pacified
                     if (_player->HasAuraType(SPELL_AURA_MOD_PACIFY))
                     {
                         //pet->SendPetCastFail(spellid, SPELL_FAILED_PACIFIED);
                         return;
                     }
 
                     // only place where pet can be player
                     Unit* TargetUnit = ObjectAccessor::GetUnit(*_player, guid2);
                     if (!TargetUnit)
                         return;
 
                     if (Unit* owner = pet->GetOwner())
                         if (!owner->IsValidAttackTarget(TargetUnit))
                             return;
 
                     pet->ClearUnitState(UNIT_STATE_FOLLOW);
                     // This is true if pet has no target or has target but targets differs.
                     if (pet->GetVictim() != TargetUnit || (pet->GetVictim() == TargetUnit && !pet->GetCharmInfo()->IsCommandAttack()))
                     {
                         if (pet->GetVictim())
                             pet->AttackStop();
 
                         if (pet->GetTypeId() != TYPEID_PLAYER && pet->ToCreature()->IsAIEnabled)
                         {
                             charmInfo->SetIsCommandAttack(true);
                             charmInfo->SetIsAtStay(false);
                             charmInfo->SetIsFollowing(false);
                             charmInfo->SetIsCommandFollow(false);
                             charmInfo->SetIsReturning(false);
 
                             pet->ToCreature()->AI()->AttackStart(TargetUnit);
 
                             //10% chance to play special pet attack talk, else growl
                             if (pet->IsPet() && ((Pet*)pet)->getPetType() == SUMMON_PET && pet != TargetUnit && urand(0, 100) < 10)
                                 pet->SendPetTalk((uint32)PET_TALK_ATTACK);
                             else
                             {
                                 // 90% chance for pet and 100% chance for charmed creature
                                 pet->SendPetAIReaction(guid1);
                             }
                         }
                         else                                // charmed player
                         {
                             if (pet->GetVictim() && pet->GetVictim() != TargetUnit)
                                 pet->AttackStop();
 
                             charmInfo->SetIsCommandAttack(true);
                             charmInfo->SetIsAtStay(false);
                             charmInfo->SetIsFollowing(false);
                             charmInfo->SetIsCommandFollow(false);
                             charmInfo->SetIsReturning(false);
 
                             pet->Attack(TargetUnit, true);
                             pet->SendPetAIReaction(guid1);
                         }
                     }
                     break;
                 }
                 case COMMAND_ABANDON:                       // abandon (hunter pet) or dismiss (summoned pet)
                     if (pet->GetCharmerGUID() == GetPlayer()->GetGUID())
                         _player->StopCastingCharm();
                     else if (pet->GetOwnerGUID() == GetPlayer()->GetGUID())
                     {
                         ASSERT(pet->GetTypeId() == TYPEID_UNIT);
                         if (pet->IsPet())
                         {
                             if (((Pet*)pet)->getPetType() == HUNTER_PET)
                                 GetPlayer()->RemovePet((Pet*)pet, PET_SAVE_AS_DELETED);
                             else
                                 //dismissing a summoned pet is like killing them (this prevents returning a soulshard...)
                                 pet->setDeathState(CORPSE);
                         }
                         else if (pet->HasUnitTypeMask(UNIT_MASK_MINION))
                         {
                             ((Minion*)pet)->UnSummon();
                         }
                     }
                     break;
                 case COMMAND_MOVE_TO:
                     pet->StopMoving();
                     pet->GetMotionMaster()->Clear(false);
                     pet->GetMotionMaster()->MovePoint(0, x, y, z);
                     charmInfo->SetCommandState(COMMAND_MOVE_TO);
 
                     charmInfo->SetIsCommandAttack(false);
                     charmInfo->SetIsAtStay(true);
                     charmInfo->SetIsFollowing(false);
                     charmInfo->SetIsReturning(false);
                     charmInfo->SaveStayPosition();
                     break;
                 default:
                     TC_LOG_ERROR("network", "WORLD: unknown PET flag Action %i and spellid %i.", uint32(flag), spellid);
             }
             break;
         case ACT_REACTION:                                  // 0x6
             switch (spellid)
             {
                 case REACT_PASSIVE:                         //passive
                     pet->AttackStop();
                     // no break;
                 case REACT_DEFENSIVE:                       //recovery
                 case REACT_AGGRESSIVE:                      //activete
                     if (pet->GetTypeId() == TYPEID_UNIT)
                         pet->ToCreature()->SetReactState(ReactStates(spellid));
                     break;
             }
             break;
         case ACT_DISABLED:                                  // 0x81    spell (disabled), ignore
         case ACT_PASSIVE:                                   // 0x01
         case ACT_ENABLED:                                   // 0xC1    spell
         {
             Unit* unit_target = NULL;
 
             if (!guid2.IsEmpty())
                 unit_target = ObjectAccessor::GetUnit(*_player, guid2);
 
             // do not cast unknown spells
             SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spellid);
             if (!spellInfo)
             {
                 TC_LOG_ERROR("network", "WORLD: unknown PET spell id %i", spellid);
                 return;
             }
 
             for (SpellEffectInfo const* effect: spellInfo->GetEffectsForDifficulty(DIFFICULTY_NONE))
             {
                 if (effect && (effect->TargetA.GetTarget() == TARGET_UNIT_SRC_AREA_ENEMY || effect->TargetA.GetTarget() == TARGET_UNIT_DEST_AREA_ENEMY || effect->TargetA.GetTarget() == TARGET_DEST_DYNOBJ_ENEMY))
                     return;
             }
 
             // do not cast not learned spells
             if (!pet->HasSpell(spellid) || spellInfo->IsPassive())
                 return;
 
             //  Clear the flags as if owner clicked 'attack'. AI will reset them
             //  after AttackStart, even if spell failed
             if (pet->GetCharmInfo())
             {
                 pet->GetCharmInfo()->SetIsAtStay(false);
                 pet->GetCharmInfo()->SetIsCommandAttack(true);
                 pet->GetCharmInfo()->SetIsReturning(false);
                 pet->GetCharmInfo()->SetIsFollowing(false);
             }
 
             Spell* spell = new Spell(pet, spellInfo, TRIGGERED_NONE);
 
             SpellCastResult result = spell->CheckPetCast(unit_target);
 
             //auto turn to target unless possessed
             if (result == SPELL_FAILED_UNIT_NOT_INFRONT && !pet->isPossessed() && !pet->IsVehicle())
             {
                 if (unit_target)
                 {
                     pet->SetInFront(unit_target);
                     if (Player* player = unit_target->ToPlayer())
                         pet->SendUpdateToPlayer(player);
                 }
                 else if (Unit* unit_target2 = spell->m_targets.GetUnitTarget())
                 {
                     pet->SetInFront(unit_target2);
                     if (Player* player = unit_target2->ToPlayer())
                         pet->SendUpdateToPlayer(player);
                 }
 
                 if (Unit* powner = pet->GetCharmerOrOwner())
                     if (Player* player = powner->ToPlayer())
                         pet->SendUpdateToPlayer(player);
 
                 result = SPELL_CAST_OK;
             }
 
             if (result == SPELL_CAST_OK)
             {
                 unit_target = spell->m_targets.GetUnitTarget();
 
                 //10% chance to play special pet attack talk, else growl
                 //actually this only seems to happen on special spells, fire shield for imp, torment for voidwalker, but it's stupid to check every spell
                 if (pet->IsPet() && (((Pet*)pet)->getPetType() == SUMMON_PET) && (pet != unit_target) && (urand(0, 100) < 10))
                     pet->SendPetTalk((uint32)PET_TALK_SPECIAL_SPELL);
                 else
                 {
                     pet->SendPetAIReaction(guid1);
                 }
 
                 if (unit_target && !GetPlayer()->IsFriendlyTo(unit_target) && !pet->isPossessed() && !pet->IsVehicle())
                 {
                     // This is true if pet has no target or has target but targets differs.
                     if (pet->GetVictim() != unit_target)
                     {
                         if (pet->GetVictim())
                             pet->AttackStop();
                         pet->GetMotionMaster()->Clear();
                         if (pet->ToCreature()->IsAIEnabled)
                             pet->ToCreature()->AI()->AttackStart(unit_target);
                     }
                 }
 
                 spell->prepare(&(spell->m_targets));
             }
             else
             {
                 if (pet->isPossessed() || pet->IsVehicle()) 
                     Spell::SendCastResult(GetPlayer(), spellInfo, 0, result);
                 else
                     spell->SendPetCastResult(result);
 
                 if (!pet->GetSpellHistory()->HasCooldown(spellid))
                     pet->GetSpellHistory()->ResetCooldown(spellid, true);
 
                 spell->finish(false);
                 delete spell;
 
                 // reset specific flags in case of spell fail. AI will reset other flags
                 if (pet->GetCharmInfo())
                     pet->GetCharmInfo()->SetIsCommandAttack(false);
             }
             break;
         }
         default:
             TC_LOG_ERROR("network", "WORLD: unknown PET flag Action %i and spellid %i.", uint32(flag), spellid);
     }
 }

Here is the caller graph for this function:

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

 {
     SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(packet.SpellID);
     if (!spellInfo)
     {
         TC_LOG_ERROR("network", "WORLD: unknown PET spell id %u", packet.SpellID);
         return;
     }
 
     Creature* pet = ObjectAccessor::GetCreatureOrPetOrVehicle(*_player, packet.PetGUID);
 
     if (!pet)
     {
         TC_LOG_ERROR("network", "HandlePetCancelAura: Attempt to cancel an aura for non-existant %s by player '%s'", packet.PetGUID.ToString().c_str(), GetPlayer()->GetName().c_str());
         return;
     }
 
     if (pet != GetPlayer()->GetGuardianPet() && pet != GetPlayer()->GetCharm())
     {
         TC_LOG_ERROR("network", "HandlePetCancelAura: %s is not a pet of player '%s'", packet.PetGUID.ToString().c_str(), GetPlayer()->GetName().c_str());
         return;
     }
 
     if (!pet->IsAlive())
     {
         pet->SendPetActionFeedback(FEEDBACK_PET_DEAD);
         return;
     }
 
     pet->RemoveOwnedAura(packet.SpellID, ObjectGuid::Empty, 0, AURA_REMOVE_BY_CANCEL);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(petCastSpell.Cast.SpellID);
     if (!spellInfo)
     {
         TC_LOG_ERROR("network", "WorldSession::HandlePetCastSpellOpcode: unknown spell id %i tried to cast by %s",
             petCastSpell.Cast.SpellID, petCastSpell.PetGUID.ToString().c_str());
         return;
     }
 
     Unit* caster = ObjectAccessor::GetUnit(*_player, petCastSpell.PetGUID);
     if (!caster)
     {
         TC_LOG_ERROR("network", "WorldSession::HandlePetCastSpellOpcode: Caster %s not found.", petCastSpell.PetGUID.ToString().c_str());
         return;
     }
 
     // This opcode is also sent from charmed and possessed units (players and creatures)
     if (caster != _player->GetGuardianPet() && caster != _player->GetCharm())
     {
         TC_LOG_ERROR("network", "WorldSession::HandlePetCastSpellOpcode: %s isn't pet of player %s (%s).", petCastSpell.PetGUID.ToString().c_str(), GetPlayer()->GetName().c_str(), GetPlayer()->GetGUID().ToString().c_str());
         return;
     }
 
     // do not cast not learned spells
     if (!caster->HasSpell(spellInfo->Id) || spellInfo->IsPassive())
         return;
 
     SpellCastTargets targets(caster, petCastSpell.Cast);
 
     caster->ClearUnitState(UNIT_STATE_FOLLOW);
 
     Spell* spell = new Spell(caster, spellInfo, TRIGGERED_NONE);
     spell->m_cast_count = petCastSpell.Cast.CastID;
     spell->m_misc.Raw.Data[0] = petCastSpell.Cast.Misc[0];
     spell->m_misc.Raw.Data[1] = petCastSpell.Cast.Misc[1];
     spell->m_targets = targets;
 
     SpellCastResult result = spell->CheckPetCast(NULL);
     if (result == SPELL_CAST_OK)
     {
         if (Creature* creature = caster->ToCreature())
         {
             if (Pet* pet = creature->ToPet())
             {
                 // 10% chance to play special pet attack talk, else growl
                 // actually this only seems to happen on special spells, fire shield for imp, torment for voidwalker, but it's stupid to check every spell
                 if (pet->getPetType() == SUMMON_PET && (urand(0, 100) < 10))
                     pet->SendPetTalk(PET_TALK_SPECIAL_SPELL);
                 else
                     pet->SendPetAIReaction(petCastSpell.PetGUID);
             }
         }
 
         spell->prepare(&targets);
     }
     else
     {
         spell->SendPetCastResult(result);
 
         if (!caster->GetSpellHistory()->HasCooldown(spellInfo->Id))
             caster->GetSpellHistory()->ResetCooldown(spellInfo->Id, true);
 
         spell->finish(false);
         delete spell;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     TC_LOG_DEBUG("network", "Petitioner %s tried sell petition: title %s", packet.Unit.ToString().c_str(), packet.Title.c_str());
 
     // prevent cheating
     Creature* creature = GetPlayer()->GetNPCIfCanInteractWith(packet.Unit, UNIT_NPC_FLAG_PETITIONER);
     if (!creature)
     {
         TC_LOG_DEBUG("network", "WORLD: HandlePetitionBuyOpcode - %s not found or you can't interact with him.", packet.Unit.ToString().c_str());
         return;
     }
 
     // remove fake death
     if (GetPlayer()->HasUnitState(UNIT_STATE_DIED))
         GetPlayer()->RemoveAurasByType(SPELL_AURA_FEIGN_DEATH);
 
     uint32 charterItemID = GUILD_CHARTER_ITEM_ID;
     uint32 cost = sWorld->getIntConfig(CONFIG_CHARTER_COST_GUILD);
 
     // do not let if already in guild.
     if (_player->GetGuildId())
         return;
 
     if (sGuildMgr->GetGuildByName(packet.Title))
     {
         Guild::SendCommandResult(this, GUILD_COMMAND_CREATE_GUILD, ERR_GUILD_NAME_EXISTS_S, packet.Title);
         return;
     }
 
     if (sObjectMgr->IsReservedName(packet.Title) || !ObjectMgr::IsValidCharterName(packet.Title))
     {
         Guild::SendCommandResult(this, GUILD_COMMAND_CREATE_GUILD, ERR_GUILD_NAME_INVALID, packet.Title);
         return;
     }
 
     ItemTemplate const* pProto = sObjectMgr->GetItemTemplate(charterItemID);
     if (!pProto)
     {
         _player->SendBuyError(BUY_ERR_CANT_FIND_ITEM, NULL, charterItemID, 0);
         return;
     }
 
     if (!_player->HasEnoughMoney(uint64(cost)))
     {
         _player->SendBuyError(BUY_ERR_NOT_ENOUGHT_MONEY, creature, charterItemID, 0);
         return;
     }
 
     ItemPosCountVec dest;
     InventoryResult msg = _player->CanStoreNewItem(NULL_BAG, NULL_SLOT, dest, charterItemID, pProto->GetBuyCount());
     if (msg != EQUIP_ERR_OK)
     {
         _player->SendEquipError(msg, NULL, NULL, charterItemID);
         return;
     }
 
     _player->ModifyMoney(-int32(cost));
     Item* charter = _player->StoreNewItem(dest, charterItemID, true);
     if (!charter)
         return;
 
     charter->SetUInt32Value(ITEM_FIELD_ENCHANTMENT, charter->GetGUID().GetCounter());
     // ITEM_FIELD_ENCHANTMENT_1_1 is guild/arenateam id
     // ITEM_FIELD_ENCHANTMENT_1_1+1 is current signatures count (showed on item)
     charter->SetState(ITEM_CHANGED, _player);
     _player->SendNewItem(charter, 1, true, false);
 
     // a petition is invalid, if both the owner and the type matches
     // we checked above, if this player is in an arenateam, so this must be
     // datacorruption
     PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_PETITION_BY_OWNER);
     stmt->setUInt64(0, _player->GetGUID().GetCounter());
     PreparedQueryResult result = CharacterDatabase.Query(stmt);
 
     std::ostringstream ssInvalidPetitionGUIDs;
 
     if (result)
     {
         do
         {
             Field* fields = result->Fetch();
             ssInvalidPetitionGUIDs << '\'' << fields[0].GetUInt64() << "', ";
         } while (result->NextRow());
     }
 
     // delete petitions with the same guid as this one
     ssInvalidPetitionGUIDs << '\'' << charter->GetGUID().GetCounter() << '\'';
 
     TC_LOG_DEBUG("network", "Invalid petition GUIDs: %s", ssInvalidPetitionGUIDs.str().c_str());
     CharacterDatabase.EscapeString(packet.Title);
     SQLTransaction trans = CharacterDatabase.BeginTransaction();
     trans->PAppend("DELETE FROM petition WHERE petitionguid IN (%s)",  ssInvalidPetitionGUIDs.str().c_str());
     trans->PAppend("DELETE FROM petition_sign WHERE petitionguid IN (%s)", ssInvalidPetitionGUIDs.str().c_str());
 
     stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_PETITION);
     stmt->setUInt64(0, _player->GetGUID().GetCounter());
     stmt->setUInt64(1, charter->GetGUID().GetCounter());
     stmt->setString(2, packet.Title);
     trans->Append(stmt);
 
     CharacterDatabase.CommitTransaction(trans);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     Item* item = _player->GetItemByGuid(packet.PetitionGuid);
     if (!item)
         return;
 
     if (sGuildMgr->GetGuildByName(packet.NewGuildName))
     {
         Guild::SendCommandResult(this, GUILD_COMMAND_CREATE_GUILD, ERR_GUILD_NAME_EXISTS_S, packet.NewGuildName);
         return;
     }
 
     if (sObjectMgr->IsReservedName(packet.NewGuildName) || !ObjectMgr::IsValidCharterName(packet.NewGuildName))
     {
         Guild::SendCommandResult(this, GUILD_COMMAND_CREATE_GUILD, ERR_GUILD_NAME_INVALID, packet.NewGuildName);
         return;
     }
 
     PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_PETITION_NAME);
 
     stmt->setString(0, packet.NewGuildName);
     stmt->setUInt64(1, packet.PetitionGuid.GetCounter());
 
     CharacterDatabase.Execute(stmt);
 
     WorldPackets::Petition::PetitionRenameGuildResponse renameResponse;
     renameResponse.PetitionGuid = packet.PetitionGuid;
     renameResponse.NewGuildName = packet.NewGuildName;
     SendPacket(renameResponse.Write());
 
     TC_LOG_DEBUG("network", "Petition %s renamed to '%s'", packet.PetitionGuid.ToString().c_str(), packet.NewGuildName.c_str());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     SendPetitionShowList(packet.PetitionUnit);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     uint8 signs = 0;
 
     // if has guild => error, return;
     if (_player->GetGuildId())
         return;
 
     PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_PETITION_SIGNATURE);
 
     stmt->setUInt64(0, packet.Item.GetCounter());
 
     PreparedQueryResult result = CharacterDatabase.Query(stmt);
 
     // result == NULL also correct in case no sign yet
     if (result)
         signs = uint8(result->GetRowCount());
 
     TC_LOG_DEBUG("network", "CMSG_PETITION_SHOW_SIGNATURES %s", packet.Item.ToString().c_str());
 
     WorldPackets::Petition::ServerPetitionShowSignatures signaturesPacket;
     signaturesPacket.Item = packet.Item;
     signaturesPacket.Owner = _player->GetGUID();
     signaturesPacket.OwnerAccountID = ObjectGuid::Create<HighGuid::WowAccount>(ObjectMgr::GetPlayerAccountIdByGUID(_player->GetGUID()));
     signaturesPacket.PetitionID = int32(packet.Item.GetCounter());  // @todo verify that...
 
     signaturesPacket.Signatures.reserve(signs);
     for (uint8 i = 1; i <= signs; ++i)
     {
         Field* fields2 = result->Fetch();
         ObjectGuid signerGUID = ObjectGuid::Create<HighGuid::Player>(fields2[0].GetUInt64());
 
         WorldPackets::Petition::ServerPetitionShowSignatures::PetitionSignature signature;
         signature.Signer = signerGUID;
         signature.Choice = 0;
         signaturesPacket.Signatures.push_back(signature);
 
         // Checking the return value just to be double safe
         if (!result->NextRow())
             break;
     }
 
     SendPacket(signaturesPacket.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     ObjectGuid petguid = packet.RenameData.PetGUID;
     bool isdeclined = packet.RenameData.HasDeclinedNames;
 
     std::string name = packet.RenameData.NewName;
     DeclinedName declinedname = packet.RenameData.DeclinedNames;
 
     Pet* pet = ObjectAccessor::GetPet(*_player, petguid);
                                                             // check it!
     if (!pet || !pet->IsPet() || ((Pet*)pet)->getPetType()!= HUNTER_PET ||
         !pet->HasByteFlag(UNIT_FIELD_BYTES_2, 2, UNIT_CAN_BE_RENAMED) ||
         pet->GetOwnerGUID() != _player->GetGUID() || !pet->GetCharmInfo())
         return;
 
     PetNameInvalidReason res = ObjectMgr::CheckPetName(name);
     if (res != PET_NAME_SUCCESS)
     {
         SendPetNameInvalid(res, name, NULL);
         return;
     }
 
     if (sObjectMgr->IsReservedName(name))
     {
         SendPetNameInvalid(PET_NAME_RESERVED, name, NULL);
         return;
     }
 
     pet->SetName(name);
 
     pet->SetGroupUpdateFlag(GROUP_UPDATE_FLAG_PET_NAME);
 
     pet->RemoveByteFlag(UNIT_FIELD_BYTES_2, 2, UNIT_CAN_BE_RENAMED);
 
     if (isdeclined)
     {
         std::wstring wname;
         if (!Utf8toWStr(name, wname))
             return;
 
         if (!ObjectMgr::CheckDeclinedNames(wname, declinedname))
         {
             SendPetNameInvalid(PET_NAME_DECLENSION_DOESNT_MATCH_BASE_NAME, name, &declinedname);
             return;
         }
     }
 
     SQLTransaction trans = CharacterDatabase.BeginTransaction();
     if (isdeclined)
     {
         PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_PET_DECLINEDNAME);
         stmt->setUInt32(0, pet->GetCharmInfo()->GetPetNumber());
         trans->Append(stmt);
 
         stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_CHAR_PET_DECLINEDNAME);
         stmt->setUInt32(0, pet->GetCharmInfo()->GetPetNumber());
         stmt->setUInt64(1, _player->GetGUID().GetCounter());
 
         for (uint8 i = 0; i < 5; i++)
             stmt->setString(i + 2, declinedname.name[i]);
 
         trans->Append(stmt);
     }
 
     PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_CHAR_PET_NAME);
     stmt->setString(0, name);
     stmt->setUInt64(1, _player->GetGUID().GetCounter());
     stmt->setUInt32(2, pet->GetCharmInfo()->GetPetNumber());
     trans->Append(stmt);
 
     CharacterDatabase.CommitTransaction(trans);
 
     pet->SetUInt32Value(UNIT_FIELD_PET_NAME_TIMESTAMP, uint32(time(NULL))); // cast can't be helped
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     ObjectGuid petguid = packet.PetGUID;
     Unit* pet = ObjectAccessor::GetUnit(*_player, petguid);
 
     if (!pet || pet != _player->GetFirstControlled())
     {
         TC_LOG_ERROR("network", "HandlePetSetAction: Unknown %s or owner (%s)", petguid.ToString().c_str(), _player->GetGUID().ToString().c_str());
         return;
     }
 
     CharmInfo* charmInfo = pet->GetCharmInfo();
     if (!charmInfo)
     {
         TC_LOG_ERROR("network", "WorldSession::HandlePetSetAction: object (%s) is considered pet-like but doesn't have a charminfo!", pet->GetGUID().ToString().c_str());
         return;
     }
 
     uint32 position = packet.Index;
     uint32 actionData = packet.Action;
 
     uint32 spell_id = UNIT_ACTION_BUTTON_ACTION(actionData);
     uint8 act_state = UNIT_ACTION_BUTTON_TYPE(actionData);
 
     TC_LOG_DEBUG("network", "Player %s has changed pet spell action. Position: %u, Spell: %u, State: 0x%X",
         _player->GetName().c_str(), position, spell_id, uint32(act_state));
 
     //if it's act for spell (en/disable/cast) and there is a spell given (0 = remove spell) which pet doesn't know, don't add
     if (!((act_state == ACT_ENABLED || act_state == ACT_DISABLED || act_state == ACT_PASSIVE) && spell_id && !pet->HasSpell(spell_id)))
     {
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spell_id))
         {
             //sign for autocast
             if (act_state == ACT_ENABLED)
             {
                 if (pet->GetTypeId() == TYPEID_UNIT && pet->IsPet())
                     ((Pet*)pet)->ToggleAutocast(spellInfo, true);
                 else
                     for (Unit::ControlList::iterator itr = GetPlayer()->m_Controlled.begin(); itr != GetPlayer()->m_Controlled.end(); ++itr)
                         if ((*itr)->GetEntry() == pet->GetEntry())
                             (*itr)->GetCharmInfo()->ToggleCreatureAutocast(spellInfo, true);
             }
             //sign for no/turn off autocast
             else if (act_state == ACT_DISABLED)
             {
                 if (pet->GetTypeId() == TYPEID_UNIT && pet->IsPet())
                     ((Pet*)pet)->ToggleAutocast(spellInfo, false);
                 else
                     for (Unit::ControlList::iterator itr = GetPlayer()->m_Controlled.begin(); itr != GetPlayer()->m_Controlled.end(); ++itr)
                         if ((*itr)->GetEntry() == pet->GetEntry())
                             (*itr)->GetCharmInfo()->ToggleCreatureAutocast(spellInfo, false);
             }
         }
 
         charmInfo->SetActionBar(position, spell_id, ActiveStates(act_state));
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     Creature* pet = ObjectAccessor::GetCreatureOrPetOrVehicle(*_player, packet.PetGUID);
     if (!pet)
     {
         TC_LOG_ERROR("network", "WorldSession::HandlePetSpellAutocastOpcode: Pet %s not found.", packet.PetGUID.ToString().c_str());
         return;
     }
 
     if (pet != _player->GetGuardianPet() && pet != _player->GetCharm())
     {
         TC_LOG_ERROR("network", "WorldSession::HandlePetSpellAutocastOpcode: %s isn't pet of player %s (%s).",
             packet.PetGUID.ToString().c_str(), GetPlayer()->GetName().c_str(), GetPlayer()->GetGUID().ToString().c_str());
         return;
     }
 
     SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(packet.SpellID);
     if (!spellInfo)
     {
         TC_LOG_ERROR("network", "WorldSession::HandlePetSpellAutocastOpcode: Unknown spell id %u used by %s.", packet.SpellID, packet.PetGUID.ToString().c_str());
         return;
     }
 
     // do not add not learned spells/ passive spells
     if (!pet->HasSpell(packet.SpellID) || !spellInfo->IsAutocastable())
         return;
 
     CharmInfo* charmInfo = pet->GetCharmInfo();
     if (!charmInfo)
     {
         TC_LOG_ERROR("network", "WorldSession::HandlePetSpellAutocastOpcode: object (%s) is considered pet-like but doesn't have a charminfo!", pet->GetGUID().ToString().c_str());
         return;
     }
 
     if (pet->IsPet())
         pet->ToPet()->ToggleAutocast(spellInfo, packet.AutocastEnabled);
     else
         charmInfo->ToggleCreatureAutocast(spellInfo, packet.AutocastEnabled);
 
     charmInfo->SetSpellAutocast(spellInfo, packet.AutocastEnabled);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     Unit* pet = ObjectAccessor::GetCreatureOrPetOrVehicle(*_player, packet.PetGUID);
 
     if (!pet)
     {
         TC_LOG_ERROR("network", "HandlePetStopAttack: %s does not exist", packet.PetGUID.ToString().c_str());
         return;
     }
 
     if (pet != GetPlayer()->GetPet() && pet != GetPlayer()->GetCharm())
     {
         TC_LOG_ERROR("network", "HandlePetStopAttack: %s isn't a pet or charmed creature of player %s",
             packet.PetGUID.ToString().c_str(), GetPlayer()->GetName().c_str());
         return;
     }
 
     if (!pet->IsAlive())
         return;
 
     pet->AttackStop();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandlePingOpcode ( WorldPacket & recvPacket )

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

 {
     WorldPackets::Character::PlayedTime playedTime;
     playedTime.TotalTime = _player->GetTotalPlayedTime();
     playedTime.LevelTime = _player->GetLevelPlayedTime();
     playedTime.TriggerEvent = packet.TriggerScriptEvent;  // 0-1 - will not show in chat frame
     SendPacket(playedTime.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandlePlayerLogin ( LoginQueryHolder * holder )

 {
     ObjectGuid playerGuid = holder->GetGuid();
 
     Player* pCurrChar = new Player(this);
      // for send server info and strings (config)
     ChatHandler chH = ChatHandler(pCurrChar->GetSession());
 
     // "GetAccountId() == db stored account id" checked in LoadFromDB (prevent login not own character using cheating tools)
     if (!pCurrChar->LoadFromDB(playerGuid, holder))
     {
         SetPlayer(NULL);
         KickPlayer();                                       // disconnect client, player no set to session and it will not deleted or saved at kick
         delete pCurrChar;                                   // delete it manually
         delete holder;                                      // delete all unprocessed queries
         m_playerLoading.Clear();
         return;
     }
 
     SendTutorialsData();
 
     pCurrChar->GetMotionMaster()->Initialize();
     pCurrChar->SendDungeonDifficulty();
 
     WorldPackets::Character::LoginVerifyWorld loginVerifyWorld;
     loginVerifyWorld.MapID = pCurrChar->GetMapId();
     loginVerifyWorld.Pos = pCurrChar->GetPosition();
     SendPacket(loginVerifyWorld.Write());
 
     // load player specific part before send times
     LoadAccountData(holder->GetPreparedResult(PLAYER_LOGIN_QUERY_LOAD_ACCOUNT_DATA), PER_CHARACTER_CACHE_MASK);
 
     WorldPackets::ClientConfig::AccountDataTimes accountDataTimes;
     accountDataTimes.PlayerGuid = playerGuid;
     accountDataTimes.ServerTime = uint32(sWorld->GetGameTime());
     for (uint32 i = 0; i < NUM_ACCOUNT_DATA_TYPES; ++i)
         accountDataTimes.AccountTimes[i] = uint32(GetAccountData(AccountDataType(i))->Time);
 
     SendPacket(accountDataTimes.Write());
 
     SendFeatureSystemStatus();
 
     // Send MOTD
     {
         WorldPackets::System::MOTD motd;
         motd.Text = &sWorld->GetMotd();
         SendPacket(motd.Write());
         TC_LOG_DEBUG("network", "WORLD: Sent motd (SMSG_MOTD)");
     }
 
     SendSetTimeZoneInformation();
 
     // Send PVPSeason
     {
         WorldPackets::Battleground::PVPSeason season;
         season.PreviousSeason = sWorld->getIntConfig(CONFIG_ARENA_SEASON_ID) - sWorld->getBoolConfig(CONFIG_ARENA_SEASON_IN_PROGRESS);
 
         if (sWorld->getBoolConfig(CONFIG_ARENA_SEASON_IN_PROGRESS))
             season.CurrentSeason = sWorld->getIntConfig(CONFIG_ARENA_SEASON_ID);
 
         SendPacket(season.Write());
         TC_LOG_DEBUG("network", "WORLD: Sent PVPSeason");
     }
 
     // send server info
     {
         if (sWorld->getIntConfig(CONFIG_ENABLE_SINFO_LOGIN) == 1)
             chH.PSendSysMessage(GitRevision::GetFullVersion());
 
         TC_LOG_DEBUG("network", "WORLD: Sent server info");
     }
 
     //QueryResult* result = CharacterDatabase.PQuery("SELECT guildid, rank FROM guild_member WHERE guid = '%u'", pCurrChar->GetGUIDLow());
     if (PreparedQueryResult resultGuild = holder->GetPreparedResult(PLAYER_LOGIN_QUERY_LOAD_GUILD))
     {
         Field* fields = resultGuild->Fetch();
         pCurrChar->SetInGuild(fields[0].GetUInt64());
         pCurrChar->SetRank(fields[1].GetUInt8());
         if (Guild* guild = sGuildMgr->GetGuildById(pCurrChar->GetGuildId()))
             pCurrChar->SetGuildLevel(guild->GetLevel());
     }
     else if (pCurrChar->GetGuildId())                        // clear guild related fields in case wrong data about non existed membership
     {
         pCurrChar->SetInGuild(UI64LIT(0));
         pCurrChar->SetRank(0);
         pCurrChar->SetGuildLevel(0);
     }
 
     //WorldPacket data(SMSG_LEARNED_DANCE_MOVES, 4+4);
     //data << uint64(0);
     //SendPacket(&data);
 
     WorldPackets::Query::HotfixNotifyBlob hotfixInfo;
     hotfixInfo.Hotfixes = sDB2Manager.GetHotfixData();
     SendPacket(hotfixInfo.Write());
 
     // TODO: Move this to BattlePetMgr::SendJournalLock() just to have all packets in one file
     WorldPackets::BattlePet::BattlePetJournalLockAcquired lock;
     SendPacket(lock.Write());
 
     pCurrChar->SendInitialPacketsBeforeAddToMap();
 
     //Show cinematic at the first time that player login
     if (!pCurrChar->getCinematic())
     {
         pCurrChar->setCinematic(1);
 
         if (ChrClassesEntry const* cEntry = sChrClassesStore.LookupEntry(pCurrChar->getClass()))
         {
             if (cEntry->CinematicSequenceID)
                 pCurrChar->SendCinematicStart(cEntry->CinematicSequenceID);
             else if (ChrRacesEntry const* rEntry = sChrRacesStore.LookupEntry(pCurrChar->getRace()))
                 pCurrChar->SendCinematicStart(rEntry->CinematicSequenceID);
 
             // send new char string if not empty
             if (!sWorld->GetNewCharString().empty())
                 chH.PSendSysMessage("%s", sWorld->GetNewCharString().c_str());
         }
     }
 
     if (!pCurrChar->GetMap()->AddPlayerToMap(pCurrChar))
     {
         AreaTriggerStruct const* at = sObjectMgr->GetGoBackTrigger(pCurrChar->GetMapId());
         if (at)
             pCurrChar->TeleportTo(at->target_mapId, at->target_X, at->target_Y, at->target_Z, pCurrChar->GetOrientation());
         else
             pCurrChar->TeleportTo(pCurrChar->m_homebindMapId, pCurrChar->m_homebindX, pCurrChar->m_homebindY, pCurrChar->m_homebindZ, pCurrChar->GetOrientation());
     }
 
     ObjectAccessor::AddObject(pCurrChar);
     //TC_LOG_DEBUG("Player %s added to Map.", pCurrChar->GetName().c_str());
 
     if (pCurrChar->GetGuildId())
     {
         if (Guild* guild = sGuildMgr->GetGuildById(pCurrChar->GetGuildId()))
             guild->SendLoginInfo(this);
         else
         {
             // remove wrong guild data
             TC_LOG_ERROR("misc", "Player %s (%s) marked as member of not existing guild (id: " UI64FMTD "), removing guild membership for player.", pCurrChar->GetName().c_str(), pCurrChar->GetGUID().ToString().c_str(), pCurrChar->GetGuildId());
             pCurrChar->SetInGuild(UI64LIT(0));
         }
     }
 
     pCurrChar->SendInitialPacketsAfterAddToMap();
 
     PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_CHAR_ONLINE);
     stmt->setUInt64(0, pCurrChar->GetGUID().GetCounter());
     CharacterDatabase.Execute(stmt);
 
     stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_ACCOUNT_ONLINE);
     stmt->setUInt32(0, GetAccountId());
     LoginDatabase.Execute(stmt);
 
     pCurrChar->SetInGameTime(getMSTime());
 
     // announce group about member online (must be after add to player list to receive announce to self)
     if (Group* group = pCurrChar->GetGroup())
     {
         //pCurrChar->groupInfo.group->SendInit(this); // useless
         group->SendUpdate();
         group->ResetMaxEnchantingLevel();
     }
 
     // friend status
     sSocialMgr->SendFriendStatus(pCurrChar, FRIEND_ONLINE, pCurrChar->GetGUID(), true);
 
     // Place character in world (and load zone) before some object loading
     pCurrChar->LoadCorpse(holder->GetPreparedResult(PLAYER_LOGIN_QUERY_LOAD_CORPSE_LOCATION));
 
     // setting Ghost+speed if dead
     if (pCurrChar->m_deathState != ALIVE)
     {
         // not blizz like, we must correctly save and load player instead...
         if (pCurrChar->getRace() == RACE_NIGHTELF && !pCurrChar->HasAura(20584))
             pCurrChar->CastSpell(pCurrChar, 20584, true, 0);// auras SPELL_AURA_INCREASE_SPEED(+speed in wisp form), SPELL_AURA_INCREASE_SWIM_SPEED(+swim speed in wisp form), SPELL_AURA_TRANSFORM (to wisp form)
 
         if (!pCurrChar->HasAura(8326))
             pCurrChar->CastSpell(pCurrChar, 8326, true, 0);     // auras SPELL_AURA_GHOST, SPELL_AURA_INCREASE_SPEED(why?), SPELL_AURA_INCREASE_SWIM_SPEED(why?)
 
         pCurrChar->SetWaterWalking(true);
     }
 
     pCurrChar->ContinueTaxiFlight();
 
     // reset for all pets before pet loading
     if (pCurrChar->HasAtLoginFlag(AT_LOGIN_RESET_PET_TALENTS))
         Pet::resetTalentsForAllPetsOf(pCurrChar);
 
     // Load pet if any (if player not alive and in taxi flight or another then pet will remember as temporary unsummoned)
     pCurrChar->LoadPet();
 
     // Set FFA PvP for non GM in non-rest mode
     if (sWorld->IsFFAPvPRealm() && !pCurrChar->IsGameMaster() && !pCurrChar->HasFlag(PLAYER_FLAGS, PLAYER_FLAGS_RESTING))
         pCurrChar->SetByteFlag(UNIT_FIELD_BYTES_2, 1, UNIT_BYTE2_FLAG_FFA_PVP);
 
     if (pCurrChar->HasFlag(PLAYER_FLAGS, PLAYER_FLAGS_CONTESTED_PVP))
         pCurrChar->SetContestedPvP();
 
     // Apply at_login requests
     if (pCurrChar->HasAtLoginFlag(AT_LOGIN_RESET_SPELLS))
     {
         pCurrChar->ResetSpells();
         SendNotification(LANG_RESET_SPELLS);
     }
 
     if (pCurrChar->HasAtLoginFlag(AT_LOGIN_RESET_TALENTS))
     {
         pCurrChar->ResetTalents(true);
         pCurrChar->ResetTalentSpecialization();
         pCurrChar->SendTalentsInfoData(); // original talents send already in to SendInitialPacketsBeforeAddToMap, resend reset state
         SendNotification(LANG_RESET_TALENTS);
     }
 
     bool firstLogin = pCurrChar->HasAtLoginFlag(AT_LOGIN_FIRST);
     if (firstLogin)
     {
         pCurrChar->RemoveAtLoginFlag(AT_LOGIN_FIRST);
 
         PlayerInfo const* info = sObjectMgr->GetPlayerInfo(pCurrChar->getRace(), pCurrChar->getClass());
         for (uint32 spellId : info->castSpells)
             pCurrChar->CastSpell(pCurrChar, spellId, true);
     }
 
     // show time before shutdown if shutdown planned.
     if (sWorld->IsShuttingDown())
         sWorld->ShutdownMsg(true, pCurrChar);
 
     if (sWorld->getBoolConfig(CONFIG_ALL_TAXI_PATHS))
         pCurrChar->SetTaxiCheater(true);
 
     if (pCurrChar->IsGameMaster())
         SendNotification(LANG_GM_ON);
 
     TC_LOG_INFO("entities.player.character", "Account: %u (IP: %s) Login Character: [%s] (%s) Level: %d",
         GetAccountId(), GetRemoteAddress().c_str(), pCurrChar->GetName().c_str(), pCurrChar->GetGUID().ToString().c_str(), pCurrChar->getLevel());
 
     if (!pCurrChar->IsStandState() && !pCurrChar->HasUnitState(UNIT_STATE_STUNNED))
         pCurrChar->SetStandState(UNIT_STAND_STATE_STAND);
 
     m_playerLoading.Clear();
 
     // Handle Login-Achievements (should be handled after loading)
     _player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_ON_LOGIN, 1);
 
     sScriptMgr->OnPlayerLogin(pCurrChar, firstLogin);
 
     delete holder;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (PlayerLoading() || GetPlayer() != NULL)
     {
         TC_LOG_ERROR("network", "Player tries to login again, AccountId = %d", GetAccountId());
         KickPlayer();
         return;
     }
 
     TC_LOG_DEBUG("network", "WORLD: Recvd Player Logon Message");
 
     m_playerLoading = playerLogin.Guid;
 
     TC_LOG_DEBUG("network", "Character %s logging in", playerLogin.Guid.ToString().c_str());
 
     if (!IsLegitCharacterForAccount(playerLogin.Guid))
     {
         TC_LOG_ERROR("network", "Account (%u) can't login with that character (%s).", GetAccountId(), playerLogin.Guid.ToString().c_str());
         KickPlayer();
         return;
     }
 
     SendConnectToInstance(WorldPackets::Auth::ConnectToSerial::WorldAttempt1);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (GetPlayer()->IsAlive() || !GetPlayer()->HasFlag(PLAYER_FLAGS, PLAYER_FLAGS_GHOST))
         return;
     GetPlayer()->RepopAtGraveyard();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (!_player->CanShareQuest(packet.QuestID))
         return;
 
     Quest const* quest = sObjectMgr->GetQuestTemplate(packet.QuestID);
     if (!quest)
         return;
 
     Player * const sender = GetPlayer();
 
     Group* group = sender->GetGroup();
     if (!group)
         return;
 
     for (GroupReference* itr = group->GetFirstMember(); itr != NULL; itr = itr->next())
     {
         Player* receiver = itr->GetSource();
 
         if (!receiver || receiver == sender)
             continue;
 
         if (!receiver->SatisfyQuestStatus(quest, false))
         {
             sender->SendPushToPartyResponse(receiver, QUEST_PUSH_ONQUEST);
             continue;
         }
 
         if (receiver->GetQuestStatus(packet.QuestID) == QUEST_STATUS_COMPLETE)
         {
             sender->SendPushToPartyResponse(receiver, QUEST_PUSH_ALREADY_DONE);
             continue;
         }
 
         if (!receiver->CanTakeQuest(quest, false))
         {
             sender->SendPushToPartyResponse(receiver, QUEST_PUSH_INVALID);
             continue;
         }
 
         if (!receiver->SatisfyQuestLog(false))
         {
             sender->SendPushToPartyResponse(receiver, QUEST_PUSH_LOG_FULL);
             continue;
         }
 
         if (!receiver->GetDivider().IsEmpty())
         {
             sender->SendPushToPartyResponse(receiver, QUEST_PUSH_BUSY);
             continue;
         }
 
         sender->SendPushToPartyResponse(receiver, QUEST_PUSH_SUCCESS);
 
         if (quest->IsAutoAccept() && receiver->CanAddQuest(quest, true) && receiver->CanTakeQuest(quest, true))
             receiver->AddQuestAndCheckCompletion(quest, sender);
 
         if (quest->IsAutoComplete() && quest->IsRepeatable() && !quest->IsDailyOrWeekly())
             receiver->PlayerTalkClass->SendQuestGiverRequestItems(quest, sender->GetGUID(), receiver->CanCompleteRepeatableQuest(quest), true);
         else
         {
             receiver->SetDivider(sender->GetGUID());
             receiver->PlayerTalkClass->SendQuestGiverQuestDetails(quest, receiver->GetGUID(), true);
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     Battleground* bg = _player->GetBattleground();
     if (!bg)
         return;
 
     // Prevent players from sending BuildPvpLogDataPacket in an arena except for when sent in BattleGround::EndBattleGround.
     if (bg->isArena())
         return;
 
     WorldPackets::Battleground::PVPLogData pvpLogData;
     bg->BuildPvPLogDataPacket(pvpLogData);
     SendPacket(pvpLogData.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (!_player->HasCorpse())
     {
         WorldPackets::Query::CorpseLocation packet;
         packet.Valid = false;                               // corpse not found
         SendPacket(packet.Write());
         return;
     }
 
     WorldLocation corpseLocation = _player->GetCorpseLocation();
     uint32 corpseMapID = corpseLocation.GetMapId();
     uint32 mapID = corpseLocation.GetMapId();
     float x = corpseLocation.GetPositionX();
     float y = corpseLocation.GetPositionY();
     float z = corpseLocation.GetPositionZ();
 
     // if corpse at different map
     if (mapID != _player->GetMapId())
     {
         // search entrance map for proper show entrance
         if (MapEntry const* corpseMapEntry = sMapStore.LookupEntry(mapID))
         {
             if (corpseMapEntry->IsDungeon() && corpseMapEntry->CorpseMapID >= 0)
             {
                 // if corpse map have entrance
                 if (Map const* entranceMap = sMapMgr->CreateBaseMap(corpseMapEntry->CorpseMapID))
                 {
                     mapID = corpseMapEntry->CorpseMapID;
                     x = corpseMapEntry->CorpsePos.X;
                     y = corpseMapEntry->CorpsePos.Y;
                     z = entranceMap->GetHeight(GetPlayer()->GetPhaseMask(), x, y, MAX_HEIGHT);
                 }
             }
         }
     }
 
     WorldPackets::Query::CorpseLocation packet;
     packet.Valid = true;
     packet.MapID = corpseMapID;
     packet.ActualMapID = mapID;
     packet.Position = G3D::Vector3(x, y, z);
     packet.Transport = ObjectGuid::Empty;
     SendPacket(packet.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     Corpse* corpse = _player->GetCorpse();
 
     WorldPackets::Query::CorpseTransportQuery response;
     if (!corpse || corpse->GetTransGUID().IsEmpty() || corpse->GetTransGUID() != queryCorpseTransport.Transport)
     {
         response.Position = G3D::Vector3(0.0f, 0.0f, 0.0f);
         response.Facing = 0.0f;
     }
     else
     {
         response.Position = G3D::Vector3(corpse->GetTransOffsetX(), corpse->GetTransOffsetY(), corpse->GetTransOffsetZ());
         response.Facing = corpse->GetTransOffsetO();
     }
 
     SendPacket(response.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     Player* player = ObjectAccessor::FindPlayer(inspect.Guid);
     if (!player)
     {
         TC_LOG_DEBUG("network", "WorldSession::HandleQueryInspectAchievements: [%s] inspected unknown Player [%s]", GetPlayer()->GetGUID().ToString().c_str(), inspect.Guid.ToString().c_str());
         return;
     }
 
     TC_LOG_DEBUG("network", "WorldSession::HandleQueryInspectAchievements: [%s] inspected Player [%s]", GetPlayer()->GetGUID().ToString().c_str(), inspect.Guid.ToString().c_str());
 
     if (!GetPlayer()->IsWithinDistInMap(player, INSPECT_DISTANCE, false))
         return;
 
     if (GetPlayer()->IsValidAttackTarget(player))
         return;
 
     player->SendRespondInspectAchievements(GetPlayer());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleQueryNextMailTime ( WorldPackets::Mail::MailQueryNextMailTime & packet )

Todo:: Fix me! ... this void has probably bad condition, but good data are sent

 {
     WorldPackets::Mail::MailQueryNextTimeResult result;
 
     if (!_player->m_mailsLoaded)
         _player->_LoadMail();
 
     if (_player->unReadMails > 0)
     {
         result.NextMailTime = 0.0f;
 
         time_t now = time(nullptr);
         std::set<ObjectGuid::LowType> sentSenders;
 
         for (Mail* mail : _player->GetMails())
         {
             if (mail->checked & MAIL_CHECK_MASK_READ)
                 continue;
 
             // already delivered
             if (now < mail->deliver_time)
                 continue;
 
             // only send each mail sender once
             if (sentSenders.count(mail->sender))
                 continue;
 
             result.Next.emplace_back(mail);
 
             sentSenders.insert(mail->sender);
 
             // do not send more than 2 mails
             if (sentSenders.size() > 2)
                 break;
         }
     }
     else
         result.NextMailTime = -DAY;
 
     SendPacket(result.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleQueryPageText ( WorldPackets::Query::QueryPageText & packet )

Only static data is sent in this packet !!!

 {
     uint32 pageID = packet.PageTextID;
 
     while (pageID)
     {
         PageText const* pageText = sObjectMgr->GetPageText(pageID);
 
         WorldPackets::Query::QueryPageTextResponse response;
         response.PageTextID = pageID;
 
         if (!pageText)
         {
             response.Allow = false;
             pageID = 0;
         }
         else
         {
             response.Allow = true;
             response.Info.ID = pageID;
             response.Info.NextPageID = pageText->NextPageID;
             response.Info.Text = pageText->Text;
 
             LocaleConstant localeConstant = GetSessionDbLocaleIndex();
             if (localeConstant >= LOCALE_enUS)
                 if (PageTextLocale const* pageTextLocale = sObjectMgr->GetPageTextLocale(pageID))
                     ObjectMgr::GetLocaleString(pageTextLocale->Text, localeConstant, response.Info.Text);
 
             pageID = pageText->NextPageID;
         }
 
         SendPacket(response.Write());
 
         TC_LOG_DEBUG("network", "WORLD: Sent SMSG_QUERY_PAGE_TEXT_RESPONSE");
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     TC_LOG_DEBUG("network", "Received CMSG_QUERY_PETITION Petition %s PetitionID %u", packet.ItemGUID.ToString().c_str(), packet.PetitionID);
 
     SendPetitionQueryOpcode(packet.ItemGUID);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     SendQueryPetNameResponse(packet.UnitGUID);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     WorldPackets::Query::QuestCompletionNPCResponse response;
 
     for (int32& questID : queryQuestCompletionNPCs.QuestCompletionNPCs)
     {
         WorldPackets::Query::QuestCompletionNPC questCompletionNPC;
 
         if (!sObjectMgr->GetQuestTemplate(questID))
         {
             TC_LOG_DEBUG("network", "WORLD: Unknown quest %u in CMSG_QUERY_QUEST_COMPLETION_NPCS by %s", questID, _player->GetGUID().ToString().c_str());
             continue;
         }
 
         questCompletionNPC.QuestID = questID;
 
         auto creatures = sObjectMgr->GetCreatureQuestInvolvedRelationReverseBounds(questID);
         for (auto it = creatures.first; it != creatures.second; ++it)
             questCompletionNPC.NPCs.push_back(it->second);
 
         auto gos = sObjectMgr->GetGOQuestInvolvedRelationReverseBounds(questID);
         for (auto it = gos.first; it != gos.second; ++it)
             questCompletionNPC.NPCs.push_back(it->second | 0x80000000); // GO mask
 
         response.QuestCompletionNPCs.push_back(questCompletionNPC);
     }
 
     SendPacket(response.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     SendQueryTimeResponse();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     TC_LOG_DEBUG("network", "WORLD: Received CMSG_QUEST_CONFIRM_ACCEPT questId = %u", packet.QuestID);
 
     if (Quest const* quest = sObjectMgr->GetQuestTemplate(packet.QuestID))
     {
         if (!quest->HasFlag(QUEST_FLAGS_PARTY_ACCEPT))
             return;
 
         Player* originalPlayer = ObjectAccessor::FindPlayer(_player->GetDivider());
         if (!originalPlayer)
             return;
 
         if (!_player->IsInSameRaidWith(originalPlayer))
             return;
 
         if (!originalPlayer->IsActiveQuest(packet.QuestID))
             return;
 
         if (!_player->CanTakeQuest(quest, true))
             return;
 
         if (_player->CanAddQuest(quest, true))
         {
             _player->AddQuestAndCheckCompletion(quest, NULL); // NULL, this prevent DB script from duplicate running
 
             if (quest->GetSrcSpell() > 0)
                 _player->CastSpell(_player, quest->GetSrcSpell(), true);
         }
     }
 
     _player->SetDivider(ObjectGuid::Empty);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     TC_LOG_DEBUG("network", "WORLD: Received CMSG_QUESTGIVER_ACCEPT_QUEST %s, quest = %u, startcheat = %u", packet.QuestGiverGUID.ToString().c_str(), packet.QuestID, packet.StartCheat);
 
     Object* object;
     if (!packet.QuestGiverGUID.IsPlayer())
         object = ObjectAccessor::GetObjectByTypeMask(*_player, packet.QuestGiverGUID, TYPEMASK_UNIT | TYPEMASK_GAMEOBJECT | TYPEMASK_ITEM);
     else
         object = ObjectAccessor::FindPlayer(packet.QuestGiverGUID);
 
 #define CLOSE_GOSSIP_CLEAR_DIVIDER() \
     do { \
         _player->PlayerTalkClass->SendCloseGossip(); \
         _player->SetDivider(ObjectGuid::Empty); \
     } while (0)
 
     // no or incorrect quest giver
     if (!object)
     {
         CLOSE_GOSSIP_CLEAR_DIVIDER();
         return;
     }
 
     if (Player* playerQuestObject = object->ToPlayer())
     {
         if ((_player->GetDivider().IsEmpty() && _player->GetDivider() != packet.QuestGiverGUID) || !playerQuestObject->CanShareQuest(packet.QuestID))
         {
             CLOSE_GOSSIP_CLEAR_DIVIDER();
             return;
         }
         if (!_player->IsInSameRaidWith(playerQuestObject))
         {
             CLOSE_GOSSIP_CLEAR_DIVIDER();
             return;
         }
     }
     else
     {
         if (!object->hasQuest(packet.QuestID))
         {
             CLOSE_GOSSIP_CLEAR_DIVIDER();
             return;
         }
     }
 
     // some kind of WPE protection
     if (!_player->CanInteractWithQuestGiver(object))
     {
         CLOSE_GOSSIP_CLEAR_DIVIDER();
         return;
     }
 
     if (Quest const* quest = sObjectMgr->GetQuestTemplate(packet.QuestID))
     {
         // prevent cheating
         if (!GetPlayer()->CanTakeQuest(quest, true))
         {
             CLOSE_GOSSIP_CLEAR_DIVIDER();
             return;
         }
 
         if (!_player->GetDivider().IsEmpty())
         {
             Player* player = ObjectAccessor::FindPlayer(_player->GetDivider());
             if (player)
             {
                 player->SendPushToPartyResponse(_player, QUEST_PUSH_ACCEPTED);
                 _player->SetDivider(ObjectGuid::Empty);
             }
         }
 
         if (_player->CanAddQuest(quest, true))
         {
             _player->AddQuestAndCheckCompletion(quest, object);
 
             if (quest->HasFlag(QUEST_FLAGS_PARTY_ACCEPT))
             {
                 if (Group* group = _player->GetGroup())
                 {
                     for (GroupReference* itr = group->GetFirstMember(); itr != NULL; itr = itr->next())
                     {
                         Player* player = itr->GetSource();
 
                         if (!player || player == _player)     // not self
                             continue;
 
                         if (player->CanTakeQuest(quest, true))
                         {
                             player->SetDivider(_player->GetGUID());
 
                             // need confirmation that any gossip window will close
                             player->PlayerTalkClass->SendCloseGossip();
 
                             _player->SendQuestConfirmAccept(quest, player);
                         }
                     }
                 }
             }
 
             _player->PlayerTalkClass->SendCloseGossip();
 
             if (quest->GetSrcSpell() > 0)
                 _player->CastSpell(_player, quest->GetSrcSpell(), true);
 
             return;
         }
     }
 
     CLOSE_GOSSIP_CLEAR_DIVIDER();
 
 #undef CLOSE_GOSSIP_CLEAR_DIVIDER
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleQuestgiverCancel ( WorldPacket & recvData )

 {
     _player->PlayerTalkClass->SendCloseGossip();
 }

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

 {
     TC_LOG_DEBUG("network", "WORLD: Received CMSG_QUESTGIVER_CHOOSE_REWARD npc = %s, quest = %u, reward = %u", packet.QuestGiverGUID.ToString().c_str(), packet.QuestID, packet.ItemChoiceID);
 
     Quest const* quest = sObjectMgr->GetQuestTemplate(packet.QuestID);
     if (!quest)
         return;
 
     // This is Real Item Entry, not slot id as pre 5.x
     if (packet.ItemChoiceID)
     {
         ItemTemplate const* rewardProto = sObjectMgr->GetItemTemplate(packet.ItemChoiceID);
         if (!rewardProto)
         {
             TC_LOG_ERROR("network", "Error in CMSG_QUESTGIVER_CHOOSE_REWARD: player %s (%s) tried to get invalid reward item (Item Entry: %u) for quest %u (possible packet-hacking detected)", _player->GetName().c_str(), _player->GetGUID().ToString().c_str(), packet.ItemChoiceID, packet.QuestID);
             return;
         }
 
         bool itemValid = false;
         for (uint32 i = 0; i < quest->GetRewChoiceItemsCount(); ++i)
         {
             if (quest->RewardChoiceItemId[i] && quest->RewardChoiceItemId[i] == uint32(packet.ItemChoiceID))
             {
                 itemValid = true;
                 break;
             }
         }
 
         if (!itemValid && quest->GetQuestPackageID())
         {
             if (std::vector<QuestPackageItemEntry const*> const* questPackageItems = sDB2Manager.GetQuestPackageItems(quest->GetQuestPackageID()))
             {
                 for (QuestPackageItemEntry const* questPackageItem : *questPackageItems)
                 {
                     if (questPackageItem->ItemID != uint32(packet.ItemChoiceID))
                         continue;
 
                     rewardProto = sObjectMgr->GetItemTemplate(questPackageItem->ItemID);
                     if (rewardProto)
                     {
                         if (rewardProto->CanWinForPlayer(_player))
                         {
                             itemValid = true;
                             break;
                         }
                     }
                 }
             }
         }
 
         if (!itemValid)
         {
             TC_LOG_ERROR("network", "Error in CMSG_QUESTGIVER_CHOOSE_REWARD: player %s (%s) tried to get reward item (Item Entry: %u) wich is not a reward for quest %u (possible packet-hacking detected)", _player->GetName().c_str(), _player->GetGUID().ToString().c_str(), packet.ItemChoiceID, packet.QuestID);
             return;
         }
     }
 
     Object* object = _player;
 
     if (!quest->HasFlag(QUEST_FLAGS_AUTOCOMPLETE))
     {
         object = ObjectAccessor::GetObjectByTypeMask(*_player, packet.QuestGiverGUID, TYPEMASK_UNIT|TYPEMASK_GAMEOBJECT);
         if (!object || !object->hasInvolvedQuest(packet.QuestID))
             return;
 
         // some kind of WPE protection
         if (!_player->CanInteractWithQuestGiver(object))
             return;
     }
 
     if ((!_player->CanSeeStartQuest(quest) &&  _player->GetQuestStatus(packet.QuestID) == QUEST_STATUS_NONE) ||
         (_player->GetQuestStatus(packet.QuestID) != QUEST_STATUS_COMPLETE && !quest->IsAutoComplete()))
     {
         TC_LOG_ERROR("network", "Error in QUEST_STATUS_COMPLETE: player %s (%s) tried to complete quest %u, but is not allowed to do so (possible packet-hacking or high latency)",
             _player->GetName().c_str(), _player->GetGUID().ToString().c_str(), packet.QuestID);
         return;
     }
 
     if (_player->CanRewardQuest(quest, packet.ItemChoiceID, true))
     {
         _player->RewardQuest(quest, packet.ItemChoiceID, object);
 
         switch (object->GetTypeId())
         {
             case TYPEID_UNIT:
             case TYPEID_PLAYER:
             {
                 //For AutoSubmition was added plr case there as it almost same exclute AI script cases.
                 Creature* creatureQGiver = object->ToCreature();
                 if (!creatureQGiver || !sScriptMgr->OnQuestReward(_player, creatureQGiver, quest, packet.ItemChoiceID))
                 {
                     // Send next quest
                     if (Quest const* nextQuest = _player->GetNextQuest(packet.QuestGiverGUID, quest))
                     {
                         // Only send the quest to the player if the conditions are met
                         if (_player->CanTakeQuest(nextQuest, false))
                         {
                             if (nextQuest->IsAutoAccept() && _player->CanAddQuest(nextQuest, true))
                                 _player->AddQuestAndCheckCompletion(nextQuest, object);
 
                             _player->PlayerTalkClass->SendQuestGiverQuestDetails(nextQuest, packet.QuestGiverGUID, true);
                         }
                     }
 
                     if (creatureQGiver)
                         creatureQGiver->AI()->sQuestReward(_player, quest, packet.ItemChoiceID);
                 }
                 break;
             }
             case TYPEID_GAMEOBJECT:
             {
                 GameObject* questGiver = object->ToGameObject();
                 if (!sScriptMgr->OnQuestReward(_player, questGiver, quest, packet.ItemChoiceID))
                 {
                     // Send next quest
                     if (Quest const* nextQuest = _player->GetNextQuest(packet.QuestGiverGUID, quest))
                     {
                         // Only send the quest to the player if the conditions are met
                         if (_player->CanTakeQuest(nextQuest, false))
                         {
                             if (nextQuest->IsAutoAccept() && _player->CanAddQuest(nextQuest, true))
                                 _player->AddQuestAndCheckCompletion(nextQuest, object);
 
                             _player->PlayerTalkClass->SendQuestGiverQuestDetails(nextQuest, packet.QuestGiverGUID, true);
                         }
                     }
 
                     questGiver->AI()->QuestReward(_player, quest, packet.ItemChoiceID);
                 }
                 break;
             }
             default:
                 break;
         }
     }
     else
         _player->PlayerTalkClass->SendQuestGiverOfferReward(quest, packet.QuestGiverGUID, true);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     bool autoCompleteMode = packet.FromScript; // 0 - standart complete quest mode with npc, 1 - auto-complete mode
 
     TC_LOG_DEBUG("network", "WORLD: Received CMSG_QUESTGIVER_COMPLETE_QUEST npc = %s, questId = %u self-complete: %u", packet.QuestGiverGUID.ToString().c_str(), packet.QuestID, autoCompleteMode ? 1 : 0);
 
     Quest const* quest = sObjectMgr->GetQuestTemplate(packet.QuestID);
     if (!quest)
         return;
 
     if (autoCompleteMode && !quest->HasFlag(QUEST_FLAGS_AUTOCOMPLETE))
         return;
 
     Object* object = nullptr;
     if (autoCompleteMode)
         object = _player;
     else
         object = ObjectAccessor::GetObjectByTypeMask(*_player, packet.QuestGiverGUID, TYPEMASK_UNIT | TYPEMASK_GAMEOBJECT);
 
     if (!object)
         return;
 
     if (autoCompleteMode == 0)
     {
         if (!object->hasInvolvedQuest(packet.QuestID))
             return;
 
         // some kind of WPE protection
         if (!_player->CanInteractWithQuestGiver(object))
             return;
     }
     else
     {
         // Do not allow completing quests on other players.
         if (packet.QuestGiverGUID != _player->GetGUID())
             return;
     }
 
     if (!_player->CanSeeStartQuest(quest) && _player->GetQuestStatus(packet.QuestID) == QUEST_STATUS_NONE)
     {
         TC_LOG_ERROR("network", "Possible hacking attempt: Player %s [%s] tried to complete quest [entry: %u] without being in possession of the quest!",
             _player->GetName().c_str(), _player->GetGUID().ToString().c_str(), packet.QuestID);
         return;
     }
 
     if (Battleground* bg = _player->GetBattleground())
         bg->HandleQuestComplete(packet.QuestID, _player);
 
     if (_player->GetQuestStatus(packet.QuestID) != QUEST_STATUS_COMPLETE)
     {
         if (quest->IsRepeatable())
             _player->PlayerTalkClass->SendQuestGiverRequestItems(quest, packet.QuestGiverGUID, _player->CanCompleteRepeatableQuest(quest), false);
         else
             _player->PlayerTalkClass->SendQuestGiverRequestItems(quest, packet.QuestGiverGUID, _player->CanRewardQuest(quest, false), false);
     }
     else
     {
         if (quest->HasSpecialFlag(QUEST_SPECIAL_FLAGS_DELIVER))                  // some items required
             _player->PlayerTalkClass->SendQuestGiverRequestItems(quest, packet.QuestGiverGUID, _player->CanRewardQuest(quest, false), false);
         else                                            // no items required
             _player->PlayerTalkClass->SendQuestGiverOfferReward(quest, packet.QuestGiverGUID, true);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     TC_LOG_DEBUG("network", "WORLD: Received CMSG_QUESTGIVER_HELLO %s", packet.QuestGiverGUID.ToString().c_str());
 
     Creature* creature = GetPlayer()->GetNPCIfCanInteractWith(packet.QuestGiverGUID, UNIT_NPC_FLAG_QUESTGIVER);
     if (!creature)
     {
         TC_LOG_DEBUG("network", "WORLD: HandleQuestgiverHelloOpcode - %s not found or you can't interact with him.",
             packet.QuestGiverGUID.ToString().c_str());
         return;
     }
 
     // remove fake death
     if (GetPlayer()->HasUnitState(UNIT_STATE_DIED))
         GetPlayer()->RemoveAurasByType(SPELL_AURA_FEIGN_DEATH);
     // Stop the npc if moving
     creature->StopMoving();
 
     if (sScriptMgr->OnGossipHello(_player, creature))
         return;
 
     _player->PrepareGossipMenu(creature, creature->GetCreatureTemplate()->GossipMenuId, true);
     _player->SendPreparedGossip(creature);
 
     creature->AI()->sGossipHello(_player);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     TC_LOG_DEBUG("network", "WORLD: Received CMSG_QUESTGIVER_QUERY_QUEST QuestGiverGUID = %s, QuestID = %u, RespondToGiver = %u", packet.QuestGiverGUID.ToString().c_str(), packet.QuestID, packet.RespondToGiver);
 
     // Verify that the guid is valid and is a questgiver or involved in the requested quest
     Object* object = ObjectAccessor::GetObjectByTypeMask(*_player, packet.QuestGiverGUID, TYPEMASK_UNIT | TYPEMASK_GAMEOBJECT | TYPEMASK_ITEM);
     if (!object || (!object->hasQuest(packet.QuestID) && !object->hasInvolvedQuest(packet.QuestID)))
     {
         _player->PlayerTalkClass->SendCloseGossip();
         return;
     }
 
     if (Quest const* quest = sObjectMgr->GetQuestTemplate(packet.QuestID))
     {
         if (!_player->CanTakeQuest(quest, true))
             return;
 
         if (quest->IsAutoAccept() && _player->CanAddQuest(quest, true))
             _player->AddQuestAndCheckCompletion(quest, object);
 
         if (quest->IsAutoComplete())
             _player->PlayerTalkClass->SendQuestGiverRequestItems(quest, object->GetGUID(), _player->CanCompleteQuest(quest->GetQuestId()), true);
         else
             _player->PlayerTalkClass->SendQuestGiverQuestDetails(quest, object->GetGUID(), true);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleQuestgiverQuestAutoLaunch ( WorldPacket & recvPacket )

560 {

561 }

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

 {
     TC_LOG_DEBUG("network", "WORLD: Received CMSG_QUESTGIVER_REQUEST_REWARD npc = %s, quest = %u", packet.QuestGiverGUID.ToString().c_str(), packet.QuestID);
 
     Object* object = ObjectAccessor::GetObjectByTypeMask(*_player, packet.QuestGiverGUID, TYPEMASK_UNIT | TYPEMASK_GAMEOBJECT);
     if (!object || !object->hasInvolvedQuest(packet.QuestID))
         return;
 
     // some kind of WPE protection
     if (!_player->CanInteractWithQuestGiver(object))
         return;
 
     if (_player->CanCompleteQuest(packet.QuestID))
         _player->CompleteQuest(packet.QuestID);
 
     if (_player->GetQuestStatus(packet.QuestID) != QUEST_STATUS_COMPLETE)
         return;
 
     if (Quest const* quest = sObjectMgr->GetQuestTemplate(packet.QuestID))
         _player->PlayerTalkClass->SendQuestGiverOfferReward(quest, packet.QuestGiverGUID, true);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     WorldPackets::Quest::QuestGiverStatusMultiple response;
 
     for (auto itr = _player->m_clientGUIDs.begin(); itr != _player->m_clientGUIDs.end(); ++itr)
     {
         if (itr->IsAnyTypeCreature())
         {
             // need also pet quests case support
             Creature* questgiver = ObjectAccessor::GetCreatureOrPetOrVehicle(*GetPlayer(), *itr);
             if (!questgiver || questgiver->IsHostileTo(_player))
                 continue;
             if (!questgiver->HasFlag64(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_QUESTGIVER))
                 continue;
 
             response.QuestGiver.emplace_back(questgiver->GetGUID(), _player->GetQuestDialogStatus(questgiver));
         }
         else if (itr->IsGameObject())
         {
             GameObject* questgiver = GetPlayer()->GetMap()->GetGameObject(*itr);
             if (!questgiver || questgiver->GetGoType() != GAMEOBJECT_TYPE_QUESTGIVER)
                 continue;
 
             response.QuestGiver.emplace_back(questgiver->GetGUID(), _player->GetQuestDialogStatus(questgiver));
         }
     }
 
     SendPacket(response.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     uint32 questStatus = DIALOG_STATUS_NONE;
 
     Object* questGiver = ObjectAccessor::GetObjectByTypeMask(*_player, packet.QuestGiverGUID, TYPEMASK_UNIT | TYPEMASK_GAMEOBJECT);
     if (!questGiver)
     {
         TC_LOG_INFO("network", "Error in CMSG_QUESTGIVER_STATUS_QUERY, called for non-existing questgiver (%s)", packet.QuestGiverGUID.ToString().c_str());
         return;
     }
 
     switch (questGiver->GetTypeId())
     {
         case TYPEID_UNIT:
         {
             TC_LOG_DEBUG("network", "WORLD: Received CMSG_QUESTGIVER_STATUS_QUERY for npc, %s", questGiver->GetGUID().ToString().c_str());
             if (!questGiver->ToCreature()->IsHostileTo(_player)) // do not show quest status to enemies
                 questStatus = _player->GetQuestDialogStatus(questGiver);
             break;
         }
         case TYPEID_GAMEOBJECT:
         {
             TC_LOG_DEBUG("network", "WORLD: Received CMSG_QUESTGIVER_STATUS_QUERY for GameObject %s", questGiver->GetGUID().ToString().c_str());
             questStatus = _player->GetQuestDialogStatus(questGiver);
             break;
         }
         default:
             TC_LOG_ERROR("network", "QuestGiver called for unexpected type %u", questGiver->GetTypeId());
             break;
     }
 
     //inform client about status of quest
     _player->PlayerTalkClass->SendQuestGiverStatus(questStatus, packet.QuestGiverGUID);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     TC_LOG_DEBUG("network", "WORLD: Received CMSG_QUESTLOG_REMOVE_QUEST slot = %u", packet.Entry);
 
     if (packet.Entry < MAX_QUEST_LOG_SIZE)
     {
         if (uint32 questId = _player->GetQuestSlotQuestId(packet.Entry))
         {
             if (!_player->TakeQuestSourceItem(questId, true))
                 return;                                     // can't un-equip some items, reject quest cancel
 
             if (Quest const* quest = sObjectMgr->GetQuestTemplate(questId))
             {
                 if (quest->HasSpecialFlag(QUEST_SPECIAL_FLAGS_TIMED))
                     _player->RemoveTimedQuest(questId);
 
                 if (quest->HasFlag(QUEST_FLAGS_FLAGS_PVP))
                 {
                     _player->pvpInfo.IsHostile = _player->pvpInfo.IsInHostileArea || _player->HasPvPForcingQuest();
                     _player->UpdatePvPState();
                 }
             }
 
             _player->TakeQuestSourceItem(questId, true); // remove quest src item from player
             _player->RemoveActiveQuest(questId);
             _player->RemoveTimedAchievement(ACHIEVEMENT_TIMED_TYPE_QUEST, questId);
 
             TC_LOG_INFO("network", "%s abandoned quest %u", _player->GetGUID().ToString().c_str(), questId);
 
             if (sWorld->getBoolConfig(CONFIG_QUEST_ENABLE_QUEST_TRACKER)) // check if Quest Tracker is enabled
             {
                 // prepare Quest Tracker datas
                 PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_QUEST_TRACK_ABANDON_TIME);
                 stmt->setUInt32(0, questId);
                 stmt->setUInt64(1, _player->GetGUID().GetCounter());
 
                 // add to Quest Tracker
                 CharacterDatabase.Execute(stmt);
             }
         }
 
         _player->SetQuestSlot(packet.Entry, 0);
 
         _player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_QUEST_ABANDONED, 1);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (questPoiQuery.MissingQuestCount > MAX_QUEST_LOG_SIZE)
         return;
 
     // Read quest ids and add the in a unordered_set so we don't send POIs for the same quest multiple times
     std::unordered_set<int32> questIds;
     for (int32 i = 0; i < questPoiQuery.MissingQuestCount; ++i)
         questIds.insert(questPoiQuery.MissingQuestPOIs[i]); // QuestID
 
     WorldPackets::Query::QuestPOIQueryResponse response;
 
     for (auto itr = questIds.begin(); itr != questIds.end(); ++itr)
     {
         int32 QuestID = *itr;
 
         bool questOk = false;
 
         uint16 questSlot = _player->FindQuestSlot(uint32(QuestID));
 
         if (questSlot != MAX_QUEST_LOG_SIZE)
             questOk = _player->GetQuestSlotQuestId(questSlot) == uint32(QuestID);
 
         if (questOk)
         {
             QuestPOIVector const* poiData = sObjectMgr->GetQuestPOIVector(QuestID);
             if (poiData)
             {
                 WorldPackets::Query::QuestPOIData questPOIData;
 
                 questPOIData.QuestID = QuestID;
 
                 for (auto data = poiData->begin(); data != poiData->end(); ++data)
                 {
                     WorldPackets::Query::QuestPOIBlobData questPOIBlobData;
 
                     questPOIBlobData.BlobIndex          = data->BlobIndex;
                     questPOIBlobData.ObjectiveIndex     = data->ObjectiveIndex;
                     questPOIBlobData.QuestObjectiveID   = data->QuestObjectiveID;
                     questPOIBlobData.QuestObjectID      = data->QuestObjectID;
                     questPOIBlobData.MapID              = data->MapID;
                     questPOIBlobData.WorldMapAreaID     = data->WorldMapAreaID;
                     questPOIBlobData.Floor              = data->Floor;
                     questPOIBlobData.Priority           = data->Priority;
                     questPOIBlobData.Flags              = data->Flags;
                     questPOIBlobData.WorldEffectID      = data->WorldEffectID;
                     questPOIBlobData.PlayerConditionID  = data->PlayerConditionID;
                     questPOIBlobData.UnkWoD1            = data->UnkWoD1;
 
                     for (auto points = data->points.begin(); points != data->points.end(); ++points)
                     {
                         WorldPackets::Query::QuestPOIBlobPoint questPOIBlobPoint;
 
                         questPOIBlobPoint.X = points->X;
                         questPOIBlobPoint.Y = points->Y;
 
                         TC_LOG_ERROR("misc", "Quest: %i BlobIndex: %i X/Y: %i/%i", QuestID, data->BlobIndex, points->X, points->Y);
 
                         questPOIBlobData.QuestPOIBlobPointStats.push_back(questPOIBlobPoint);
                     }
 
                     questPOIData.QuestPOIBlobDataStats.push_back(questPOIBlobData);
                 }
 
                 response.QuestPOIDataStats.push_back(questPOIData);
             }
         }
     }
 
     SendPacket(response.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (!_player->GetDivider().IsEmpty())
     {
         if (_player->GetDivider() == packet.SenderGUID)
             if (Player* player = ObjectAccessor::FindPlayer(_player->GetDivider()))
                 player->SendPushToPartyResponse(_player, static_cast<QuestPushReason>(packet.Result));
 
         _player->SetDivider(ObjectGuid::Empty);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (!_player)
         return;
 
     TC_LOG_DEBUG("network", "WORLD: Received CMSG_QUEST_QUERY quest = %u", packet.QuestID);
 
     if (Quest const* quest = sObjectMgr->GetQuestTemplate(packet.QuestID))
         _player->PlayerTalkClass->SendQuestQueryResponse(quest);
 }

Here is the caller graph for this function:

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

 {
     if (!Player::IsValidRace(packet.Race))
     {
         TC_LOG_ERROR("misc", "Invalid race (%u) sent by accountId: %u", packet.Race, GetAccountId());
         return;
     }
 
     if (!Player::IsValidGender(packet.Sex))
     {
         TC_LOG_ERROR("misc", "Invalid gender (%u) sent by accountId: %u", packet.Sex, GetAccountId());
         return;
     }
 
     WorldPackets::Character::GenerateRandomCharacterNameResult result;
     result.Success = true;
     result.Name = sDB2Manager.GetNameGenEntry(packet.Race, packet.Sex, GetSessionDbcLocale());
 
     SendPacket(result.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

error handling

 {
     uint32 minimum, maximum, roll;
     minimum = packet.Min;
     maximum = packet.Max;
 
     if (minimum > maximum || maximum > 10000)                // < 32768 for urand call
         return;
     /********************/
 
     // everything's fine, do it
     roll = urand(minimum, maximum);
 
     WorldPackets::Misc::RandomRoll randomRoll;
     randomRoll.Min = minimum;
     randomRoll.Max = maximum;
     randomRoll.Result = roll;
     randomRoll.Roller = GetPlayer()->GetGUID();
     randomRoll.RollerWowAccount = GetAccountGUID();
     if (GetPlayer()->GetGroup())
         GetPlayer()->GetGroup()->BroadcastPacket(randomRoll.Write(), false);
     else
         SendPacket(randomRoll.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Todo:: : 6.x research new values

 {
     Item* item = _player->GetItemByPos(readItem.PackSlot, readItem.Slot);
     if (item && item->GetTemplate()->GetPageText())
     {
         InventoryResult msg = _player->CanUseItem(item);
         if (msg == EQUIP_ERR_OK)
         {
             WorldPackets::Item::ReadItemResultOK packet;
             packet.Item = item->GetGUID();
             SendPacket(packet.Write());
 
             TC_LOG_INFO("network", "STORAGE: Item page sent");
         }
         else
         {
             /*WorldPackets::Item::ReadItemResultFailed packet;
             packet.Item = item->GetGUID();
             packet.Subcode = ??;
             packet.Delay = ??;
             SendPacket(packet.Write());*/
 
             TC_LOG_INFO("network", "STORAGE: Unable to read item");
             _player->SendEquipError(msg, item, NULL);
         }
     }
     else
         _player->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, NULL, NULL);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     Group* group = GetPlayer()->GetGroup();
     if (!group)
         return;
 
     // everything's fine, do it
     group->SetMemberReadyCheck(GetPlayer()->GetGUID(), packet.IsReady);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (_player->IsAlive())
         return;
 
     // do not allow corpse reclaim in arena
     if (_player->InArena())
         return;
 
     // body not released yet
     if (!_player->HasFlag(PLAYER_FLAGS, PLAYER_FLAGS_GHOST))
         return;
 
     Corpse* corpse = _player->GetCorpse();
     if (!corpse)
         return;
 
     // prevent resurrect before 30-sec delay after body release not finished
     if (time_t(corpse->GetGhostTime() + _player->GetCorpseReclaimDelay(corpse->GetType() == CORPSE_RESURRECTABLE_PVP)) > time_t(time(NULL)))
         return;
 
     if (!corpse->IsWithinDistInMap(_player, CORPSE_RECLAIM_RADIUS, true))
         return;
 
     // resurrect
     _player->ResurrectPlayer(_player->InBattleground() ? 1.0f : 0.5f);
 
     // spawn bones
     _player->SpawnCorpseBones();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleRemoveGlyph ( WorldPacket & recvData )

 {
     uint32 slot;
     recvData >> slot;
 
     if (slot >= MAX_GLYPH_SLOT_INDEX)
     {
         TC_LOG_DEBUG("network", "Client sent wrong glyph slot number in opcode CMSG_REMOVE_GLYPH %u", slot);
         return;
     }
 
     if (uint32 glyph = _player->GetGlyph(_player->GetActiveTalentGroup(), slot))
     {
         if (GlyphPropertiesEntry const* gp = sGlyphPropertiesStore.LookupEntry(glyph))
         {
             _player->RemoveAurasDueToSpell(gp->SpellID);
             _player->SetGlyph(slot, 0);
             _player->SendTalentsInfoData();
         }
     }
 }

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

 {
     SQLTransaction trans = CharacterDatabase.BeginTransaction();
 
     for (WorldPackets::Character::ReorderCharacters::ReorderInfo const& reorderInfo : reorderChars.Entries)
     {
         PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_CHAR_LIST_SLOT);
         stmt->setUInt8(0, reorderInfo.NewPosition);
         stmt->setUInt64(1, reorderInfo.PlayerGUID.GetCounter());
         stmt->setUInt32(2, GetAccountId());
         trans->Append(stmt);
     }
 
     CharacterDatabase.CommitTransaction(trans);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     TC_LOG_DEBUG("network", "WORLD: CMSG_REPAIR_ITEM: Npc %s, Item %s, UseGuildBank: %u",
         packet.NpcGUID.ToString().c_str(), packet.ItemGUID.ToString().c_str(), packet.UseGuildBank);
 
     Creature* unit = GetPlayer()->GetNPCIfCanInteractWith(packet.NpcGUID, UNIT_NPC_FLAG_REPAIR);
     if (!unit)
     {
         TC_LOG_DEBUG("network", "WORLD: HandleRepairItemOpcode - %s not found or you can not interact with him.", packet.NpcGUID.ToString().c_str());
         return;
     }
 
     // remove fake death
     if (GetPlayer()->HasUnitState(UNIT_STATE_DIED))
         GetPlayer()->RemoveAurasByType(SPELL_AURA_FEIGN_DEATH);
 
     // reputation discount
     float discountMod = _player->GetReputationPriceDiscount(unit);
 
     if (!packet.ItemGUID.IsEmpty())
     {
         TC_LOG_DEBUG("network", "ITEM: Repair %s, at %s", packet.ItemGUID.ToString().c_str(), packet.NpcGUID.ToString().c_str());
 
         Item* item = _player->GetItemByGuid(packet.ItemGUID);
         if (item)
             _player->DurabilityRepair(item->GetPos(), true, discountMod, packet.UseGuildBank);
     }
     else
     {
         TC_LOG_DEBUG("network", "ITEM: Repair all items at %s", packet.NpcGUID.ToString().c_str());
         _player->DurabilityRepairAll(true, discountMod, packet.UseGuildBank);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleReplicateItems ( WorldPackets::AuctionHouse::AuctionReplicateItems & packet )

 {
     //@todo implement this properly
     WorldPackets::AuctionHouse::AuctionReplicateResponse response;
     response.ChangeNumberCursor = packet.ChangeNumberCursor;
     response.ChangeNumberGlobal = packet.ChangeNumberGlobal;
     response.ChangeNumberTombstone = packet.ChangeNumberTombstone;
     response.DesiredDelay = 300;
     response.Result = 0;
     SendPacket(response.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (GetPlayer()->IsAlive() || GetPlayer()->HasFlag(PLAYER_FLAGS, PLAYER_FLAGS_GHOST))
         return;
 
     if (GetPlayer()->HasAuraType(SPELL_AURA_PREVENT_RESURRECTION))
         return; // silently return, client should display the error by itself
 
     // the world update order is sessions, players, creatures
     // the netcode runs in parallel with all of these
     // creatures can kill players
     // so if the server is lagging enough the player can
     // release spirit after he's killed but before he is updated
     if (GetPlayer()->getDeathState() == JUST_DIED)
     {
         TC_LOG_DEBUG("network", "HandleRepopRequestOpcode: got request after player %s(%s) was killed and before he was updated",
             GetPlayer()->GetName().c_str(), GetPlayer()->GetGUID().ToString().c_str());
         GetPlayer()->KillPlayer();
     }
 
     //this is spirit release confirm?
     GetPlayer()->RemovePet(NULL, PET_SAVE_NOT_IN_SLOT, true);
     GetPlayer()->BuildPlayerRepop();
     GetPlayer()->RepopAtGraveyard();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     Player* reportedPlayer = ObjectAccessor::FindPlayer(reportPvPPlayerAFK.Offender);
     if (!reportedPlayer)
     {
         TC_LOG_DEBUG("bg.battleground", "WorldSession::HandleReportPvPAFK: player not found");
         return;
     }
 
     TC_LOG_DEBUG("bg.battleground", "WorldSession::HandleReportPvPAFK: %s reported %s", _player->GetName().c_str(), reportedPlayer->GetName().c_str());
 
     reportedPlayer->ReportedAfkBy(_player);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     TC_LOG_DEBUG("network", "WORLD: Received CMSG_REQUEST_ACCOUNT_DATA: type %u", request.DataType);
 
     if (request.DataType >= NUM_ACCOUNT_DATA_TYPES)
         return;
 
     AccountData const* adata = GetAccountData(AccountDataType(request.DataType));
 
     WorldPackets::ClientConfig::UpdateAccountData data;
     data.Player = _player ? _player->GetGUID() : ObjectGuid::Empty;
     data.Time = adata->Time;
     data.Size = adata->Data.size();
     data.DataType = request.DataType;
 
     uLongf destSize = compressBound(data.Size);
 
     data.CompressedData.resize(destSize);
 
     if (data.Size && compress(data.CompressedData.contents(), &destSize, (uint8 const*)adata->Data.c_str(), data.Size) != Z_OK)
     {
         TC_LOG_ERROR("network", "RAD: Failed to compress account data");
         return;
     }
 
     data.CompressedData.resize(destSize);
 
     SendPacket(data.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     // we must update all queues here
     Battleground* bg = NULL;
     for (uint8 i = 0; i < PLAYER_MAX_BATTLEGROUND_QUEUES; ++i)
     {
         BattlegroundQueueTypeId bgQueueTypeId = _player->GetBattlegroundQueueTypeId(i);
         if (!bgQueueTypeId)
             continue;
         BattlegroundTypeId bgTypeId = BattlegroundMgr::BGTemplateId(bgQueueTypeId);
         uint8 arenaType = BattlegroundMgr::BGArenaType(bgQueueTypeId);
         if (bgTypeId == _player->GetBattlegroundTypeId())
         {
             bg = _player->GetBattleground();
             //i cannot check any variable from player class because player class doesn't know if player is in 2v2 / 3v3 or 5v5 arena
             //so i must use bg pointer to get that information
             if (bg && bg->GetArenaType() == arenaType)
             {
                 WorldPackets::Battleground::BattlefieldStatusActive battlefieldStatus;
                 sBattlegroundMgr->BuildBattlegroundStatusActive(&battlefieldStatus, bg, _player, i, _player->GetBattlegroundQueueJoinTime(bgQueueTypeId), arenaType);
                 SendPacket(battlefieldStatus.Write());
                 continue;
             }
         }
 
         //we are sending update to player about queue - he can be invited there!
         //get GroupQueueInfo for queue status
         BattlegroundQueue& bgQueue = sBattlegroundMgr->GetBattlegroundQueue(bgQueueTypeId);
         GroupQueueInfo ginfo;
         if (!bgQueue.GetPlayerGroupInfoData(_player->GetGUID(), &ginfo))
             continue;
         if (ginfo.IsInvitedToBGInstanceGUID)
         {
             bg = sBattlegroundMgr->GetBattleground(ginfo.IsInvitedToBGInstanceGUID, bgTypeId);
             if (!bg)
                 continue;
 
 
             WorldPackets::Battleground::BattlefieldStatusNeedConfirmation battlefieldStatus;
             sBattlegroundMgr->BuildBattlegroundStatusNeedConfirmation(&battlefieldStatus, bg, _player, i, _player->GetBattlegroundQueueJoinTime(bgQueueTypeId), getMSTimeDiff(getMSTime(), ginfo.RemoveInviteTime), arenaType);
             SendPacket(battlefieldStatus.Write());
         }
         else
         {
             bg = sBattlegroundMgr->GetBattlegroundTemplate(bgTypeId);
             if (!bg)
                 continue;
 
             // expected bracket entry
             PvPDifficultyEntry const* bracketEntry = GetBattlegroundBracketByLevel(bg->GetMapId(), _player->getLevel());
             if (!bracketEntry)
                 continue;
 
             uint32 avgTime = bgQueue.GetAverageQueueWaitTime(&ginfo, bracketEntry->GetBracketId());
             WorldPackets::Battleground::BattlefieldStatusQueued battlefieldStatus;
             sBattlegroundMgr->BuildBattlegroundStatusQueued(&battlefieldStatus, bg, _player, i, _player->GetBattlegroundQueueJoinTime(bgQueueTypeId), avgTime, arenaType, ginfo.Players.size() > 1);
             SendPacket(battlefieldStatus.Write());
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     _player->SendSpellCategoryCooldowns();
 }

Here is the caller graph for this function:

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

 {
     uint32 zoneId = _player->GetZoneId();
     uint32 team = _player->GetTeam();
 
     std::vector<uint32> graveyardIds;
     auto range = sObjectMgr->GraveYardStore.equal_range(zoneId);
 
     for (auto it = range.first; it != range.second && graveyardIds.size() < 16; ++it) // client max
     {
         if (it->second.team == 0 || it->second.team == team)
             graveyardIds.push_back(it->first);
     }
 
     if (graveyardIds.empty())
     {
         TC_LOG_DEBUG("network", "No graveyards found for zone %u for %s (team %u) in CMSG_REQUEST_CEMETERY_LIST",
             zoneId, _player->GetGUID().ToString().c_str(), team);
         return;
     }
 
     WorldPackets::Misc::RequestCemeteryListResponse packet;
     packet.IsGossipTriggered = false;
     packet.CemeteryID.reserve(graveyardIds.size());
 
     for (uint32 id : graveyardIds)
         packet.CemeteryID.push_back(id);
 
     SendPacket(packet.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     _player->GetReputationMgr().SendForceReactions();
 }

Here is the caller graph for this function:

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

 {
     if (sGuildMgr->GetGuildById(_player->GetGuildId()))
     {
         std::vector<GuildReward> const& rewards = sGuildMgr->GetGuildRewards();
 
         WorldPackets::Guild::GuildRewardList rewardList;
         rewardList.Version = uint32(time(NULL));
         rewardList.RewardItems.reserve(rewards.size());
 
         for (uint32 i = 0; i < rewards.size(); i++)
         {
             WorldPackets::Guild::GuildRewardItem rewardItem;
             rewardItem.ItemID = rewards[i].ItemID;
             rewardItem.RaceMask = rewards[i].RaceMask;
             rewardItem.MinGuildLevel = 0;
             rewardItem.MinGuildRep = rewards[i].MinGuildRep;
             rewardItem.AchievementsRequired = rewards[i].AchievementsRequired;
             rewardItem.Cost = rewards[i].Cost;
             rewardList.RewardItems.push_back(rewardItem);
         }
 
         SendPacket(rewardList.Write());
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleRequestHonorStatsOpcode ( WorldPackets::Inspect::RequestHonorStats & request )

Todo:

 {
     Player* player = ObjectAccessor::FindPlayer(request.TargetGUID);
     if (!player)
     {
         TC_LOG_DEBUG("network", "WorldSession::HandleRequestHonorStatsOpcode: Target %s not found.", request.TargetGUID.ToString().c_str());
         return;
     }
 
     TC_LOG_DEBUG("network", "WorldSession::HandleRequestHonorStatsOpcode: Target %s.", request.TargetGUID.ToString().c_str());
 
     if (!GetPlayer()->IsWithinDistInMap(player, INSPECT_DISTANCE, false))
         return;
 
     if (GetPlayer()->IsValidAttackTarget(player))
         return;
 
     WorldPackets::Inspect::InspectHonorStats honorStats;
     honorStats.PlayerGUID  = request.TargetGUID;
     honorStats.LifetimeHK  = player->GetUInt32Value(PLAYER_FIELD_LIFETIME_HONORABLE_KILLS);
     honorStats.YesterdayHK = player->GetUInt16Value(PLAYER_FIELD_KILLS, PLAYER_FIELD_KILLS_OFFSET_YESTERDAY_KILLS);
     honorStats.TodayHK     = player->GetUInt16Value(PLAYER_FIELD_KILLS, PLAYER_FIELD_KILLS_OFFSET_TODAY_KILLS);
     honorStats.LifetimeMaxRank = 0; 
 
     SendPacket(honorStats.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     Group* group = GetPlayer()->GetGroup();
     if (!group)
         return;
 
     group->SendTargetIconList(this, packet.PartyIndex);
     group->SendRaidMarkersChanged(this, packet.PartyIndex);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     WorldPackets::Party::PartyMemberStats partyMemberStats;
 
     Player* player = ObjectAccessor::FindConnectedPlayer(packet.TargetGUID);
     if (!player)
     {
         partyMemberStats.MemberStats.GUID = packet.TargetGUID;
         partyMemberStats.MemberStats.Status = MEMBER_STATUS_OFFLINE;
     }
     else
         partyMemberStats.Initialize(player);
 
     SendPacket(partyMemberStats.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleRequestPetInfo ( WorldPackets::Pet::RequestPetInfo & packet )

60 {

61 }

Here is the caller graph for this function:

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

 {
     _player->SendPvpRewards();
 }

Here is the caller graph for this function:

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

 {
     // every time the player checks the character screen
     _player->SendRaidInfo();
 }

Here is the caller graph for this function:

void WorldSession::HandleRequestRatedBattlefieldInfo ( WorldPackets::Battleground::RequestRatedBattlefieldInfo & packet )

: perfome research in this case The unk fields are related to arenas

 {
     WorldPacket data(SMSG_RATED_BATTLEFIELD_INFO, 72);
     data << uint32(0);      // BgWeeklyWins20vs20
     data << uint32(0);      // BgWeeklyPlayed20vs20
     data << uint32(0);      // BgWeeklyPlayed15vs15
     data << uint32(0);
     data << uint32(0);      // BgWeeklyWins10vs10
     data << uint32(0);
     data << uint32(0);
     data << uint32(0);
     data << uint32(0);      // BgWeeklyWins15vs15
     data << uint32(0);
     data << uint32(0);
     data << uint32(0);
     data << uint32(0);
     data << uint32(0);
     data << uint32(0);
     data << uint32(0);      // BgWeeklyPlayed10vs10
     data << uint32(0);
     data << uint32(0);
 
     SendPacket(&data);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (!CheckStableMaster(packet.StableMaster))
         return;
 
     // remove fake death
     if (GetPlayer()->HasUnitState(UNIT_STATE_DIED))
         GetPlayer()->RemoveAurasByType(SPELL_AURA_FEIGN_DEATH);
 
     // remove mounts this fix bug where getting pet from stable while mounted deletes pet.
     if (GetPlayer()->IsMounted())
         GetPlayer()->RemoveAurasByType(SPELL_AURA_MOUNTED);
 
     SendStablePet(packet.StableMaster);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (Vehicle* vehicle = GetPlayer()->GetVehicle())
     {
         if (VehicleSeatEntry const* seat = vehicle->GetSeatForPassenger(GetPlayer()))
         {
             if (seat->CanEnterOrExit())
                 GetPlayer()->ExitVehicle();
             else
                 TC_LOG_ERROR("network", "%s tried to exit vehicle, but seatflags %u (ID: %u) don't permit that.",
                     GetPlayer()->GetGUID().ToString().c_str(), seat->ID, seat->Flags);
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     Unit* vehicle_base = GetPlayer()->GetVehicleBase();
     if (!vehicle_base)
         return;
 
     VehicleSeatEntry const* seat = GetPlayer()->GetVehicle()->GetSeatForPassenger(GetPlayer());
     if (!seat->CanSwitchFromSeat())
     {
         TC_LOG_ERROR("network", "HandleRequestVehicleNextSeat: %s tried to switch seats but current seatflags %u don't permit that.",
             GetPlayer()->GetGUID().ToString().c_str(), seat->Flags);
         return;
     }
 
     GetPlayer()->ChangeSeat(-1, true);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     Unit* vehicle_base = GetPlayer()->GetVehicleBase();
     if (!vehicle_base)
         return;
 
     VehicleSeatEntry const* seat = GetPlayer()->GetVehicle()->GetSeatForPassenger(GetPlayer());
     if (!seat->CanSwitchFromSeat())
     {
         TC_LOG_ERROR("network", "HandleRequestVehiclePrevSeat: %s tried to switch seats but current seatflags %u don't permit that.",
             GetPlayer()->GetGUID().ToString().c_str(), seat->Flags);
         return;
     }
 
     GetPlayer()->ChangeSeat(-1, false);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     Unit* vehicle_base = GetPlayer()->GetVehicleBase();
     if (!vehicle_base)
         return;
 
     VehicleSeatEntry const* seat = GetPlayer()->GetVehicle()->GetSeatForPassenger(GetPlayer());
     if (!seat->CanSwitchFromSeat())
     {
         TC_LOG_ERROR("network", "HandleRequestVehicleSwitchSeat: %s tried to switch seats but current seatflags %u don't permit that.",
             GetPlayer()->GetGUID().ToString().c_str(), seat->Flags);
         return;
     }
 
     if (vehicle_base->GetGUID() == requestVehicleSwitchSeat.Vehicle)
         GetPlayer()->ChangeSeat(int8(requestVehicleSwitchSeat.SeatIndex));
     else if (Unit* vehUnit = ObjectAccessor::GetUnit(*GetPlayer(), requestVehicleSwitchSeat.Vehicle))
         if (Vehicle* vehicle = vehUnit->GetVehicleKit())
             if (vehicle->HasEmptySeat(int8(requestVehicleSwitchSeat.SeatIndex)))
                 vehUnit->HandleSpellClick(GetPlayer(), int8(requestVehicleSwitchSeat.SeatIndex));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleRequestWowTokenMarketPrice ( WorldPackets::Token::RequestWowTokenMarketPrice & requestWowTokenMarketPrice )

Todo:: : 6.x fix implementation

 {
     WorldPackets::Token::WowTokenMarketPriceResponse response;
 
     response.CurrentMarketPrice = 300000000;
     response.UnkInt = requestWowTokenMarketPrice.UnkInt;
     response.Result = TOKEN_RESULT_SUCCESS;
     //packet.ReadUInt32("UnkInt32");
 
     SendPacket(response.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (Group* group = _player->GetGroup())
     {
         if (group->IsLeader(_player->GetGUID()))
             group->ResetInstances(INSTANCE_RESET_ALL, false, false, _player);
     }
     else
         _player->ResetInstances(INSTANCE_RESET_ALL, false, false);
 }

Here is the caller graph for this function:

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

 {
     if (GetPlayer()->IsAlive())
         return;
 
     if (packet.Response != 0) // Accept = 0 Decline = 1 Timeout = 2
     {
         GetPlayer()->ClearResurrectRequestData();           // reject
         return;
     }
 
     if (!GetPlayer()->IsResurrectRequestedBy(packet.Resurrecter))
         return;
 
     GetPlayer()->ResurrectUsingRequestData();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (Player* player = ObjectAccessor::FindPlayer(rideVehicleInteract.Vehicle))
     {
         if (!player->GetVehicleKit())
             return;
         if (!player->IsInRaidWith(_player))
             return;
         if (!player->IsWithinDistInMap(_player, INTERACTION_DISTANCE))
             return;
 
         _player->EnterVehicle(player);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (packet.CUFProfiles.size() > MAX_CUF_PROFILES)
     {
         TC_LOG_ERROR("entities.player", "HandleSaveCUFProfiles - %s tried to save more than %i CUF profiles. Hacking attempt?", GetPlayerName().c_str(), MAX_CUF_PROFILES);
         return;
     }
 
     for (uint8 i = 0; i < packet.CUFProfiles.size(); ++i)
         GetPlayer()->SaveCUFProfile(i, std::move(packet.CUFProfiles[i]));
 
     for (uint8 i = packet.CUFProfiles.size(); i < MAX_CUF_PROFILES; ++i)
         GetPlayer()->SaveCUFProfile(i, nullptr);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     EmblemInfo emblemInfo;
     emblemInfo.ReadPacket(packet);
 
     TC_LOG_DEBUG("guild", "CMSG_SAVE_GUILD_EMBLEM [%s]: Guid: [%s] Style: %d, Color: %d, BorderStyle: %d, BorderColor: %d, BackgroundColor: %d"
         , GetPlayerInfo().c_str(), packet.Vendor.ToString().c_str(), emblemInfo.GetStyle()
         , emblemInfo.GetColor(), emblemInfo.GetBorderStyle()
         , emblemInfo.GetBorderColor(), emblemInfo.GetBackgroundColor());
 
     if (GetPlayer()->GetNPCIfCanInteractWith(packet.Vendor, UNIT_NPC_FLAG_TABARDDESIGNER))
     {
         // Remove fake death
         if (GetPlayer()->HasUnitState(UNIT_STATE_DIED))
             GetPlayer()->RemoveAurasByType(SPELL_AURA_FEIGN_DEATH);
 
         if (!emblemInfo.ValidateEmblemColors())
         {
             Guild::SendSaveEmblemResult(this, ERR_GUILDEMBLEM_INVALID_TABARD_COLORS);
             return;
         }
 
         if (Guild* guild = GetPlayer()->GetGuild())
             guild->HandleSetEmblem(this, emblemInfo);
         else
             Guild::SendSaveEmblemResult(this, ERR_GUILDEMBLEM_NOGUILD); // "You are not part of a guild!";
     }
     else
         Guild::SendSaveEmblemResult(this, ERR_GUILDEMBLEM_INVALIDVENDOR); // "That's not an emblem vendor!"
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     TC_LOG_DEBUG("scenes", "HandleScenePlaybackCanceled: SceneInstanceID: %u", scenePlaybackCanceled.SceneInstanceID);
 }

Here is the caller graph for this function:

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

 {
 
     TC_LOG_DEBUG("scenes", "HandleScenePlaybackComplete: SceneInstanceID: %u", scenePlaybackComplete.SceneInstanceID);
 }

Here is the caller graph for this function:

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

 {
     TC_LOG_DEBUG("scenes", "HandleSceneTriggerEvent: SceneInstanceID: %u Event: %s", sceneTriggerEvent.SceneInstanceID, sceneTriggerEvent._Event.c_str());
 }

Here is the caller graph for this function:

void WorldSession::HandleSelfResOpcode ( WorldPackets::Spells::SelfRes & packet )

 {
     if (_player->HasAuraType(SPELL_AURA_PREVENT_RESURRECTION))
         return; // silent return, client should display error by itself and not send this opcode
 
     if (_player->GetUInt32Value(PLAYER_SELF_RES_SPELL))
     {
         SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(_player->GetUInt32Value(PLAYER_SELF_RES_SPELL));
         if (spellInfo)
             _player->CastSpell(_player, spellInfo, false, nullptr);
 
         _player->SetUInt32Value(PLAYER_SELF_RES_SPELL, 0);
     }
 }

Here is the caller graph for this function:

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

 {
     TC_LOG_DEBUG("network", "WORLD: Received CMSG_SELL_ITEM: Vendor %s, Item %s, Amount: %u",
         packet.VendorGUID.ToString().c_str(), packet.ItemGUID.ToString().c_str(), packet.Amount);
 
     if (packet.ItemGUID.IsEmpty())
         return;
 
     Creature* creature = GetPlayer()->GetNPCIfCanInteractWith(packet.VendorGUID, UNIT_NPC_FLAG_VENDOR);
     if (!creature)
     {
         TC_LOG_DEBUG("network", "WORLD: HandleSellItemOpcode - %s not found or you can not interact with him.", packet.VendorGUID.ToString().c_str());
         _player->SendSellError(SELL_ERR_CANT_FIND_VENDOR, nullptr, packet.ItemGUID);
         return;
     }
 
     // remove fake death
     if (GetPlayer()->HasUnitState(UNIT_STATE_DIED))
         GetPlayer()->RemoveAurasByType(SPELL_AURA_FEIGN_DEATH);
 
     Item* pItem = _player->GetItemByGuid(packet.ItemGUID);
     if (pItem)
     {
         // prevent sell not owner item
         if (_player->GetGUID() != pItem->GetOwnerGUID())
         {
             _player->SendSellError(SELL_ERR_CANT_SELL_ITEM, creature, packet.ItemGUID);
             return;
         }
 
         // prevent sell non empty bag by drag-and-drop at vendor's item list
         if (pItem->IsNotEmptyBag())
         {
             _player->SendSellError(SELL_ERR_CANT_SELL_ITEM, creature, packet.ItemGUID);
             return;
         }
 
         // prevent sell currently looted item
         if (_player->GetLootGUID() == pItem->GetGUID())
         {
             _player->SendSellError(SELL_ERR_CANT_SELL_ITEM, creature, packet.ItemGUID);
             return;
         }
 
         // prevent selling item for sellprice when the item is still refundable
         // this probably happens when right clicking a refundable item, the client sends both
         // CMSG_SELL_ITEM and CMSG_REFUND_ITEM (unverified)
         if (pItem->HasFlag(ITEM_FIELD_FLAGS, ITEM_FIELD_FLAG_REFUNDABLE))
             return; // Therefore, no feedback to client
 
         // special case at auto sell (sell all)
         if (packet.Amount == 0)
             packet.Amount = pItem->GetCount();
         else
         {
             // prevent sell more items that exist in stack (possible only not from client)
             if (packet.Amount > pItem->GetCount())
             {
                 _player->SendSellError(SELL_ERR_CANT_SELL_ITEM, creature, packet.ItemGUID);
                 return;
             }
         }
 
         ItemTemplate const* pProto = pItem->GetTemplate();
         if (pProto)
         {
             if (pProto->GetSellPrice() > 0)
             {
                 if (packet.Amount < pItem->GetCount())               // need split items
                 {
                     Item* pNewItem = pItem->CloneItem(packet.Amount, _player);
                     if (!pNewItem)
                     {
                         TC_LOG_ERROR("network", "WORLD: HandleSellItemOpcode - could not create clone of item %u; count = %u", pItem->GetEntry(), packet.Amount);
                         _player->SendSellError(SELL_ERR_CANT_SELL_ITEM, creature, packet.ItemGUID);
                         return;
                     }
 
                     pItem->SetCount(pItem->GetCount() - packet.Amount);
                     _player->ItemRemovedQuestCheck(pItem->GetEntry(), packet.Amount);
                     if (_player->IsInWorld())
                         pItem->SendUpdateToPlayer(_player);
                     pItem->SetState(ITEM_CHANGED, _player);
 
                     _player->AddItemToBuyBackSlot(pNewItem);
                     if (_player->IsInWorld())
                         pNewItem->SendUpdateToPlayer(_player);
                 }
                 else
                 {
                     _player->ItemRemovedQuestCheck(pItem->GetEntry(), pItem->GetCount());
                     _player->RemoveItem(pItem->GetBagSlot(), pItem->GetSlot(), true);
                     pItem->RemoveFromUpdateQueueOf(_player);
                     _player->AddItemToBuyBackSlot(pItem);
                 }
 
                 uint32 money = pProto->GetSellPrice() * packet.Amount;
                 _player->ModifyMoney(money);
                 _player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_MONEY_FROM_VENDORS, money);
             }
             else
                 _player->SendSellError(SELL_ERR_CANT_SELL_ITEM, creature, packet.ItemGUID);
             return;
         }
     }
     _player->SendSellError(SELL_ERR_CANT_FIND_ITEM, creature, packet.ItemGUID);
     return;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleSendMail ( WorldPackets::Mail::SendMail & packet )

 {
     if (packet.Info.Attachments.size() > MAX_MAIL_ITEMS)        // client limit
     {
         GetPlayer()->SendMailResult(0, MAIL_SEND, MAIL_ERR_TOO_MANY_ATTACHMENTS);
         return;
     }
 
     if (!CanOpenMailBox(packet.Info.Mailbox))
         return;
 
     if (packet.Info.Target.empty())
         return;
 
     Player* player = _player;
 
     if (player->getLevel() < sWorld->getIntConfig(CONFIG_MAIL_LEVEL_REQ))
     {
         SendNotification(GetTrinityString(LANG_MAIL_SENDER_REQ), sWorld->getIntConfig(CONFIG_MAIL_LEVEL_REQ));
         return;
     }
 
     ObjectGuid receiverGuid;
     if (normalizePlayerName(packet.Info.Target))
         receiverGuid = ObjectMgr::GetPlayerGUIDByName(packet.Info.Target);
 
     if (!receiverGuid)
     {
         TC_LOG_INFO("network", "Player %s is sending mail to %s (GUID: not existed!) with subject %s "
             "and body %s includes " SZFMTD " items, " SI64FMTD " copper and " SI64FMTD " COD copper with StationeryID = %d",
             GetPlayerInfo().c_str(), packet.Info.Target.c_str(), packet.Info.Subject.c_str(), packet.Info.Body.c_str(),
             packet.Info.Attachments.size(), packet.Info.SendMoney, packet.Info.Cod, packet.Info.StationeryID);
         player->SendMailResult(0, MAIL_SEND, MAIL_ERR_RECIPIENT_NOT_FOUND);
         return;
     }
 
     if (packet.Info.SendMoney < 0)
     {
         GetPlayer()->SendMailResult(0, MAIL_SEND, MAIL_ERR_INTERNAL_ERROR);
         TC_LOG_WARN("cheat", "Player %s attempted to send mail to %s (%s) with negative money value (SendMoney: " SI64FMTD ")",
             GetPlayerInfo().c_str(), packet.Info.Target.c_str(), receiverGuid.ToString().c_str(), packet.Info.SendMoney);
         return;
     }
 
     if (packet.Info.Cod < 0)
     {
         GetPlayer()->SendMailResult(0, MAIL_SEND, MAIL_ERR_INTERNAL_ERROR);
         TC_LOG_WARN("cheat", "Player %s attempted to send mail to %s (%s) with negative COD value (Cod: " SI64FMTD ")",
             GetPlayerInfo().c_str(), packet.Info.Target.c_str(), receiverGuid.ToString().c_str(), packet.Info.Cod);
         return;
     }
 
     TC_LOG_INFO("network", "Player %s is sending mail to %s (%s) with subject %s and body %s "
         "includes " SZFMTD " items, " SI64FMTD " copper and " SI64FMTD  " COD copper with StationeryID = %d",
         GetPlayerInfo().c_str(), packet.Info.Target.c_str(), receiverGuid.ToString().c_str(), packet.Info.Subject.c_str(),
         packet.Info.Body.c_str(), packet.Info.Attachments.size(), packet.Info.SendMoney, packet.Info.Cod, packet.Info.StationeryID);
 
     if (player->GetGUID() == receiverGuid)
     {
         player->SendMailResult(0, MAIL_SEND, MAIL_ERR_CANNOT_SEND_TO_SELF);
         return;
     }
 
     uint32 cost = !packet.Info.Attachments.empty() ? 30 * packet.Info.Attachments.size() : 30;  // price hardcoded in client
 
     int64 reqmoney = cost + packet.Info.SendMoney;
 
     // Check for overflow
     if (reqmoney < packet.Info.SendMoney)
     {
         player->SendMailResult(0, MAIL_SEND, MAIL_ERR_NOT_ENOUGH_MONEY);
         return;
     }
 
     if (!player->HasEnoughMoney(reqmoney) && !player->IsGameMaster())
     {
         player->SendMailResult(0, MAIL_SEND, MAIL_ERR_NOT_ENOUGH_MONEY);
         return;
     }
 
     Player* receiver = ObjectAccessor::FindConnectedPlayer(receiverGuid);
 
     uint32 receiverTeam = 0;
     uint8 mailsCount = 0;                                  //do not allow to send to one player more than 100 mails
     uint8 receiverLevel = 0;
     uint32 receiverAccountId = 0;
     uint32 receiverBnetAccountId = 0;
 
     if (receiver)
     {
         receiverTeam = receiver->GetTeam();
         mailsCount = receiver->GetMailSize();
         receiverLevel = receiver->getLevel();
         receiverAccountId = receiver->GetSession()->GetAccountId();
         receiverBnetAccountId = receiver->GetSession()->GetBattlenetAccountId();
     }
     else
     {
         receiverTeam = ObjectMgr::GetPlayerTeamByGUID(receiverGuid);
 
         PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_MAIL_COUNT);
         stmt->setUInt64(0, receiverGuid.GetCounter());
 
         PreparedQueryResult result = CharacterDatabase.Query(stmt);
         if (result)
         {
             Field* fields = result->Fetch();
             mailsCount = fields[0].GetUInt64();
         }
 
         stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHAR_LEVEL);
         stmt->setUInt64(0, receiverGuid.GetCounter());
 
         result = CharacterDatabase.Query(stmt);
         if (result)
         {
             Field* fields = result->Fetch();
             receiverLevel = fields[0].GetUInt8();
         }
 
         receiverAccountId = ObjectMgr::GetPlayerAccountIdByGUID(receiverGuid);
         receiverBnetAccountId = Battlenet::AccountMgr::GetIdByGameAccount(receiverAccountId);
     }
 
     // do not allow to have more than 100 mails in mailbox.. mails count is in opcode uint8!!! - so max can be 255..
     if (mailsCount > 100)
     {
         player->SendMailResult(0, MAIL_SEND, MAIL_ERR_RECIPIENT_CAP_REACHED);
         return;
     }
 
     // test the receiver's Faction... or all items are account bound
     bool accountBound = !packet.Info.Attachments.empty();
     for (auto const& att : packet.Info.Attachments)
     {
         if (Item* item = player->GetItemByGuid(att.ItemGUID))
         {
             ItemTemplate const* itemProto = item->GetTemplate();
             if (!itemProto || !(itemProto->GetFlags() & ITEM_FLAG_BIND_TO_ACCOUNT))
             {
                 accountBound = false;
                 break;
             }
         }
     }
 
     if (!accountBound && player->GetTeam() != receiverTeam && !HasPermission(rbac::RBAC_PERM_TWO_SIDE_INTERACTION_MAIL))
     {
         player->SendMailResult(0, MAIL_SEND, MAIL_ERR_NOT_YOUR_TEAM);
         return;
     }
 
     if (receiverLevel < sWorld->getIntConfig(CONFIG_MAIL_LEVEL_REQ))
     {
         SendNotification(GetTrinityString(LANG_MAIL_RECEIVER_REQ), sWorld->getIntConfig(CONFIG_MAIL_LEVEL_REQ));
         return;
     }
 
     std::vector<Item*> items;
 
     for (auto const& att : packet.Info.Attachments)
     {
         if (att.ItemGUID.IsEmpty())
         {
             player->SendMailResult(0, MAIL_SEND, MAIL_ERR_MAIL_ATTACHMENT_INVALID);
             return;
         }
 
         Item* item = player->GetItemByGuid(att.ItemGUID);
 
         // prevent sending bag with items (cheat: can be placed in bag after adding equipped empty bag to mail)
         if (!item)
         {
             player->SendMailResult(0, MAIL_SEND, MAIL_ERR_MAIL_ATTACHMENT_INVALID);
             return;
         }
 
         if (!item->CanBeTraded(true))
         {
             player->SendMailResult(0, MAIL_SEND, MAIL_ERR_EQUIP_ERROR, EQUIP_ERR_MAIL_BOUND_ITEM);
             return;
         }
 
         if (item->IsBoundAccountWide() && item->IsSoulBound() && player->GetSession()->GetAccountId() != receiverAccountId)
         {
             if (!item->IsBattlenetAccountBound() || !player->GetSession()->GetBattlenetAccountId() || player->GetSession()->GetBattlenetAccountId() != receiverBnetAccountId)
             {
                 player->SendMailResult(0, MAIL_SEND, MAIL_ERR_EQUIP_ERROR, EQUIP_ERR_NOT_SAME_ACCOUNT);
                 return;
             }
         }
 
         if (item->GetTemplate()->GetFlags() & ITEM_FLAG_CONJURED || item->GetUInt32Value(ITEM_FIELD_DURATION))
         {
             player->SendMailResult(0, MAIL_SEND, MAIL_ERR_EQUIP_ERROR, EQUIP_ERR_MAIL_BOUND_ITEM);
             return;
         }
 
         if (packet.Info.Cod && item->HasFlag(ITEM_FIELD_FLAGS, ITEM_FIELD_FLAG_WRAPPED))
         {
             player->SendMailResult(0, MAIL_SEND, MAIL_ERR_CANT_SEND_WRAPPED_COD);
             return;
         }
 
         if (item->IsNotEmptyBag())
         {
             player->SendMailResult(0, MAIL_SEND, MAIL_ERR_EQUIP_ERROR, EQUIP_ERR_DESTROY_NONEMPTY_BAG);
             return;
         }
 
         items.push_back(item);
     }
 
     player->SendMailResult(0, MAIL_SEND, MAIL_OK);
 
     player->ModifyMoney(-reqmoney);
     player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_GOLD_SPENT_FOR_MAIL, cost);
 
     bool needItemDelay = false;
 
     MailDraft draft(packet.Info.Subject, packet.Info.Body);
 
     SQLTransaction trans = CharacterDatabase.BeginTransaction();
 
     if (!packet.Info.Attachments.empty() || packet.Info.SendMoney > 0)
     {
         bool log = HasPermission(rbac::RBAC_PERM_LOG_GM_TRADE);
         if (!packet.Info.Attachments.empty())
         {
             for (auto const& item : items)
             {
                 if (log)
                 {
                     sLog->outCommand(GetAccountId(), "GM %s (%s) (Account: %u) mail item: %s (Entry: %u Count: %u) "
                         "to: %s (%s) (Account: %u)", GetPlayerName().c_str(), _player->GetGUID().ToString().c_str(), GetAccountId(),
                         item->GetTemplate()->GetDefaultLocaleName(), item->GetEntry(), item->GetCount(),
                         packet.Info.Target.c_str(), receiverGuid.ToString().c_str(), receiverAccountId);
                 }
 
                 item->SetNotRefundable(GetPlayer()); // makes the item no longer refundable
                 player->MoveItemFromInventory(item->GetBagSlot(), item->GetSlot(), true);
 
                 item->DeleteFromInventoryDB(trans);     // deletes item from character's inventory
                 item->SetOwnerGUID(receiverGuid);
                 item->SaveToDB(trans);                  // recursive and not have transaction guard into self, item not in inventory and can be save standalone
 
                 draft.AddItem(item);
             }
 
             // if item send to character at another account, then apply item delivery delay
             needItemDelay = player->GetSession()->GetAccountId() != receiverAccountId;
         }
 
         if (log && packet.Info.SendMoney > 0)
         {
             sLog->outCommand(GetAccountId(), "GM %s (%s) (Account: %u) mail money: " SI64FMTD " to: %s (%s) (Account: %u)",
                 GetPlayerName().c_str(), _player->GetGUID().ToString().c_str(), GetAccountId(), packet.Info.SendMoney, packet.Info.Target.c_str(), receiverGuid.ToString().c_str(), receiverAccountId);
         }
     }
 
     // If theres is an item, there is a one hour delivery delay if sent to another account's character.
     uint32 deliver_delay = needItemDelay ? sWorld->getIntConfig(CONFIG_MAIL_DELIVERY_DELAY) : 0;
 
     // Mail sent between guild members arrives instantly if they have the guild perk "Guild Mail"
     if (Guild* guild = sGuildMgr->GetGuildById(player->GetGuildId()))
         if (guild->GetLevel() >= 17 && guild->IsMember(receiverGuid))
             deliver_delay = 0;
 
     // don't ask for COD if there are no items
     if (packet.Info.Attachments.empty())
         packet.Info.Cod = 0;
 
     // will delete item or place to receiver mail list
     draft
         .AddMoney(packet.Info.SendMoney)
         .AddCOD(packet.Info.Cod)
         .SendMailTo(trans, MailReceiver(receiver, receiverGuid.GetCounter()), MailSender(player), packet.Info.Body.empty() ? MAIL_CHECK_MASK_COPIED : MAIL_CHECK_MASK_HAS_BODY, deliver_delay);
 
     player->SaveInventoryAndGoldToDB(trans);
     CharacterDatabase.CommitTransaction(trans);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (!GetPlayer())                                        // ignore until not logged (check needed because STATUS_AUTHED)
     {
         if (packet.Mask != 0)
             TC_LOG_ERROR("network", "WorldSession::HandleSetActionBarToggles in not logged state with value: %u, ignored", uint32(packet.Mask));
         return;
     }
 
     GetPlayer()->SetByteValue(PLAYER_FIELD_BYTES, PLAYER_FIELD_BYTES_OFFSET_ACTION_BAR_TOGGLES, packet.Mask);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     uint32 action = ACTION_BUTTON_ACTION(packet.Action);
     uint32 type = ACTION_BUTTON_TYPE(packet.Action);
 
     TC_LOG_DEBUG("network", "CMSG_SET_ACTION_BUTTON Button: %u Action: %u Type: %u", packet.Index, action, type);
 
     if (!packet.Action)
         GetPlayer()->RemoveActionButton(packet.Index);
     else
         GetPlayer()->AddActionButton(packet.Index, action, type);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (GetPlayer()->IsInWorld())
         if (_player->m_mover->GetGUID() != packet.ActiveMover)
             TC_LOG_DEBUG("network", "HandleSetActiveMoverOpcode: incorrect mover guid: mover is %s and should be %s" , packet.ActiveMover.ToString().c_str(), _player->m_mover->GetGUID().ToString().c_str());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleSetActiveVoiceChannel ( WorldPackets::Voice::SetActiveVoiceChannel & packet )

27 {

28 }

Here is the caller graph for this function:

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

 {
     _player->SetAdvancedCombatLogging(setAdvancedCombatLogging.Enable);
 }

Here is the caller graph for this function:

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

 {
     Group* group = GetPlayer()->GetGroup();
     if (!group)
         return;
 
     if (!group->IsLeader(GetPlayer()->GetGUID()))
         return;
 
     group->SetGroupMemberFlag(packet.Target, packet.Apply, MEMBER_FLAG_ASSISTANT);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     GetPlayer()->ValidateMovementInfo(&setCollisionHeightAck.Data.movementInfo);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Todo:: : handle VirtualRealmAddress

 {
     TC_LOG_DEBUG("network", "WorldSession::HandleSetContactNotesOpcode: Contact: %s, Notes: %s", packet.Player.Guid.ToString().c_str(), packet.Notes.c_str());
     _player->GetSocial()->SetFriendNote(packet.Player.Guid, packet.Notes);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     DifficultyEntry const* difficultyEntry = sDifficultyStore.LookupEntry(setDungeonDifficulty.DifficultyID);
     if (!difficultyEntry)
     {
         TC_LOG_DEBUG("network", "WorldSession::HandleSetDungeonDifficultyOpcode: %s sent an invalid instance mode %d!",
             _player->GetGUID().ToString().c_str(), setDungeonDifficulty.DifficultyID);
         return;
     }
 
     if (difficultyEntry->InstanceType != MAP_INSTANCE)
     {
         TC_LOG_DEBUG("network", "WorldSession::HandleSetDungeonDifficultyOpcode: %s sent an non-dungeon instance mode %d!",
             _player->GetGUID().ToString().c_str(), difficultyEntry->ID);
         return;
     }
 
     if (!(difficultyEntry->Flags & DIFFICULTY_FLAG_CAN_SELECT))
     {
         TC_LOG_DEBUG("network", "WorldSession::HandleSetDungeonDifficultyOpcode: %s sent unselectable instance mode %d!",
             _player->GetGUID().ToString().c_str(), difficultyEntry->ID);
         return;
     }
 
     Difficulty difficultyID = Difficulty(difficultyEntry->ID);
     if (difficultyID == _player->GetDungeonDifficultyID())
         return;
 
     // cannot reset while in an instance
     Map* map = _player->FindMap();
     if (map && map->IsDungeon())
     {
         TC_LOG_DEBUG("network", "WorldSession::HandleSetDungeonDifficultyOpcode: player (Name: %s, %s) tried to reset the instance while player is inside!",
             _player->GetName().c_str(), _player->GetGUID().ToString().c_str());
         return;
     }
 
     Group* group = _player->GetGroup();
     if (group)
     {
         if (group->IsLeader(_player->GetGUID()))
         {
             for (GroupReference* itr = group->GetFirstMember(); itr != NULL; itr = itr->next())
             {
                 Player* groupGuy = itr->GetSource();
                 if (!groupGuy)
                     continue;
 
                 if (!groupGuy->IsInMap(groupGuy))
                     return;
 
                 if (groupGuy->GetMap()->IsNonRaidDungeon())
                 {
                     TC_LOG_DEBUG("network", "WorldSession::HandleSetDungeonDifficultyOpcode: %s tried to reset the instance while group member (Name: %s, %s) is inside!",
                         _player->GetGUID().ToString().c_str(), groupGuy->GetName().c_str(), groupGuy->GetGUID().ToString().c_str());
                     return;
                 }
             }
             // the difficulty is set even if the instances can't be reset
             //_player->SendDungeonDifficulty(true);
             group->ResetInstances(INSTANCE_RESET_CHANGE_DIFFICULTY, false, false, _player);
             group->SetDungeonDifficultyID(difficultyID);
         }
     }
     else
     {
         _player->ResetInstances(INSTANCE_RESET_CHANGE_DIFFICULTY, false, false);
         _player->SetDungeonDifficultyID(difficultyID);
         _player->SendDungeonDifficulty();
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     Group* group = GetPlayer()->GetGroup();
     if (!group)
         return;
 
     if (!group->IsLeader(GetPlayer()->GetGUID()))
         return;
 
     group->SetEveryoneIsAssistant(packet.EveryoneIsAssistant);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     GetPlayer()->GetReputationMgr().SetAtWar(packet.FactionIndex, true);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleSetFactionCheat ( WorldPacket & recvData )

 {
     TC_LOG_ERROR("network", "WORLD SESSION: HandleSetFactionCheat, not expected call, please report.");
     GetPlayer()->GetReputationMgr().SendStates();
 }

Here is the call graph for this function:

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

 {
     _player->GetReputationMgr().SetInactive(packet.Index, packet.State);
 }

Here is the caller graph for this function:

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

 {
     GetPlayer()->GetReputationMgr().SetAtWar(packet.FactionIndex, false);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

error handling

 {
     Group* group = GetPlayer()->GetGroup();
     if (!group)
         return;
 
     if (!group->IsLeader(GetPlayer()->GetGUID()))
         return;
 
     if (packet.LootMethod > PERSONAL_LOOT)
         return;
 
     if (packet.LootThreshold < ITEM_QUALITY_UNCOMMON || packet.LootThreshold > ITEM_QUALITY_ARTIFACT)
         return;
 
     if (packet.LootMethod == MASTER_LOOT && !group->IsMember(packet.LootMasterGUID))
         return;
     /********************/
 
     // everything's fine, do it
     group->SetLootMethod(static_cast<LootMethod>(packet.LootMethod));
     group->SetMasterLooterGuid(packet.LootMasterGUID);
     group->SetLootThreshold(static_cast<ItemQualities>(packet.LootThreshold));
     group->SendUpdate();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (packet.SpecID)
     {
         if (ChrSpecializationEntry const* chrSpec = sChrSpecializationStore.LookupEntry(packet.SpecID))
         {
             if (chrSpec->ClassID == GetPlayer()->getClass())
                 GetPlayer()->SetLootSpecId(packet.SpecID);
         }
     }
     else
         GetPlayer()->SetLootSpecId(packet.SpecID);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     Group* group = GetPlayer()->GetGroup();
     if (!group)
         return;
 
     ObjectGuid senderGuid = GetPlayer()->GetGUID();
     if (!group->IsLeader(senderGuid) && !group->IsAssistant(senderGuid))
         return;
 
     switch (packet.Assignment)
     {
         case GROUP_ASSIGN_MAINASSIST:
             group->RemoveUniqueGroupMemberFlag(MEMBER_FLAG_MAINASSIST);
             group->SetGroupMemberFlag(packet.Target, packet.Set, MEMBER_FLAG_MAINASSIST);
             break;
         case GROUP_ASSIGN_MAINTANK:
             group->RemoveUniqueGroupMemberFlag(MEMBER_FLAG_MAINTANK);           // Remove main assist flag from current if any.
             group->SetGroupMemberFlag(packet.Target, packet.Set, MEMBER_FLAG_MAINTANK);
         default:
             break;
     }
 
     group->SendUpdate();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     Player* player = ObjectAccessor::FindConnectedPlayer(packet.TargetGUID);
     Group* group = GetPlayer()->GetGroup();
 
     if (!group || !player)
         return;
 
     if (!group->IsLeader(GetPlayer()->GetGUID()) || player->GetGroup() != group)
         return;
 
     // Everything's fine, accepted.
     group->ChangeLeader(packet.TargetGUID, packet.PartyIndex);
     group->SendUpdate();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     // not accept declined names for unsupported languages
     std::string name;
     if (!ObjectMgr::GetPlayerNameByGUID(packet.Player, name))
     {
         SendSetPlayerDeclinedNamesResult(DECLINED_NAMES_RESULT_ERROR, packet.Player);
         return;
     }
 
     std::wstring wname;
     if (!Utf8toWStr(name, wname))
     {
         SendSetPlayerDeclinedNamesResult(DECLINED_NAMES_RESULT_ERROR, packet.Player);
         return;
     }
 
     if (!isCyrillicCharacter(wname[0]))                      // name already stored as only single alphabet using
     {
         SendSetPlayerDeclinedNamesResult(DECLINED_NAMES_RESULT_ERROR, packet.Player);
         return;
     }
 
     for (int i = 0; i < MAX_DECLINED_NAME_CASES; ++i)
     {
         if (!normalizePlayerName(packet.DeclinedNames.name[i]))
         {
             SendSetPlayerDeclinedNamesResult(DECLINED_NAMES_RESULT_ERROR, packet.Player);
             return;
         }
     }
 
     if (!ObjectMgr::CheckDeclinedNames(wname, packet.DeclinedNames))
     {
         SendSetPlayerDeclinedNamesResult(DECLINED_NAMES_RESULT_ERROR, packet.Player);
         return;
     }
 
     for (int i = 0; i < MAX_DECLINED_NAME_CASES; ++i)
         CharacterDatabase.EscapeString(packet.DeclinedNames.name[i]);
 
     SQLTransaction trans = CharacterDatabase.BeginTransaction();
 
     PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_DECLINED_NAME);
     stmt->setUInt64(0, packet.Player.GetCounter());
     trans->Append(stmt);
 
     stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_CHAR_DECLINED_NAME);
     stmt->setUInt64(0, packet.Player.GetCounter());
 
     for (uint8 i = 0; i < MAX_DECLINED_NAME_CASES; i++)
         stmt->setString(i + 1, packet.DeclinedNames.name[i]);
 
     trans->Append(stmt);
 
     CharacterDatabase.CommitTransaction(trans);
 
     SendSetPlayerDeclinedNamesResult(DECLINED_NAMES_RESULT_SUCCESS, packet.Player);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     GetPlayer()->ApplyModFlag(PLAYER_FLAGS, PLAYER_FLAGS_IN_PVP, packet.EnablePVP);
     GetPlayer()->ApplyModFlag(PLAYER_FLAGS, PLAYER_FLAGS_PVP_TIMER, !packet.EnablePVP);
 
     if (GetPlayer()->HasFlag(PLAYER_FLAGS, PLAYER_FLAGS_IN_PVP))
     {
         if (!GetPlayer()->IsPvP() || GetPlayer()->pvpInfo.EndTimer)
             GetPlayer()->UpdatePvP(true, true);
     }
     else
     {
         if (!GetPlayer()->pvpInfo.IsHostile && GetPlayer()->IsPvP())
             GetPlayer()->pvpInfo.EndTimer = time(nullptr); // start set-off
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     DifficultyEntry const* difficultyEntry = sDifficultyStore.LookupEntry(setRaidDifficulty.DifficultyID);
     if (!difficultyEntry)
     {
         TC_LOG_DEBUG("network", "WorldSession::HandleSetDungeonDifficultyOpcode: %s sent an invalid instance mode %u!",
             _player->GetGUID().ToString().c_str(), setRaidDifficulty.DifficultyID);
         return;
     }
 
     if (difficultyEntry->InstanceType != MAP_RAID)
     {
         TC_LOG_DEBUG("network", "WorldSession::HandleSetDungeonDifficultyOpcode: %s sent an non-dungeon instance mode %u!",
             _player->GetGUID().ToString().c_str(), difficultyEntry->ID);
         return;
     }
 
     if (!(difficultyEntry->Flags & DIFFICULTY_FLAG_CAN_SELECT))
     {
         TC_LOG_DEBUG("network", "WorldSession::HandleSetDungeonDifficultyOpcode: %s sent unselectable instance mode %u!",
             _player->GetGUID().ToString().c_str(), difficultyEntry->ID);
         return;
     }
 
     if (((difficultyEntry->Flags & DIFFICULTY_FLAG_LEGACY) >> 5) != setRaidDifficulty.Legacy)
     {
         TC_LOG_DEBUG("network", "WorldSession::HandleSetDungeonDifficultyOpcode: %s sent not matching legacy difficulty %u!",
             _player->GetGUID().ToString().c_str(), difficultyEntry->ID);
         return;
     }
 
     Difficulty difficultyID = Difficulty(difficultyEntry->ID);
     if (difficultyID == (setRaidDifficulty.Legacy ?  _player->GetLegacyRaidDifficultyID() : _player->GetRaidDifficultyID()))
         return;
 
     // cannot reset while in an instance
     Map* map = _player->FindMap();
     if (map && map->IsDungeon())
     {
         TC_LOG_DEBUG("network", "WorldSession::HandleSetRaidDifficultyOpcode: player (Name: %s, %s) tried to reset the instance while player is inside!",
             _player->GetName().c_str(), _player->GetGUID().ToString().c_str());
         return;
     }
 
     Group* group = _player->GetGroup();
     if (group)
     {
         if (group->IsLeader(_player->GetGUID()))
         {
             for (GroupReference* itr = group->GetFirstMember(); itr != NULL; itr = itr->next())
             {
                 Player* groupGuy = itr->GetSource();
                 if (!groupGuy)
                     continue;
 
                 if (!groupGuy->IsInMap(groupGuy))
                     return;
 
                 if (groupGuy->GetMap()->IsRaid())
                 {
                     TC_LOG_DEBUG("network", "WorldSession::HandleSetRaidDifficultyOpcode: %s tried to reset the instance while group member (Name: %s, %s) is inside!",
                         _player->GetGUID().ToString().c_str(), groupGuy->GetName().c_str(), groupGuy->GetGUID().ToString().c_str());
                     return;
                 }
             }
             // the difficulty is set even if the instances can't be reset
             group->ResetInstances(INSTANCE_RESET_CHANGE_DIFFICULTY, true, setRaidDifficulty.Legacy != 0, _player);
             if (setRaidDifficulty.Legacy)
                 group->SetLegacyRaidDifficultyID(difficultyID);
             else
                 group->SetRaidDifficultyID(difficultyID);
         }
     }
     else
     {
         _player->ResetInstances(INSTANCE_RESET_CHANGE_DIFFICULTY, true, setRaidDifficulty.Legacy != 0);
         if (setRaidDifficulty.Legacy)
             _player->SetLegacyRaidDifficultyID(difficultyID);
         else
             _player->SetRaidDifficultyID(difficultyID);
 
         _player->SendRaidDifficulty(setRaidDifficulty.Legacy != 0);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     WorldPackets::Party::RoleChangedInform roleChangedInform;
 
     Group* group = GetPlayer()->GetGroup();
     uint8 oldRole = group ? group->GetLfgRoles(packet.TargetGUID) : 0;
     if (oldRole == packet.Role)
         return;
 
     roleChangedInform.PartyIndex = packet.PartyIndex;
     roleChangedInform.From = GetPlayer()->GetGUID();
     roleChangedInform.ChangedUnit = packet.TargetGUID;
     roleChangedInform.OldRole = oldRole;
     roleChangedInform.NewRole = packet.Role;
 
     if (group)
     {
         group->BroadcastPacket(roleChangedInform.Write(), false);
         group->SetLfgRoles(packet.TargetGUID, packet.Role);
     }
     else
         SendPacket(roleChangedInform.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     TC_LOG_DEBUG("network", "CMSG_SET_SAVED_INSTANCE_EXTEND - MapId: %u, Difficulty: %u, ToggleExtend: %s", setSavedInstanceExtend.MapID, setSavedInstanceExtend.DifficultyID, setSavedInstanceExtend.Extend ? "On" : "Off");
 
     if (Player* player = GetPlayer())
     {
         InstancePlayerBind* instanceBind = player->GetBoundInstance(setSavedInstanceExtend.MapID, Difficulty(setSavedInstanceExtend.DifficultyID), setSavedInstanceExtend.Extend); // include expired instances if we are toggling extend on
         if (!instanceBind || !instanceBind->save || !instanceBind->perm)
             return;
 
         BindExtensionState newState;
         if (!setSavedInstanceExtend.Extend || instanceBind->extendState == EXTEND_STATE_EXPIRED)
             newState = EXTEND_STATE_NORMAL;
         else
             newState = EXTEND_STATE_EXTENDED;
 
         player->BindToInstance(instanceBind->save, true, newState, false);
     }
 
     /*
     InstancePlayerBind* instanceBind = _player->GetBoundInstance(setSavedInstanceExtend.MapID, Difficulty(setSavedInstanceExtend.DifficultyID));
     if (!instanceBind || !instanceBind->save)
         return;
 
     InstanceSave* save = instanceBind->save;
     // http://www.wowwiki.com/Instance_Lock_Extension
     // SendCalendarRaidLockoutUpdated(save);
     */
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     _player->SetSelection(packet.Selection);
 }

Here is the caller graph for this function:

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

 {
     if (packet.CurrentSheathState >= MAX_SHEATH_STATE)
     {
         TC_LOG_ERROR("network", "Unknown sheath state %u ??", packet.CurrentSheathState);
         return;
     }
 
     GetPlayer()->SetSheath(SheathState(packet.CurrentSheathState));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleSetSpecializationOpcode ( WorldPackets::Talent::SetSpecialization & packet )

 {
     Player* player = GetPlayer();
 
     if (packet.SpecGroupIndex >= MAX_SPECIALIZATIONS)
     {
         TC_LOG_DEBUG("network", "WORLD: HandleSetSpecializationOpcode - specialization index %u out of range", packet.SpecGroupIndex);
         return;
     }
 
     ChrSpecializationEntry const* chrSpec = sChrSpecializationByIndexStore[player->getClass()][packet.SpecGroupIndex];
 
     if (!chrSpec)
     {
         TC_LOG_DEBUG("network", "WORLD: HandleSetSpecializationOpcode - specialization index %u not found", packet.SpecGroupIndex);
         return;
     }
 
     if (chrSpec->ClassID != player->getClass())
     {
         TC_LOG_DEBUG("network", "WORLD: HandleSetSpecializationOpcode - specialization %u does not belong to class %u", chrSpec->ID, player->getClass());
         return;
     }
 
     if (player->getLevel() < MIN_SPECIALIZATION_LEVEL)
     {
         TC_LOG_DEBUG("network", "WORLD: HandleSetSpecializationOpcode - player level too low for specializations");
         return;
     }
 
     player->LearnTalentSpecialization(chrSpec->ID);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     _player->ApplyModFlag(PLAYER_FLAGS, PLAYER_FLAGS_TAXI_BENCHMARK, packet.Enable);
 }

Here is the caller graph for this function:

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

 {
     // -1 at none
     if (packet.TitleID > 0 && packet.TitleID < MAX_TITLE_INDEX)
     {
        if (!GetPlayer()->HasTitle(packet.TitleID))
             return;
     }
     else
         packet.TitleID = 0;
 
     GetPlayer()->SetUInt32Value(PLAYER_CHOSEN_TITLE, packet.TitleID);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

766 {

767 }

Here is the caller graph for this function:

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

 {
     TradeData* my_trade = _player->GetTradeData();
     if (!my_trade)
         return;
 
     my_trade->UpdateClientStateIndex();
     my_trade->SetMoney(setTradeGold.Coinage);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     TradeData* my_trade = _player->GetTradeData();
     if (!my_trade)
         return;
 
     WorldPackets::Trade::TradeStatus info;
     // invalid slot number
     if (setTradeItem.TradeSlot >= TRADE_SLOT_COUNT)
     {
         info.Status = TRADE_STATUS_CANCELLED;
         SendTradeStatus(info);
         return;
     }
 
     // check cheating, can't fail with correct client operations
     Item* item = _player->GetItemByPos(setTradeItem.PackSlot, setTradeItem.ItemSlotInPack);
     if (!item || (setTradeItem.TradeSlot != TRADE_SLOT_NONTRADED && !item->CanBeTraded(false, true)))
     {
         info.Status = TRADE_STATUS_CANCELLED;
         SendTradeStatus(info);
         return;
     }
 
     ObjectGuid iGUID = item->GetGUID();
 
     // prevent place single item into many trade slots using cheating and client bugs
     if (my_trade->HasItem(iGUID))
     {
         // cheating attempt
         info.Status = TRADE_STATUS_CANCELLED;
         SendTradeStatus(info);
         return;
     }
 
     my_trade->UpdateClientStateIndex();
 
     if (setTradeItem.TradeSlot != TRADE_SLOT_NONTRADED && item->IsBindedNotWith(my_trade->GetTrader()))
     {
         info.Status = TRADE_STATUS_NOT_ON_TAPLIST;
         info.TradeSlot = setTradeItem.TradeSlot;
         SendTradeStatus(info);
         return;
     }
 
     my_trade->SetItem(TradeSlots(setTradeItem.TradeSlot), item);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     GetPlayer()->SetUInt32Value(PLAYER_FIELD_WATCHED_FACTION_INDEX, packet.FactionIndex);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleShowingCloakOpcode ( WorldPackets::Character::ShowingCloak & packet )

 {
     if (packet.ShowCloak)
         _player->RemoveFlag(PLAYER_FLAGS, PLAYER_FLAGS_HIDE_CLOAK);
     else
         _player->SetFlag(PLAYER_FLAGS, PLAYER_FLAGS_HIDE_CLOAK);
 }

Here is the caller graph for this function:

void WorldSession::HandleShowingHelmOpcode ( WorldPackets::Character::ShowingHelm & packet )

 {
     if (packet.ShowHelm)
         _player->RemoveFlag(PLAYER_FLAGS, PLAYER_FLAGS_HIDE_HELM);
     else
         _player->SetFlag(PLAYER_FLAGS, PLAYER_FLAGS_HIDE_HELM);
 }

Here is the caller graph for this function:

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

 {
     PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_PETITION_SIGNATURES);
 
     stmt->setUInt64(0, packet.PetitionGUID.GetCounter());
     stmt->setUInt64(1, packet.PetitionGUID.GetCounter());
 
     PreparedQueryResult result = CharacterDatabase.Query(stmt);
 
     if (!result)
     {
         TC_LOG_ERROR("network", "Petition %s is not found for %s %s", packet.PetitionGUID.ToString().c_str(), GetPlayer()->GetGUID().ToString().c_str(), GetPlayer()->GetName().c_str());
         return;
     }
 
     Field* fields = result->Fetch();
     ObjectGuid ownerGuid = ObjectGuid::Create<HighGuid::Player>(fields[0].GetUInt64());
     //uint64 signs = fields[1].GetUInt64();
 
     if (ownerGuid == _player->GetGUID())
         return;
 
     // not let enemies sign guild charter
     if (!sWorld->getBoolConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_GUILD) && GetPlayer()->GetTeam() != ObjectMgr::GetPlayerTeamByGUID(ownerGuid))
     {
         Guild::SendCommandResult(this, GUILD_COMMAND_CREATE_GUILD, ERR_GUILD_NOT_ALLIED);
         return;
     }
 
     if (_player->GetGuildId())
     {
         Guild::SendCommandResult(this, GUILD_COMMAND_INVITE_PLAYER, ERR_ALREADY_IN_GUILD_S, _player->GetName());
         return;
     }
 
     if (_player->GetGuildIdInvited())
     {
         Guild::SendCommandResult(this, GUILD_COMMAND_INVITE_PLAYER, ERR_ALREADY_INVITED_TO_GUILD_S, _player->GetName());
         return;
     }
 
     //if (++signs > type)                                        // client signs maximum
     //    return;
 
     // Client doesn't allow to sign petition two times by one character, but not check sign by another character from same account
     // not allow sign another player from already sign player account
     stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_PETITION_SIG_BY_ACCOUNT);
 
     stmt->setUInt32(0, GetAccountId());
     stmt->setUInt64(1, packet.PetitionGUID.GetCounter());
 
     result = CharacterDatabase.Query(stmt);
 
     WorldPackets::Petition::PetitionSignResults signResult;
     signResult.Player = _player->GetGUID();
     signResult.Item = packet.PetitionGUID;
 
     if (result)
     {
         signResult.Error = int32(PETITION_SIGN_ALREADY_SIGNED);
 
         // close at signer side
         SendPacket(signResult.Write());
         return;
     }
 
     stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_PETITION_SIGNATURE);
 
     stmt->setUInt64(0, ownerGuid.GetCounter());
     stmt->setUInt64(1, packet.PetitionGUID.GetCounter());
     stmt->setUInt64(2, _player->GetGUID().GetCounter());
     stmt->setUInt32(3, GetAccountId());
 
     CharacterDatabase.Execute(stmt);
 
     TC_LOG_DEBUG("network", "PETITION SIGN: %s by player: %s (%s Account: %u)", packet.PetitionGUID.ToString().c_str(), _player->GetName().c_str(), _player->GetGUID().ToString().c_str(), GetAccountId());
 
     signResult.Error = int32(PETITION_SIGN_OK);
 
     // close at signer side
     SendPacket(signResult.Write());
 
     // update signs count on charter, required testing...
     //Item* item = _player->GetItemByGuid(petitionguid));
     //if (item)
     //    item->SetUInt32Value(ITEM_FIELD_ENCHANTMENT_1_1+1, signs);
 
     // update for owner if online
     if (Player* owner = ObjectAccessor::FindConnectedPlayer(ownerGuid))
         owner->GetSession()->SendPacket(signResult.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (!socketGems.ItemGuid)
         return;
 
     //cheat -> tried to socket same gem multiple times
     if ((!socketGems.GemItem[0].IsEmpty() && (socketGems.GemItem[0] == socketGems.GemItem[1] || socketGems.GemItem[0] == socketGems.GemItem[2])) ||
         (!socketGems.GemItem[1].IsEmpty() && (socketGems.GemItem[1] == socketGems.GemItem[2])))
         return;
 
     Item* itemTarget = _player->GetItemByGuid(socketGems.ItemGuid);
     if (!itemTarget)                                         //missing item to socket
         return;
 
     ItemTemplate const* itemProto = itemTarget->GetTemplate();
     if (!itemProto)
         return;
 
     //this slot is excepted when applying / removing meta gem bonus
     uint8 slot = itemTarget->IsEquipped() ? itemTarget->GetSlot() : uint8(NULL_SLOT);
 
     Item* Gems[MAX_GEM_SOCKETS];
     for (int i = 0; i < MAX_GEM_SOCKETS; ++i)
         Gems[i] = !socketGems.GemItem[i].IsEmpty() ? _player->GetItemByGuid(socketGems.GemItem[i]) : NULL;
 
     GemPropertiesEntry const* GemProps[MAX_GEM_SOCKETS];
     for (int i = 0; i < MAX_GEM_SOCKETS; ++i)                //get geminfo from dbc storage
         GemProps[i] = (Gems[i]) ? sGemPropertiesStore.LookupEntry(Gems[i]->GetTemplate()->GetGemProperties()) : NULL;
 
     // Find first prismatic socket
     int32 firstPrismatic = 0;
     while (firstPrismatic < MAX_GEM_SOCKETS && itemTarget->GetSocketColor(firstPrismatic))
         ++firstPrismatic;
 
     for (int i = 0; i < MAX_GEM_SOCKETS; ++i)                //check for hack maybe
     {
         if (!GemProps[i])
             continue;
 
         // tried to put gem in socket where no socket exists (take care about prismatic sockets)
         if (!itemTarget->GetSocketColor(i))
         {
             // no prismatic socket
             if (!itemTarget->GetEnchantmentId(PRISMATIC_ENCHANTMENT_SLOT))
                 return;
 
             if (i != firstPrismatic)
                 return;
         }
 
         // tried to put normal gem in meta socket
         if (itemTarget->GetSocketColor(i) == SOCKET_COLOR_META && GemProps[i]->Type != SOCKET_COLOR_META)
             return;
 
         // tried to put meta gem in normal socket
         if (itemTarget->GetSocketColor(i) != SOCKET_COLOR_META && GemProps[i]->Type == SOCKET_COLOR_META)
             return;
 
         // tried to put normal gem in cogwheel socket
         if (itemTarget->GetSocketColor(i) == SOCKET_COLOR_COGWHEEL && GemProps[i]->Type != SOCKET_COLOR_COGWHEEL)
             return;
 
         // tried to put cogwheel gem in normal socket
         if (itemTarget->GetSocketColor(i) != SOCKET_COLOR_COGWHEEL && GemProps[i]->Type == SOCKET_COLOR_COGWHEEL)
             return;
     }
 
     uint32 GemEnchants[MAX_GEM_SOCKETS];
     uint32 OldEnchants[MAX_GEM_SOCKETS];
     for (int i = 0; i < MAX_GEM_SOCKETS; ++i)                //get new and old enchantments
     {
         GemEnchants[i] = (GemProps[i]) ? GemProps[i]->EnchantID : 0;
         OldEnchants[i] = itemTarget->GetEnchantmentId(EnchantmentSlot(SOCK_ENCHANTMENT_SLOT+i));
     }
 
     // check unique-equipped conditions
     for (int i = 0; i < MAX_GEM_SOCKETS; ++i)
     {
         if (!Gems[i])
             continue;
 
         // continue check for case when attempt add 2 similar unique equipped gems in one item.
         ItemTemplate const* iGemProto = Gems[i]->GetTemplate();
 
         // unique item (for new and already placed bit removed enchantments
         if (iGemProto->GetFlags() & ITEM_FLAG_UNIQUE_EQUIPPED)
         {
             for (int j = 0; j < MAX_GEM_SOCKETS; ++j)
             {
                 if (i == j)                                    // skip self
                     continue;
 
                 if (Gems[j])
                 {
                     if (iGemProto->GetId() == Gems[j]->GetEntry())
                     {
                         _player->SendEquipError(EQUIP_ERR_ITEM_UNIQUE_EQUIPPABLE_SOCKETED, itemTarget, NULL);
                         return;
                     }
                 }
                 else if (OldEnchants[j])
                 {
                     if (SpellItemEnchantmentEntry const* enchantEntry = sSpellItemEnchantmentStore.LookupEntry(OldEnchants[j]))
                     {
                         if (iGemProto->GetId() == enchantEntry->SRCItemID)
                         {
                             _player->SendEquipError(EQUIP_ERR_ITEM_UNIQUE_EQUIPPABLE_SOCKETED, itemTarget, NULL);
                             return;
                         }
                     }
                 }
             }
         }
 
         // unique limit type item
         int32 limit_newcount = 0;
         if (iGemProto->GetItemLimitCategory())
         {
             if (ItemLimitCategoryEntry const* limitEntry = sItemLimitCategoryStore.LookupEntry(iGemProto->GetItemLimitCategory()))
             {
                 // NOTE: limitEntry->mode is not checked because if item has limit then it is applied in equip case
                 for (int j = 0; j < MAX_GEM_SOCKETS; ++j)
                 {
                     if (Gems[j])
                     {
                         // new gem
                         if (iGemProto->GetItemLimitCategory() == Gems[j]->GetTemplate()->GetItemLimitCategory())
                             ++limit_newcount;
                     }
                     else if (OldEnchants[j])
                     {
                         // existing gem
                         if (SpellItemEnchantmentEntry const* enchantEntry = sSpellItemEnchantmentStore.LookupEntry(OldEnchants[j]))
                             if (ItemTemplate const* jProto = sObjectMgr->GetItemTemplate(enchantEntry->SRCItemID))
                                 if (iGemProto->GetItemLimitCategory() == jProto->GetItemLimitCategory())
                                     ++limit_newcount;
                     }
                 }
 
                 if (limit_newcount > 0 && uint32(limit_newcount) > limitEntry->Quantity)
                 {
                     _player->SendEquipError(EQUIP_ERR_ITEM_UNIQUE_EQUIPPABLE_SOCKETED, itemTarget, NULL);
                     return;
                 }
             }
         }
 
         // for equipped item check all equipment for duplicate equipped gems
         if (itemTarget->IsEquipped())
         {
             if (InventoryResult res = _player->CanEquipUniqueItem(Gems[i], slot, std::max(limit_newcount, 0)))
             {
                 _player->SendEquipError(res, itemTarget, NULL);
                 return;
             }
         }
     }
 
     bool SocketBonusActivated = itemTarget->GemsFitSockets();    //save state of socketbonus
     _player->ToggleMetaGemsActive(slot, false);             //turn off all metagems (except for the target item)
 
     //if a meta gem is being equipped, all information has to be written to the item before testing if the conditions for the gem are met
 
     //remove ALL enchants
     for (uint32 enchant_slot = SOCK_ENCHANTMENT_SLOT; enchant_slot < SOCK_ENCHANTMENT_SLOT + MAX_GEM_SOCKETS; ++enchant_slot)
         _player->ApplyEnchantment(itemTarget, EnchantmentSlot(enchant_slot), false);
 
     for (int i = 0; i < MAX_GEM_SOCKETS; ++i)
     {
         if (GemEnchants[i])
         {
             itemTarget->SetEnchantment(EnchantmentSlot(SOCK_ENCHANTMENT_SLOT+i), GemEnchants[i], 0, 0, _player->GetGUID());
             if (Item* guidItem = _player->GetItemByGuid(socketGems.GemItem[i]))
             {
                 uint32 gemCount = 1;
                 _player->DestroyItemCount(guidItem, gemCount, true);
             }
         }
     }
 
     for (uint32 enchant_slot = SOCK_ENCHANTMENT_SLOT; enchant_slot < SOCK_ENCHANTMENT_SLOT+MAX_GEM_SOCKETS; ++enchant_slot)
         _player->ApplyEnchantment(itemTarget, EnchantmentSlot(enchant_slot), true);
 
     bool SocketBonusToBeActivated = itemTarget->GemsFitSockets();//current socketbonus state
     if (SocketBonusActivated ^ SocketBonusToBeActivated)     //if there was a change...
     {
         _player->ApplyEnchantment(itemTarget, BONUS_ENCHANTMENT_SLOT, false);
         itemTarget->SetEnchantment(BONUS_ENCHANTMENT_SLOT, (SocketBonusToBeActivated ? itemTarget->GetTemplate()->GetSocketBonus() : 0), 0, 0, _player->GetGUID());
         _player->ApplyEnchantment(itemTarget, BONUS_ENCHANTMENT_SLOT, true);
         //it is not displayed, client has an inbuilt system to determine if the bonus is activated
     }
 
     _player->ToggleMetaGemsActive(slot, true);              //turn on all metagems (except for target item)
 
     _player->RemoveTradeableItem(itemTarget);
     itemTarget->ClearSoulboundTradeable(_player);           // clear tradeable flag
 
     itemTarget->SendUpdateSockets();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Todo:: Unit::SetCharmedBy: 28782 is not in world but 0 is trying to charm it! -> crash

 {
     // this will get something not in world. crash
     Creature* unit = ObjectAccessor::GetCreatureOrPetOrVehicle(*_player, spellClick.SpellClickUnitGuid);
 
     if (!unit)
         return;
 
     if (!unit->IsInWorld())
         return;
 
     unit->HandleSpellClick(_player);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     Creature* unit = GetPlayer()->GetNPCIfCanInteractWith(packet.Healer, UNIT_NPC_FLAG_SPIRITHEALER);
     if (!unit)
     {
         TC_LOG_DEBUG("network", "WORLD: HandleSpiritHealerActivateOpcode - %s not found or you can not interact with him.", packet.Healer.ToString().c_str());
         return;
     }
 
     // remove fake death
     if (GetPlayer()->HasUnitState(UNIT_STATE_DIED))
         GetPlayer()->RemoveAurasByType(SPELL_AURA_FEIGN_DEATH);
 
     SendSpiritResurrect();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (!splitItem.Inv.Items.empty())
     {
         TC_LOG_ERROR("network", "HandleSplitItemOpcode - Invalid ItemCount (" SZFMTD ")", splitItem.Inv.Items.size());
         return;
     }
 
     TC_LOG_DEBUG("network", "HandleSplitItemOpcode: receive FromPackSlot: %u, FromSlot: %u, ToPackSlot: %u, ToSlot: %u, Quantity: %u",
         splitItem.FromPackSlot, splitItem.FromSlot, splitItem.ToPackSlot, splitItem.ToSlot, splitItem.Quantity);
 
     uint16 src = ((splitItem.FromPackSlot << 8) | splitItem.FromSlot);
     uint16 dst = ((splitItem.ToPackSlot << 8) | splitItem.ToSlot);
 
     if (src == dst)
         return;
 
     // check count - if zero it's fake packet
     if (!splitItem.Quantity)
         return;
 
     if (!_player->IsValidPos(splitItem.FromPackSlot, splitItem.FromSlot, true))
     {
         _player->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND);
         return;
     }
 
     if (!_player->IsValidPos(splitItem.ToPackSlot, splitItem.ToSlot, false)) // can be autostore pos
     {
         _player->SendEquipError(EQUIP_ERR_WRONG_SLOT);
         return;
     }
 
     _player->SplitItem(src, dst, splitItem.Quantity);
 }

Here is the caller graph for this function:

void WorldSession::HandleStablePet ( WorldPacket & recvPacket )

 {
     ObjectGuid npcGUID;
 
     recvData >> npcGUID;
 
     if (!GetPlayer()->IsAlive())
     {
         SendPetStableResult(STABLE_ERR_STABLE);
         return;
     }
 
     if (!CheckStableMaster(npcGUID))
     {
         SendPetStableResult(STABLE_ERR_STABLE);
         return;
     }
 
     // remove fake death
     if (GetPlayer()->HasUnitState(UNIT_STATE_DIED))
         GetPlayer()->RemoveAurasByType(SPELL_AURA_FEIGN_DEATH);
 
     Pet* pet = _player->GetPet();
 
     // can't place in stable dead pet
     if (!pet || !pet->IsAlive() || pet->getPetType() != HUNTER_PET)
     {
         SendPetStableResult(STABLE_ERR_STABLE);
         return;
     }
 
     PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_PET_SLOTS);
 
     stmt->setUInt64(0, _player->GetGUID().GetCounter());
     stmt->setUInt8(1, PET_SAVE_FIRST_STABLE_SLOT);
     stmt->setUInt8(2, PET_SAVE_LAST_STABLE_SLOT);
 
     _stablePetCallback = CharacterDatabase.AsyncQuery(stmt);
 }

Here is the call graph for this function:

void WorldSession::HandleStablePetCallback ( PreparedQueryResult result )

 {
     if (!GetPlayer())
         return;
 
     uint8 freeSlot = 1;
     if (result)
     {
         do
         {
             Field* fields = result->Fetch();
 
             uint8 slot = fields[1].GetUInt8();
 
             // slots ordered in query, and if not equal then free
             if (slot != freeSlot)
                 break;
 
             // this slot not free, skip
             ++freeSlot;
         }
         while (result->NextRow());
     }
 
     if (freeSlot > 0 && freeSlot <= GetPlayer()->m_stableSlots)
     {
         _player->RemovePet(_player->GetPet(), PetSaveMode(freeSlot));
         SendPetStableResult(STABLE_SUCCESS_STABLE);
     }
     else
         SendPetStableResult(STABLE_ERR_INVALID_SLOT);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleStableRevivePet ( WorldPacket & recvPacket )

 {
     TC_LOG_DEBUG("network", "HandleStableRevivePet: Not implemented");
 }

void WorldSession::HandleStableSwapPet ( WorldPacket & recvPacket )

 {
     ObjectGuid npcGUID;
     uint32 petId;
 
     recvData >> npcGUID >> petId;
 
     if (!CheckStableMaster(npcGUID))
     {
         SendPetStableResult(STABLE_ERR_STABLE);
         return;
     }
 
     // remove fake death
     if (GetPlayer()->HasUnitState(UNIT_STATE_DIED))
         GetPlayer()->RemoveAurasByType(SPELL_AURA_FEIGN_DEATH);
 
     Pet* pet = _player->GetPet();
 
     if (!pet || pet->getPetType() != HUNTER_PET)
     {
         SendPetStableResult(STABLE_ERR_STABLE);
         return;
     }
 
     // Find swapped pet slot in stable
 
     PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_PET_SLOT_BY_ID);
 
     stmt->setUInt64(0, _player->GetGUID().GetCounter());
     stmt->setUInt32(1, petId);
 
     _stableSwapCallback.SetParam(petId);
     _stableSwapCallback.SetFutureResult(CharacterDatabase.AsyncQuery(stmt));
 }

Here is the call graph for this function:

void WorldSession::HandleStableSwapPetCallback	(	PreparedQueryResult	result,
		uint32	petId
	)

 {
     if (!GetPlayer())
         return;
 
     if (!result)
     {
         SendPetStableResult(STABLE_ERR_STABLE);
         return;
     }
 
     Field* fields = result->Fetch();
 
     uint32 slot     = fields[0].GetUInt8();
     uint32 petEntry = fields[1].GetUInt32();
 
     if (!petEntry)
     {
         SendPetStableResult(STABLE_ERR_STABLE);
         return;
     }
 
     CreatureTemplate const* creatureInfo = sObjectMgr->GetCreatureTemplate(petEntry);
     if (!creatureInfo || !creatureInfo->IsTameable(true))
     {
         SendPetStableResult(STABLE_ERR_STABLE);
         return;
     }
 
     if (!creatureInfo->IsTameable(_player->CanTameExoticPets()))
     {
         SendPetStableResult(STABLE_ERR_EXOTIC);
         return;
     }
 
     Pet* pet = _player->GetPet();
     // The player's pet could have been removed during the delay of the DB callback
     if (!pet)
     {
         SendPetStableResult(STABLE_ERR_STABLE);
         return;
     }
 
     // move alive pet to slot or delete dead pet
     _player->RemovePet(pet, pet->IsAlive() ? PetSaveMode(slot) : PET_SAVE_AS_DELETED);
 
     // summon unstabled pet
     Pet* newPet = new Pet(_player);
     if (!newPet->LoadPetFromDB(_player, petEntry, petId))
     {
         delete newPet;
         SendPetStableResult(STABLE_ERR_STABLE);
     }
     else
         SendPetStableResult(STABLE_SUCCESS_UNSTABLE);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     _player->SetStandState(packet.StandState);
 }

Here is the caller graph for this function:

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

 {
     if (!_player->IsAlive() || _player->IsInCombat())
         return;
 
     _player->SummonIfPossible(packet.Accept);
 }

Here is the caller graph for this function:

void WorldSession::HandleSupportTicketSubmitBug ( WorldPackets::Ticket::SupportTicketSubmitBug & packet )

 {
     if (!sSupportMgr->GetBugSystemStatus())
         return;
 
     BugTicket* ticket = new BugTicket(GetPlayer());
     ticket->SetPosition(packet.Header.MapID, packet.Header.Position);
     ticket->SetFacing(packet.Header.Facing);
     ticket->SetNote(packet.Note);
 
     sSupportMgr->AddTicket(ticket);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (!sSupportMgr->GetComplaintSystemStatus())
         return;
 
     ComplaintTicket* comp = new ComplaintTicket(GetPlayer());
     comp->SetPosition(packet.Header.MapID, packet.Header.Position);
     comp->SetFacing(packet.Header.Facing);
     comp->SetChatLog(packet.ChatLog);
     comp->SetTargetCharacterGuid(packet.TargetCharacterGUID);
     comp->SetComplaintType(GMSupportComplaintType(packet.ComplaintType));
     comp->SetNote(packet.Note);
 
     sSupportMgr->AddTicket(comp);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleSupportTicketSubmitSuggestion ( WorldPackets::Ticket::SupportTicketSubmitSuggestion & packet )

 {
     if (!sSupportMgr->GetSuggestionSystemStatus())
         return;
 
     SuggestionTicket* ticket = new SuggestionTicket(GetPlayer());
     ticket->SetPosition(packet.Header.MapID, packet.Header.Position);
     ticket->SetFacing(packet.Header.Facing);
     ticket->SetNote(packet.Note);
 
     sSupportMgr->AddTicket(ticket);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (swapInvItem.Inv.Items.size() != 2)
     {
         TC_LOG_ERROR("network", "HandleSwapInvItemOpcode - Invalid itemCount (" SZFMTD ")", swapInvItem.Inv.Items.size());
         return;
     }
 
     TC_LOG_DEBUG("network", "HandleSwapInvItemOpcode: receive Slot1: %u, Slot2: %u",
         swapInvItem.Slot1, swapInvItem.Slot2);
 
     // prevent attempt swap same item to current position generated by client at special checting sequence
     if (swapInvItem.Slot1 == swapInvItem.Slot2)
         return;
 
     if (!_player->IsValidPos(INVENTORY_SLOT_BAG_0, swapInvItem.Slot1, true))
     {
         _player->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND);
         return;
     }
 
     if (!_player->IsValidPos(INVENTORY_SLOT_BAG_0, swapInvItem.Slot2, true))
     {
         _player->SendEquipError(EQUIP_ERR_WRONG_SLOT);
         return;
     }
 
     if (_player->IsBankPos(INVENTORY_SLOT_BAG_0, swapInvItem.Slot1) && !CanUseBank())
     {
         TC_LOG_DEBUG("network", "HandleSwapInvItemOpcode - Unit (%s) not found or you can't interact with him.", m_currentBankerGUID.ToString().c_str());
         return;
     }
 
     if (_player->IsBankPos(INVENTORY_SLOT_BAG_0, swapInvItem.Slot2) && !CanUseBank())
     {
         TC_LOG_DEBUG("network", "HandleSwapInvItemOpcode - Unit (%s) not found or you can't interact with him.", m_currentBankerGUID.ToString().c_str());
         return;
     }
 
     uint16 src = ((INVENTORY_SLOT_BAG_0 << 8) | swapInvItem.Slot1);
     uint16 dst = ((INVENTORY_SLOT_BAG_0 << 8) | swapInvItem.Slot2);
 
     _player->SwapItem(src, dst);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (swapItem.Inv.Items.size() != 2)
     {
         TC_LOG_ERROR("network", "HandleSwapItem - Invalid itemCount (" SZFMTD ")", swapItem.Inv.Items.size());
         return;
     }
 
     TC_LOG_DEBUG("network", "HandleSwapItem: receive ContainerSlotA: %u, SlotA: %u, ContainerSlotB: %u, SlotB: %u",
         swapItem.ContainerSlotA, swapItem.SlotA, swapItem.ContainerSlotB, swapItem.SlotB);
 
     uint16 src = ((swapItem.ContainerSlotA << 8) | swapItem.SlotA);
     uint16 dst = ((swapItem.ContainerSlotB << 8) | swapItem.SlotB);
 
     // prevent attempt swap same item to current position generated by client at special checting sequence
     if (src == dst)
         return;
 
     if (!_player->IsValidPos(swapItem.ContainerSlotA, swapItem.SlotA, true))
     {
         _player->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND);
         return;
     }
 
     if (!_player->IsValidPos(swapItem.ContainerSlotB, swapItem.SlotB, true))
     {
         _player->SendEquipError(EQUIP_ERR_WRONG_SLOT);
         return;
     }
 
     if (_player->IsBankPos(swapItem.ContainerSlotA, swapItem.SlotA) && !CanUseBank())
     {
         TC_LOG_DEBUG("network", "HandleSwapItem - Unit (%s) not found or you can't interact with him.", m_currentBankerGUID.ToString().c_str());
         return;
     }
 
     if (_player->IsBankPos(swapItem.ContainerSlotB, swapItem.SlotB) && !CanUseBank())
     {
         TC_LOG_DEBUG("network", "HandleSwapItem - Unit (%s) not found or you can't interact with him.", m_currentBankerGUID.ToString().c_str());
         return;
     }
 
     _player->SwapItem(src, dst);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     Group* group = GetPlayer()->GetGroup();
     if (!group)
         return;
 
     ObjectGuid senderGuid = GetPlayer()->GetGUID();
     if (!group->IsLeader(senderGuid) && !group->IsAssistant(senderGuid))
         return;
 
     group->SwapMembersGroups(packet.FirstTarget, packet.SecondTarget);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     Creature* unit = GetPlayer()->GetNPCIfCanInteractWith(packet.Unit, UNIT_NPC_FLAG_TABARDDESIGNER);
     if (!unit)
     {
         TC_LOG_DEBUG("network", "WORLD: HandleTabardVendorActivateOpcode - %s not found or you can not interact with him.", packet.Unit.ToString().c_str());
         return;
     }
 
     // remove fake death
     if (GetPlayer()->HasUnitState(UNIT_STATE_DIED))
         GetPlayer()->RemoveAurasByType(SPELL_AURA_FEIGN_DEATH);
 
     SendTabardVendorActivate(packet.Unit);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     SendTaxiStatus(taxiNodeStatusQuery.UnitGUID);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     // cheating checks
     Creature* unit = GetPlayer()->GetNPCIfCanInteractWith(taxiQueryAvailableNodes.Unit, UNIT_NPC_FLAG_FLIGHTMASTER);
     if (!unit)
     {
         TC_LOG_DEBUG("network", "WORLD: HandleTaxiQueryAvailableNodes - %s not found or you can't interact with him.", taxiQueryAvailableNodes.Unit.ToString().c_str());
         return;
     }
     // remove fake death
     if (GetPlayer()->HasUnitState(UNIT_STATE_DIED))
         GetPlayer()->RemoveAurasByType(SPELL_AURA_FEIGN_DEATH);
 
     // unknown taxi node case
     if (SendLearnNewTaxiNode(unit))
         return;
 
     // known taxi node case
     SendTaxiMenu(unit);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (GetPlayer()->GetMotionMaster()->GetCurrentMovementGeneratorType() == FLIGHT_MOTION_TYPE)
     {
         if (GetPlayer()->m_taxi.RequestEarlyLanding())
         {
             FlightPathMovementGenerator* flight = static_cast<FlightPathMovementGenerator*>(GetPlayer()->GetMotionMaster()->top());
             flight->LoadPath(GetPlayer(), flight->GetPath()[flight->GetCurrentNode()]->NodeIndex);
             flight->Reset(GetPlayer());
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (!_player->IsAlive())
         return;
 
     if (!_player->CanSpeak())
     {
         std::string timeStr = secsToTimeString(m_muteTime - time(NULL));
         SendNotification(GetTrinityString(LANG_WAIT_BEFORE_SPEAKING), timeStr.c_str());
         return;
     }
 
     sScriptMgr->OnPlayerTextEmote(_player, packet.SoundIndex, packet.EmoteID, packet.Target);
 
     EmotesTextEntry const* em = sEmotesTextStore.LookupEntry(packet.EmoteID);
     if (!em)
         return;
 
     uint32 emoteAnim = em->EmoteID;
 
     switch (emoteAnim)
     {
         case EMOTE_STATE_SLEEP:
         case EMOTE_STATE_SIT:
         case EMOTE_STATE_KNEEL:
         case EMOTE_ONESHOT_NONE:
             break;
         case EMOTE_STATE_DANCE:
         case EMOTE_STATE_READ:
             _player->SetUInt32Value(UNIT_NPC_EMOTESTATE, emoteAnim);
             break;
         default:
             // Only allow text-emotes for "dead" entities (feign death included)
             if (_player->HasUnitState(UNIT_STATE_DIED))
                 break;
             _player->HandleEmoteCommand(emoteAnim);
             break;
     }
 
     WorldPackets::Chat::STextEmote textEmote;
     textEmote.SourceGUID = _player->GetGUID();
     textEmote.SourceAccountGUID = GetAccountGUID();
     textEmote.TargetGUID = packet.Target;
     textEmote.EmoteID = packet.EmoteID;
     textEmote.SoundIndex = packet.SoundIndex;
     _player->SendMessageToSetInRange(textEmote.Write(), sWorld->getFloatConfig(CONFIG_LISTEN_RANGE_TEXTEMOTE), true);
 
     Unit* unit = ObjectAccessor::GetUnit(*_player, packet.Target);
 
     _player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_DO_EMOTE, packet.SoundIndex, 0, 0, unit);
 
     // Send scripted event call
     if (unit)
         if (Creature* creature = unit->ToCreature())
             creature->AI()->ReceiveEmote(_player, packet.SoundIndex);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleTimeSyncResponse ( WorldPackets::Misc::TimeSyncResponse & packet )

 {
     // Prevent crashing server if queue is empty
     if (_player->m_timeSyncQueue.empty())
     {
         TC_LOG_ERROR("network", "Received CMSG_TIME_SYNC_RESPONSE from player %s without requesting it (hacker?)", _player->GetName().c_str());
         return;
     }
 
     if (packet.SequenceIndex != _player->m_timeSyncQueue.front())
         TC_LOG_ERROR("network", "Wrong time sync counter from player %s (cheater?)", _player->GetName().c_str());
 
     TC_LOG_DEBUG("network", "Time sync received: counter %u, client ticks %u, time since last sync %u", packet.SequenceIndex, packet.ClientTime, packet.ClientTime - _player->m_timeSyncClient);
 
     uint32 ourTicks = packet.ClientTime + (getMSTime() - _player->m_timeSyncServer);
 
     // diff should be small
     TC_LOG_DEBUG("network", "Our ticks: %u, diff %u, latency %u", ourTicks, ourTicks - packet.ClientTime, GetLatency());
 
     _player->m_timeSyncClient = packet.ClientTime;
     _player->m_timeSyncQueue.pop();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     bool inPvP = GetPlayer()->HasFlag(PLAYER_FLAGS, PLAYER_FLAGS_IN_PVP);
 
     GetPlayer()->ApplyModFlag(PLAYER_FLAGS, PLAYER_FLAGS_IN_PVP, !inPvP);
     GetPlayer()->ApplyModFlag(PLAYER_FLAGS, PLAYER_FLAGS_PVP_TIMER, inPvP);
 
     if (GetPlayer()->HasFlag(PLAYER_FLAGS, PLAYER_FLAGS_IN_PVP))
     {
         if (!GetPlayer()->IsPvP() || GetPlayer()->pvpInfo.EndTimer)
             GetPlayer()->UpdatePvP(true, true);
     }
     else
     {
         if (!GetPlayer()->pvpInfo.IsHostile && GetPlayer()->IsPvP())
             GetPlayer()->pvpInfo.EndTimer = time(nullptr); // start toggle-off
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     // ignore for remote control state
     if (_player->m_mover != _player)
         return;
 
     uint8 slotId = totemDestroyed.Slot;
     slotId += SUMMON_SLOT_TOTEM;
 
     if (slotId >= MAX_TOTEM_SLOT)
         return;
 
     if (!_player->m_SummonSlot[slotId])
         return;
 
     Creature* totem = GetPlayer()->GetMap()->GetCreature(_player->m_SummonSlot[slotId]);
     if (totem && totem->IsTotem() && totem->GetGUID() == totemDestroyed.TotemGUID)
         totem->ToTotem()->UnSummon();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleToySetFavorite ( WorldPackets::Toy::ToySetFavorite & packet )

 {
     _collectionMgr->ToySetFavorite(packet.ItemID, packet.Favorite);
 }

Here is the caller graph for this function:

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

 {
     TC_LOG_DEBUG("network", "WORLD: Received CMSG_TRAINER_BUY_SPELL %s, learn spell id is: %i", packet.TrainerGUID.ToString().c_str(), packet.SpellID);
 
     Creature* unit = GetPlayer()->GetNPCIfCanInteractWith(packet.TrainerGUID, UNIT_NPC_FLAG_TRAINER);
     if (!unit)
     {
         TC_LOG_DEBUG("network", "WORLD: HandleTrainerBuySpellOpcode - %s not found or you can not interact with him.", packet.TrainerGUID.ToString().c_str());
         return;
     }
 
     // remove fake death
     if (GetPlayer()->HasUnitState(UNIT_STATE_DIED))
         GetPlayer()->RemoveAurasByType(SPELL_AURA_FEIGN_DEATH);
 
     // check present spell in trainer spell list
     TrainerSpellData const* trainer_spells = unit->GetTrainerSpells();
     if (!trainer_spells)
     {
         SendTrainerBuyFailed(packet.TrainerGUID, packet.SpellID, 0);
         return;
     }
 
     // not found, cheat?
     TrainerSpell const* trainerSpell = trainer_spells->Find(packet.SpellID);
     if (!trainerSpell)
     {
         SendTrainerBuyFailed(packet.TrainerGUID, packet.SpellID, 0);
         return;
     }
 
     // can't be learn, cheat? Or double learn with lags...
     if (_player->GetTrainerSpellState(trainerSpell) != TRAINER_SPELL_GREEN)
     {
         SendTrainerBuyFailed(packet.TrainerGUID, packet.SpellID, 0);
         return;
     }
 
     // apply reputation discount
     uint32 nSpellCost = uint32(floor(trainerSpell->MoneyCost * _player->GetReputationPriceDiscount(unit)));
 
     // check money requirement
     if (!_player->HasEnoughMoney(uint64(nSpellCost)))
     {
         SendTrainerBuyFailed(packet.TrainerGUID, packet.SpellID, 1);
         return;
     }
 
     _player->ModifyMoney(-int64(nSpellCost));
 
     unit->SendPlaySpellVisualKit(179, 0);       // 53 SpellCastDirected
     _player->SendPlaySpellVisualKit(362, 1);    // 113 EmoteSalute
 
     // learn explicitly or cast explicitly
     if (trainerSpell->IsCastable())
         _player->CastSpell(_player, trainerSpell->SpellID, true);
     else
         _player->LearnSpell(packet.SpellID, false);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     SendTrainerList(packet.Unit);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleTransmogrifyItems ( WorldPackets::Item::TransmogrifyItems & transmogrifyItems )

 {
     Player* player = GetPlayer();
     // Validate
     if (!player->GetNPCIfCanInteractWith(transmogrifyItems.Npc, UNIT_NPC_FLAG_TRANSMOGRIFIER))
     {
         TC_LOG_DEBUG("network", "WORLD: HandleTransmogrifyItems - %s not found or player can't interact with it.", transmogrifyItems.Npc.ToString().c_str());
         return;
     }
 
     int64 cost = 0;
     std::unordered_map<Item*, Item*> transmogItems;
     std::unordered_map<Item*, std::pair<VoidStorageItem*, BonusData>> transmogVoidItems;
     std::vector<Item*> resetAppearanceItems;
 
     for (WorldPackets::Item::TransmogrifyItem const& transmogItem : transmogrifyItems.Items)
     {
         // slot of the transmogrified item
         if (transmogItem.Slot >= EQUIPMENT_SLOT_END)
         {
             TC_LOG_DEBUG("network", "WORLD: HandleTransmogrifyItems - Player (%s, name: %s) tried to transmogrify wrong slot (%u) when transmogrifying items.", player->GetGUID().ToString().c_str(), player->GetName().c_str(), transmogItem.Slot);
             return;
         }
 
         // transmogrified item
         Item* itemTransmogrified = player->GetItemByPos(INVENTORY_SLOT_BAG_0, transmogItem.Slot);
         if (!itemTransmogrified)
         {
             TC_LOG_DEBUG("network", "WORLD: HandleTransmogrifyItems - Player (%s, name: %s) tried to transmogrify an invalid item in a valid slot (slot: %u).", player->GetGUID().ToString().c_str(), player->GetName().c_str(), transmogItem.Slot);
             return;
         }
         if (player->CanUseItem(itemTransmogrified->GetTemplate()) != EQUIP_ERR_OK)
         {
             TC_LOG_DEBUG("network", "WORLD: HandleTransmogrifyItems - Player (%s, name: %s) tried to transmogrify an unequippable item in a valid slot (slot: %u).", player->GetGUID().ToString().c_str(), player->GetName().c_str(), transmogItem.Slot);
             return;
         }
 
         WorldPackets::Item::ItemInstance itemInstance;
         BonusData const* bonus = nullptr;
         if (transmogItem.SrcItemGUID)
         {
             // guid of the transmogrifier item
             Item* itemTransmogrifier = player->GetItemByGuid(*transmogItem.SrcItemGUID);
             if (!itemTransmogrifier)
             {
                 TC_LOG_DEBUG("network", "WORLD: HandleTransmogrifyItems - Player (%s, name: %s) tried to transmogrify with an invalid item (%s).", player->GetGUID().ToString().c_str(), player->GetName().c_str(), transmogItem.SrcItemGUID->ToString().c_str());
                 return;
             }
             if (player->CanUseItem(itemTransmogrifier->GetTemplate()) != EQUIP_ERR_OK)
             {
                 TC_LOG_DEBUG("network", "WORLD: HandleTransmogrifyItems - Player (%s, name: %s) tried to transmogrify with an unequippable item (%s).", player->GetGUID().ToString().c_str(), player->GetName().c_str(), transmogItem.SrcItemGUID->ToString().c_str());
                 return;
             }
 
             itemInstance.Initialize(itemTransmogrifier);
             bonus = itemTransmogrifier->GetBonus();
             transmogItems[itemTransmogrified] = itemTransmogrifier;
         }
         else if (transmogItem.SrcVoidItemGUID)
         {
             // guid of the transmogrifier item
             uint8 slot;
             VoidStorageItem* itemTransmogrifier = player->GetVoidStorageItem(transmogItem.SrcVoidItemGUID->GetCounter(), slot);
             if (!itemTransmogrifier)
             {
                 TC_LOG_DEBUG("network", "WORLD: HandleTransmogrifyItems - Player (%s, name: %s) tried to transmogrify with an invalid void storage item (%s).", player->GetGUID().ToString().c_str(), player->GetName().c_str(), transmogItem.SrcVoidItemGUID->ToString().c_str());
                 return;
             }
             ItemTemplate const * transmogrifierTemplate = sObjectMgr->GetItemTemplate(itemTransmogrifier->ItemEntry);
             if (player->CanUseItem(transmogrifierTemplate) != EQUIP_ERR_OK)
             {
                 TC_LOG_DEBUG("network", "WORLD: HandleTransmogrifyItems - Player (%s, name: %s) tried to transmogrify with an unequippable void storage item (%s).", player->GetGUID().ToString().c_str(), player->GetName().c_str(), transmogItem.SrcVoidItemGUID->ToString().c_str());
                 return;
             }
 
             itemInstance.Initialize(itemTransmogrifier);
             std::pair<VoidStorageItem*, BonusData>& transmogData = transmogVoidItems[itemTransmogrified];
             transmogData.first = itemTransmogrifier;
             transmogData.second.Initialize(itemInstance);
             bonus = &transmogData.second;
         }
         else
         {
             resetAppearanceItems.push_back(itemTransmogrified);
             continue;
         }
 
         // entry of transmogrifier and from packet
         if (itemInstance != transmogItem.Item)
         {
             TC_LOG_DEBUG("network", "WORLD: HandleTransmogrifyItems - Player (%s, name: %s) tried to transmogrify with an invalid item instance data for %s.", player->GetGUID().ToString().c_str(), player->GetName().c_str(), transmogItem.SrcItemGUID->ToString().c_str());
             return;
         }
 
         // validity of the transmogrification items
         if (!Item::CanTransmogrifyItemWithItem(itemTransmogrified, transmogItem.Item, bonus))
         {
             TC_LOG_DEBUG("network", "WORLD: HandleTransmogrifyItems - Player (%s, name: %s) failed CanTransmogrifyItemWithItem (%u with %u).", player->GetGUID().ToString().c_str(), player->GetName().c_str(), itemTransmogrified->GetEntry(), transmogItem.Item.ItemID);
             return;
         }
 
         // add cost
         cost += itemTransmogrified->GetSpecialPrice();
     }
 
     if (cost) // 0 cost if reverting look
     {
         if (!player->HasEnoughMoney(cost))
             return;
         player->ModifyMoney(-cost);
     }
 
     // Everything is fine, proceed
     for (auto& transmogPair : transmogItems)
     {
         Item* transmogrified = transmogPair.first;
         Item* transmogrifier = transmogPair.second;
 
         transmogrified->SetModifier(ITEM_MODIFIER_TRANSMOG_ITEM_ID, transmogrifier->GetEntry());
         transmogrified->SetModifier(ITEM_MODIFIER_TRANSMOG_APPEARANCE_MOD, transmogrifier->GetAppearanceModId());
         player->SetVisibleItemSlot(transmogrified->GetSlot(), transmogrified);
 
         transmogrified->SetNotRefundable(player);
         transmogrified->ClearSoulboundTradeable(player);
 
         transmogrifier->SetNotRefundable(player);
         transmogrifier->ClearSoulboundTradeable(player);
 
         if (transmogrifier->GetTemplate()->GetBonding() == BIND_WHEN_EQUIPED || transmogrifier->GetTemplate()->GetBonding() == BIND_WHEN_USE)
             transmogrifier->SetBinding(true);
     }
 
     for (auto& transmogVoirPair : transmogVoidItems)
     {
         Item* transmogrified = transmogVoirPair.first;
         VoidStorageItem* transmogrifier = transmogVoirPair.second.first;
         BonusData& bonus = transmogVoirPair.second.second;
 
         transmogrified->SetModifier(ITEM_MODIFIER_TRANSMOG_ITEM_ID, transmogrifier->ItemEntry);
         transmogrified->SetModifier(ITEM_MODIFIER_TRANSMOG_APPEARANCE_MOD, bonus.AppearanceModID);
         player->SetVisibleItemSlot(transmogrified->GetSlot(), transmogrified);
 
         transmogrified->SetNotRefundable(player);
         transmogrified->ClearSoulboundTradeable(player);
     }
 
     for (Item* item : resetAppearanceItems)
     {
         item->SetModifier(ITEM_MODIFIER_TRANSMOG_ITEM_ID, 0);
         item->SetModifier(ITEM_MODIFIER_TRANSMOG_APPEARANCE_MOD, 0);
         player->SetVisibleItemSlot(item->GetSlot(), item);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     // Check if player really has the required petition charter
     Item* item = _player->GetItemByGuid(packet.Item);
     if (!item)
         return;
 
     TC_LOG_DEBUG("network", "Petition %s turned in by %s", packet.Item.ToString().c_str(), _player->GetGUID().ToString().c_str());
 
     // Get petition data from db
     ObjectGuid ownerguid;
     std::string name;
 
     PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_PETITION);
     stmt->setUInt64(0, packet.Item.GetCounter());
     PreparedQueryResult result = CharacterDatabase.Query(stmt);
 
     if (result)
     {
         Field* fields = result->Fetch();
         ownerguid = ObjectGuid::Create<HighGuid::Player>(fields[0].GetUInt64());
         name = fields[1].GetString();
     }
     else
     {
         TC_LOG_ERROR("network", "Player %s (%s) tried to turn in petition (%s) that is not present in the database", _player->GetName().c_str(), _player->GetGUID().ToString().c_str(), packet.Item.ToString().c_str());
         return;
     }
 
     // Only the petition owner can turn in the petition
     if (_player->GetGUID() != ownerguid)
         return;
 
     // Check if player is already in a guild
     if (_player->GetGuildId())
     {
         WorldPackets::Petition::TurnInPetitionResult resultPacket;
         resultPacket.Result = int32(PETITION_TURN_ALREADY_IN_GUILD);
         _player->GetSession()->SendPacket(resultPacket.Write());
         return;
     }
 
     // Check if guild name is already taken
     if (sGuildMgr->GetGuildByName(name))
     {
         Guild::SendCommandResult(this, GUILD_COMMAND_CREATE_GUILD, ERR_GUILD_NAME_EXISTS_S, name);
         return;
     }
 
     // Get petition signatures from db
     uint8 signatures;
 
     stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_PETITION_SIGNATURE);
     stmt->setUInt64(0, packet.Item.GetCounter());
     result = CharacterDatabase.Query(stmt);
 
     if (result)
         signatures = uint8(result->GetRowCount());
     else
         signatures = 0;
 
     uint32 requiredSignatures = sWorld->getIntConfig(CONFIG_MIN_PETITION_SIGNS);
 
     // Notify player if signatures are missing
     if (signatures < requiredSignatures)
     {
         WorldPackets::Petition::TurnInPetitionResult resultPacket;
         resultPacket.Result = int32(PETITION_TURN_NEED_MORE_SIGNATURES);
         SendPacket(resultPacket.Write());
         return;
     }
 
     // Proceed with guild creation
 
     // Delete charter item
     _player->DestroyItem(item->GetBagSlot(), item->GetSlot(), true);
 
     // Create guild
     Guild* guild = new Guild;
 
     if (!guild->Create(_player, name))
     {
         delete guild;
         return;
     }
 
     // Register guild and add guild master
     sGuildMgr->AddGuild(guild);
 
     Guild::SendCommandResult(this, GUILD_COMMAND_CREATE_GUILD, ERR_GUILD_COMMAND_SUCCESS, name);
 
     // Add members from signatures
     for (uint8 i = 0; i < signatures; ++i)
     {
         Field* fields = result->Fetch();
         guild->AddMember(ObjectGuid::Create<HighGuid::Player>(fields[0].GetUInt64()));
 
         // Checking the return value just to be double safe
         if (!result->NextRow())
             break;
     }
 
     SQLTransaction trans = CharacterDatabase.BeginTransaction();
 
     stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_PETITION_BY_GUID);
     stmt->setUInt64(0, packet.Item.GetCounter());
     trans->Append(stmt);
 
     stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_PETITION_SIGNATURE_BY_GUID);
     stmt->setUInt64(0, packet.Item.GetCounter());
     trans->Append(stmt);
 
     CharacterDatabase.CommitTransaction(trans);
 
     // created
     TC_LOG_DEBUG("network", "Player %s (%s) turning in petition %s", _player->GetName().c_str(), _player->GetGUID().ToString().c_str(), packet.Item.ToString().c_str());
 
     WorldPackets::Petition::TurnInPetitionResult resultPacket;
     resultPacket.Result = int32(PETITION_TURN_OK);
     SendPacket(resultPacket.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     switch (packet.Action)
     {
         case TUTORIAL_ACTION_UPDATE:
         {
             uint8 index = uint8(packet.TutorialBit >> 5);
             if (index >= MAX_ACCOUNT_TUTORIAL_VALUES)
             {
                 TC_LOG_ERROR("network", "CMSG_TUTORIAL_FLAG received bad TutorialBit %u.", packet.TutorialBit);
                 return;
             }
             uint32 flag = GetTutorialInt(index);
             flag |= (1 << (packet.TutorialBit & 0x1F));
             SetTutorialInt(index, flag);
             break;
         }
         case TUTORIAL_ACTION_CLEAR:
             for (uint8 i = 0; i < MAX_ACCOUNT_TUTORIAL_VALUES; ++i)
                 SetTutorialInt(i, 0xFFFFFFFF);
             break;
         case TUTORIAL_ACTION_RESET:
             for (uint8 i = 0; i < MAX_ACCOUNT_TUTORIAL_VALUES; ++i)
                 SetTutorialInt(i, 0x00000000);
             break;
         default:
             TC_LOG_ERROR("network", "CMSG_TUTORIAL_FLAG received unknown TutorialAction %u.", packet.Action);
             return;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleUITimeRequest ( WorldPackets::Misc::UITimeRequest & )

 {
     WorldPackets::Misc::UITime response;
     response.Time = time(NULL);
     SendPacket(response.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     TradeData* my_trade = _player->GetTradeData();
     if (!my_trade)
         return;
 
     my_trade->SetAccepted(false, true);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleUndeleteCooldownStatusCallback ( PreparedQueryResult result )

 {
     switch (_undeleteCooldownStatusCallback.GetStage())
     {
         case 0:
         {
             PreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_LAST_CHAR_UNDELETE);
             stmt->setUInt32(0, GetBattlenetAccountId());
 
             _undeleteCooldownStatusCallback.FreeResult();
             _undeleteCooldownStatusCallback.SetFutureResult(LoginDatabase.AsyncQuery(stmt));
             _undeleteCooldownStatusCallback.NextStage();
             break;
         }
         case 1:
         {
             uint32 cooldown = 0;
             uint32 maxCooldown = sWorld->getIntConfig(CONFIG_FEATURE_SYSTEM_CHARACTER_UNDELETE_COOLDOWN);
             if (result)
             {
                 uint32 lastUndelete = result->Fetch()[0].GetUInt32();
                 uint32 now = uint32(time(nullptr));
                 if (lastUndelete + maxCooldown > now)
                     cooldown = std::max<uint32>(0, lastUndelete + maxCooldown - now);
             }
 
             SendUndeleteCooldownStatusResponse(cooldown, maxCooldown);
             _undeleteCooldownStatusCallback.Reset();
             break;
         }
     }
 
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     SkillRaceClassInfoEntry const* rcEntry = GetSkillRaceClassInfo(packet.SkillLine, GetPlayer()->getRace(), GetPlayer()->getClass());
     if (!rcEntry || !(rcEntry->Flags & SKILL_FLAG_UNLEARNABLE))
         return;
 
     GetPlayer()->SetSkill(packet.SkillLine, 0, 0, 0);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     _registeredAddonPrefixes.clear();
 }

Here is the caller graph for this function:

void WorldSession::HandleUnstablePet ( WorldPacket & recvPacket )

 {
     ObjectGuid npcGUID;
     uint32 petnumber;
 
     recvData >> npcGUID >> petnumber;
 
     if (!CheckStableMaster(npcGUID))
     {
         SendPetStableResult(STABLE_ERR_STABLE);
         return;
     }
 
     // remove fake death
     if (GetPlayer()->HasUnitState(UNIT_STATE_DIED))
         GetPlayer()->RemoveAurasByType(SPELL_AURA_FEIGN_DEATH);
 
     PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_PET_ENTRY);
 
     stmt->setUInt64(0, _player->GetGUID().GetCounter());
     stmt->setUInt32(1, petnumber);
     stmt->setUInt8(2, PET_SAVE_FIRST_STABLE_SLOT);
     stmt->setUInt8(3, PET_SAVE_LAST_STABLE_SLOT);
 
     _unstablePetCallback.SetParam(petnumber);
     _unstablePetCallback.SetFutureResult(CharacterDatabase.AsyncQuery(stmt));
 }

Here is the call graph for this function:

void WorldSession::HandleUnstablePetCallback	(	PreparedQueryResult	result,
		uint32	petId
	)

 {
     if (!GetPlayer())
         return;
 
     uint32 petEntry = 0;
     if (result)
     {
         Field* fields = result->Fetch();
         petEntry = fields[0].GetUInt32();
     }
 
     if (!petEntry)
     {
         SendPetStableResult(STABLE_ERR_STABLE);
         return;
     }
 
     CreatureTemplate const* creatureInfo = sObjectMgr->GetCreatureTemplate(petEntry);
     if (!creatureInfo || !creatureInfo->IsTameable(_player->CanTameExoticPets()))
     {
         // if problem in exotic pet
         if (creatureInfo && creatureInfo->IsTameable(true))
             SendPetStableResult(STABLE_ERR_EXOTIC);
         else
             SendPetStableResult(STABLE_ERR_STABLE);
         return;
     }
 
     Pet* pet = _player->GetPet();
     if (pet && pet->IsAlive())
     {
         SendPetStableResult(STABLE_ERR_STABLE);
         return;
     }
 
     // delete dead pet
     if (pet)
         _player->RemovePet(pet, PET_SAVE_AS_DELETED);
 
     Pet* newPet = new Pet(_player, HUNTER_PET);
     if (!newPet->LoadPetFromDB(_player, petEntry, petId))
     {
         delete newPet;
         newPet = NULL;
         SendPetStableResult(STABLE_ERR_STABLE);
         return;
     }
 
     SendPetStableResult(STABLE_SUCCESS_UNSTABLE);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     TC_LOG_DEBUG("network", "WORLD: Received CMSG_UPDATE_ACCOUNT_DATA: type %u, time %u, decompressedSize %u",
         packet.DataType, packet.Time, packet.Size);
 
     if (packet.DataType > NUM_ACCOUNT_DATA_TYPES)
         return;
 
     if (packet.Size == 0)                               // erase
     {
         SetAccountData(AccountDataType(packet.DataType), 0, "");
         return;
     }
 
     if (packet.Size > 0xFFFF)
     {
         TC_LOG_ERROR("network", "UAD: Account data packet too big, size %u", packet.Size);
         return;
     }
 
     ByteBuffer dest;
     dest.resize(packet.Size);
 
     uLongf realSize = packet.Size;
     if (uncompress(dest.contents(), &realSize, packet.CompressedData.contents(), packet.CompressedData.size()) != Z_OK)
     {
         TC_LOG_ERROR("network", "UAD: Failed to decompress account data");
         return;
     }
 
     std::string adata;
     dest >> adata;
 
     SetAccountData(AccountDataType(packet.DataType), packet.Time, adata);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleUpdateListedAuctionableTokens ( WorldPackets::Token::UpdateListedAuctionableTokens & updateListedAuctionableTokens )

Todo:: : 6.x fix implementation

 {
     WorldPackets::Token::UpdateListedAuctionableTokensResponse response;
 
     response.UnkInt = updateListedAuctionableTokens.UnkInt;
     response.Result = TOKEN_RESULT_SUCCESS;
 
     SendPacket(response.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     Unit* caster = ObjectAccessor::GetUnit(*_player, packet.Guid);
     Spell* spell = caster ? caster->GetCurrentSpell(CURRENT_GENERIC_SPELL) : NULL;
     if (!spell || spell->m_spellInfo->Id != uint32(packet.SpellID) || !spell->m_targets.HasDst() || !spell->m_targets.HasSrc())
         return;
 
     Position pos = *spell->m_targets.GetSrcPos();
     pos.Relocate(packet.FirePos);
     spell->m_targets.ModSrc(pos);
 
     pos = *spell->m_targets.GetDstPos();
     pos.Relocate(packet.ImpactPos);
     spell->m_targets.ModDst(pos);
 
     spell->m_targets.SetPitch(packet.Pitch);
     spell->m_targets.SetSpeed(packet.Speed);
 
     if (packet.Status.is_initialized())
     {
         GetPlayer()->ValidateMovementInfo(packet.Status.get_ptr());
         /*uint32 opcode;
         recvPacket >> opcode;
         recvPacket.SetOpcode(CMSG_MOVE_STOP); // always set to CMSG_MOVE_STOP in client SetOpcode
                                               //HandleMovementOpcodes(recvPacket);*/
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     Group* group = GetPlayer()->GetGroup();
     if (!group)
         return;
 
     if (packet.Symbol == -1)                  // target icon request
         group->SendTargetIconList(this, packet.PartyIndex);
     else                                        // target icon update
     {
         if (group->isRaidGroup() && !group->IsLeader(GetPlayer()->GetGUID()) && !group->IsAssistant(GetPlayer()->GetGUID()))
             return;
 
         if (packet.Target.IsPlayer())
         {
             Player* target = ObjectAccessor::FindConnectedPlayer(packet.Target);
             if (!target || target->IsHostileTo(GetPlayer()))
                 return;
         }
 
         group->SetTargetIcon(packet.Symbol, packet.Target, GetPlayer()->GetGUID(), packet.PartyIndex);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     Item* item = _player->GetItemByGuid(useCritterItem.ItemGuid);
     if (!item)
         return;
 
     ItemToBattlePetSpeciesEntry const* itemToBattlePetSpecies = sItemToBattlePetSpeciesStore.LookupEntry(item->GetEntry());
     if (!itemToBattlePetSpecies)
         return;
 
     BattlePetSpeciesEntry const* battlePetSpecies = sBattlePetSpeciesStore.LookupEntry(itemToBattlePetSpecies->BattlePetSpeciesID);
     if (!battlePetSpecies)
         return;
 
     GetBattlePetMgr()->AddPet(battlePetSpecies->ID, battlePetSpecies->CreatureID, BattlePetMgr::RollPetBreed(battlePetSpecies->ID), BattlePetMgr::GetDefaultPetQuality(battlePetSpecies->ID));
     _player->DestroyItem(item->GetBagSlot(), item->GetSlot(), true);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     ObjectGuid ignoredItemGuid;
     ignoredItemGuid.SetRawValue(0, 1);
 
     for (uint8 i = 0; i < EQUIPMENT_SLOT_END; ++i)
     {
         TC_LOG_DEBUG("entities.player.items", "%s: ContainerSlot: %u, Slot: %u", useEquipmentSet.Items[i].Item.ToString().c_str(), useEquipmentSet.Items[i].ContainerSlot, useEquipmentSet.Items[i].Slot);
 
         // check if item slot is set to "ignored" (raw value == 1), must not be unequipped then
         if (useEquipmentSet.Items[i].Item == ignoredItemGuid)
             continue;
 
         // Only equip weapons in combat
         if (_player->IsInCombat() && i != EQUIPMENT_SLOT_MAINHAND && i != EQUIPMENT_SLOT_OFFHAND)
             continue;
 
         Item* item = _player->GetItemByGuid(useEquipmentSet.Items[i].Item);
 
         uint16 dstPos = i | (INVENTORY_SLOT_BAG_0 << 8);
 
         if (!item)
         {
             Item* uItem = _player->GetItemByPos(INVENTORY_SLOT_BAG_0, i);
             if (!uItem)
                 continue;
 
             ItemPosCountVec itemPosCountVec;
             InventoryResult inventoryResult = _player->CanStoreItem(NULL_BAG, NULL_SLOT, itemPosCountVec, uItem, false);
             if (inventoryResult == EQUIP_ERR_OK)
             {
                 _player->RemoveItem(INVENTORY_SLOT_BAG_0, i, true);
                 _player->StoreItem(itemPosCountVec, uItem, true);
             }
             else
                 _player->SendEquipError(inventoryResult, uItem,  NULL);
             continue;
         }
 
         if (item->GetPos() == dstPos)
             continue;
 
         _player->SwapItem(item->GetPos(), dstPos);
     }
 
     WorldPackets::EquipmentSet::UseEquipmentSetResult result;
     result.Reason = 0; // 4 - equipment swap failed - inventory is full
     SendPacket(result.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     Player* user = _player;
 
     // ignore for remote control state
     if (user->m_mover != user)
         return;
 
     Item* item = user->GetUseableItemByPos(packet.PackSlot, packet.Slot);
     if (!item)
     {
         user->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, NULL, NULL);
         return;
     }
 
     if (item->GetGUID() != packet.CastItem)
     {
         user->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, NULL, NULL);
         return;
     }
 
     ItemTemplate const* proto = item->GetTemplate();
     if (!proto)
     {
         user->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, item, NULL);
         return;
     }
 
     // some item classes can be used only in equipped state
     if (proto->GetInventoryType() != INVTYPE_NON_EQUIP && !item->IsEquipped())
     {
         user->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, item, NULL);
         return;
     }
 
     InventoryResult msg = user->CanUseItem(item);
     if (msg != EQUIP_ERR_OK)
     {
         user->SendEquipError(msg, item, NULL);
         return;
     }
 
     // only allow conjured consumable, bandage, poisons (all should have the 2^21 item flag set in DB)
     if (proto->GetClass() == ITEM_CLASS_CONSUMABLE && !(proto->GetFlags() & ITEM_FLAG_USEABLE_IN_ARENA) && user->InArena())
     {
         user->SendEquipError(EQUIP_ERR_NOT_DURING_ARENA_MATCH, item, NULL);
         return;
     }
 
     // don't allow items banned in arena
     if (proto->GetFlags() & ITEM_FLAG_NOT_USEABLE_IN_ARENA && user->InArena())
     {
         user->SendEquipError(EQUIP_ERR_NOT_DURING_ARENA_MATCH, item, NULL);
         return;
     }
 
     if (user->IsInCombat())
     {
         for (uint32 i = 0; i < proto->Effects.size(); ++i)
         {
             if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(proto->Effects[i]->SpellID))
             {
                 if (!spellInfo->CanBeUsedInCombat())
                 {
                     user->SendEquipError(EQUIP_ERR_NOT_IN_COMBAT, item, NULL);
                     return;
                 }
             }
         }
     }
 
     // check also  BIND_WHEN_PICKED_UP and BIND_QUEST_ITEM for .additem or .additemset case by GM (not binded at adding to inventory)
     if (item->GetTemplate()->GetBonding() == BIND_WHEN_USE || item->GetTemplate()->GetBonding() == BIND_WHEN_PICKED_UP || item->GetTemplate()->GetBonding() == BIND_QUEST_ITEM)
     {
         if (!item->IsSoulBound())
         {
             item->SetState(ITEM_CHANGED, user);
             item->SetBinding(true);
         }
     }
 
     SpellCastTargets targets(user, packet.Cast);
 
     // Note: If script stop casting it must send appropriate data to client to prevent stuck item in gray state.
     if (!sScriptMgr->OnItemUse(user, item, targets))
     {
         // no script or script not process request by self
         user->CastItemUseSpell(item, targets, packet.Cast.CastID, packet.Cast.Misc);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     ItemTemplate const* item = sObjectMgr->GetItemTemplate(packet.ItemID);
     if (!item)
         return;
 
     SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(packet.Cast.SpellID);
     if (!spellInfo)
     {
         TC_LOG_ERROR("network", "HandleUseToy: unknown spell id: %u used by Toy Item entry %u", packet.Cast.SpellID, packet.ItemID);
         return;
     }
 
     if (_player->isPossessing())
         return;
 
     SpellCastTargets targets(_player, packet.Cast);
 
     Spell* spell = new Spell(_player, spellInfo, TRIGGERED_NONE, ObjectGuid::Empty, false);
     spell->m_castItemEntry = packet.ItemID;
     spell->m_cast_count = packet.Cast.CastID;
     spell->m_misc.Raw.Data[0] = packet.Cast.Misc[0];
     spell->m_misc.Raw.Data[1] = packet.Cast.Misc[1];
     spell->m_castFlagsEx |= CAST_FLAG_EX_USE_TOY_SPELL;
     spell->prepare(&targets);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     // do something?
 }

Here is the caller graph for this function:

void WorldSession::HandleVoiceSessionEnable ( WorldPackets::Voice::VoiceSessionEnable & packet )

23 {

24 }

Here is the caller graph for this function:

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

 {
     Creature* unit = _player->GetNPCIfCanInteractWith(queryVoidStorage.Npc, UNIT_NPC_FLAG_TRANSMOGRIFIER | UNIT_NPC_FLAG_VAULTKEEPER);
     if (!unit)
     {
         TC_LOG_DEBUG("network", "WORLD: HandleVoidStorageQuery - %s not found or player can't interact with it.", queryVoidStorage.Npc.ToString().c_str());
         SendPacket(WorldPackets::VoidStorage::VoidStorageFailed().Write());
         return;
     }
 
     if (!_player->IsVoidStorageUnlocked())
     {
         TC_LOG_DEBUG("network", "WORLD: HandleVoidStorageQuery - Player (%s, name: %s) queried void storage without unlocking it.", _player->GetGUID().ToString().c_str(), _player->GetName().c_str());
         SendPacket(WorldPackets::VoidStorage::VoidStorageFailed().Write());
         return;
     }
 
     uint8 count = 0;
     for (uint8 i = 0; i < VOID_STORAGE_MAX_SLOT; ++i)
         if (_player->GetVoidStorageItem(i))
             ++count;
 
     WorldPackets::VoidStorage::VoidStorageContents voidStorageContents;
     voidStorageContents.Items.reserve(VOID_STORAGE_MAX_SLOT);
 
     for (uint8 i = 0; i < VOID_STORAGE_MAX_SLOT; ++i)
     {
         VoidStorageItem* item = _player->GetVoidStorageItem(i);
         if (!item)
             continue;
 
         WorldPackets::VoidStorage::VoidItem voidItem;
         voidItem.Guid = ObjectGuid::Create<HighGuid::Item>(item->ItemId);
         voidItem.Creator = item->CreatorGuid;
         voidItem.Slot = i;
         voidItem.Item.Initialize(item);
 
         voidStorageContents.Items.push_back(voidItem);
     }
 
     SendPacket(voidStorageContents.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     Creature* unit = _player->GetNPCIfCanInteractWith(voidStorageTransfer.Npc, UNIT_NPC_FLAG_VAULTKEEPER);
     if (!unit)
     {
         TC_LOG_DEBUG("network", "WORLD: HandleVoidStorageTransfer - %s not found or player can't interact with it.", voidStorageTransfer.Npc.ToString().c_str());
         return;
     }
 
     if (!_player->IsVoidStorageUnlocked())
     {
         TC_LOG_DEBUG("network", "WORLD: HandleVoidStorageTransfer - Player (%s, name: %s) queried void storage without unlocking it.", _player->GetGUID().ToString().c_str(), _player->GetName().c_str());
         return;
     }
 
     if (voidStorageTransfer.Deposits.size() > _player->GetNumOfVoidStorageFreeSlots())
     {
         SendVoidStorageTransferResult(VOID_TRANSFER_ERROR_FULL);
         return;
     }
 
     uint32 freeBagSlots = 0;
     if (!voidStorageTransfer.Withdrawals.empty())
     {
         // make this a Player function
         for (uint8 i = INVENTORY_SLOT_BAG_START; i < INVENTORY_SLOT_BAG_END; i++)
             if (Bag* bag = _player->GetBagByPos(i))
                 freeBagSlots += bag->GetFreeSlots();
 
         for (uint8 i = INVENTORY_SLOT_ITEM_START; i < INVENTORY_SLOT_ITEM_END; i++)
             if (!_player->GetItemByPos(INVENTORY_SLOT_BAG_0, i))
                 ++freeBagSlots;
     }
 
     if (voidStorageTransfer.Withdrawals.size() > freeBagSlots)
     {
         SendVoidStorageTransferResult(VOID_TRANSFER_ERROR_INVENTORY_FULL);
         return;
     }
 
     if (!_player->HasEnoughMoney(uint64(voidStorageTransfer.Deposits.size() * VOID_STORAGE_STORE_ITEM_COST)))
     {
         SendVoidStorageTransferResult(VOID_TRANSFER_ERROR_NOT_ENOUGH_MONEY);
         return;
     }
 
     WorldPackets::VoidStorage::VoidStorageTransferChanges voidStorageTransferChanges;
     voidStorageTransferChanges.AddedItems.reserve(VOID_STORAGE_MAX_DEPOSIT);
     voidStorageTransferChanges.RemovedItems.reserve(VOID_STORAGE_MAX_DEPOSIT);
 
     uint8 depositCount = 0;
     for (uint32 i = 0; i < voidStorageTransfer.Deposits.size(); ++i)
     {
         Item* item = _player->GetItemByGuid(voidStorageTransfer.Deposits[i]);
         if (!item)
         {
             TC_LOG_DEBUG("network", "WORLD: HandleVoidStorageTransfer - %s %s wants to deposit an invalid item (%s).", _player->GetGUID().ToString().c_str(), _player->GetName().c_str(), voidStorageTransfer.Deposits[i].ToString().c_str());
             continue;
         }
 
         VoidStorageItem itemVS(sObjectMgr->GenerateVoidStorageItemId(), item->GetEntry(), item->GetGuidValue(ITEM_FIELD_CREATOR),
             item->GetItemRandomPropertyId(), item->GetItemSuffixFactor(), item->GetModifier(ITEM_MODIFIER_UPGRADE_ID), item->GetDynamicValues(ITEM_DYNAMIC_FIELD_BONUSLIST_IDS));
 
         WorldPackets::VoidStorage::VoidItem voidItem;
         voidItem.Guid = ObjectGuid::Create<HighGuid::Item>(itemVS.ItemId);
         voidItem.Creator = item->GetGuidValue(ITEM_FIELD_CREATOR);
         voidItem.Item.Initialize(&itemVS);
         voidItem.Slot = _player->AddVoidStorageItem(std::move(itemVS));
 
         voidStorageTransferChanges.AddedItems.push_back(voidItem);
 
         _player->DestroyItem(item->GetBagSlot(), item->GetSlot(), true);
         ++depositCount;
     }
 
     int64 cost = depositCount * VOID_STORAGE_STORE_ITEM_COST;
 
     _player->ModifyMoney(-cost);
 
     for (uint32 i = 0; i < voidStorageTransfer.Withdrawals.size(); ++i)
     {
         uint8 slot = 0;
         VoidStorageItem* itemVS = _player->GetVoidStorageItem(voidStorageTransfer.Withdrawals[i].GetCounter(), slot);
         if (!itemVS)
         {
             TC_LOG_DEBUG("network", "WORLD: HandleVoidStorageTransfer - %s %s tried to withdraw an invalid item (id: %s)", _player->GetGUID().ToString().c_str(), _player->GetName().c_str(), voidStorageTransfer.Withdrawals[i].ToString().c_str());
             continue;
         }
 
         ItemPosCountVec dest;
         InventoryResult msg = _player->CanStoreNewItem(NULL_BAG, NULL_SLOT, dest, itemVS->ItemEntry, 1);
         if (msg != EQUIP_ERR_OK)
         {
             SendVoidStorageTransferResult(VOID_TRANSFER_ERROR_INVENTORY_FULL);
             TC_LOG_DEBUG("network", "WORLD: HandleVoidStorageTransfer - %s %s couldn't withdraw item id %s because inventory was full.", _player->GetGUID().ToString().c_str(), _player->GetName().c_str(), voidStorageTransfer.Withdrawals[i].ToString().c_str());
             return;
         }
 
         Item* item = _player->StoreNewItem(dest, itemVS->ItemEntry, true, itemVS->ItemRandomPropertyId, GuidSet(), itemVS->BonusListIDs);
         item->SetUInt32Value(ITEM_FIELD_PROPERTY_SEED, itemVS->ItemSuffixFactor);
         item->SetGuidValue(ITEM_FIELD_CREATOR, itemVS->CreatorGuid);
         item->SetModifier(ITEM_MODIFIER_UPGRADE_ID, itemVS->ItemUpgradeId);
         item->SetBinding(true);
 
         voidStorageTransferChanges.RemovedItems.push_back(ObjectGuid::Create<HighGuid::Item>(itemVS->ItemId));
 
         _player->DeleteVoidStorageItem(slot);
     }
 
     SendPacket(voidStorageTransferChanges.Write());
 
     SendVoidStorageTransferResult(VOID_TRANSFER_ERROR_NO_ERROR);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     Creature* unit = _player->GetNPCIfCanInteractWith(unlockVoidStorage.Npc, UNIT_NPC_FLAG_VAULTKEEPER);
     if (!unit)
     {
         TC_LOG_DEBUG("network", "WORLD: HandleVoidStorageUnlock - %s not found or player can't interact with it.", unlockVoidStorage.Npc.ToString().c_str());
         return;
     }
 
     if (_player->IsVoidStorageUnlocked())
     {
         TC_LOG_DEBUG("network", "WORLD: HandleVoidStorageUnlock - Player (%s, name: %s) tried to unlock void storage a 2nd time.", _player->GetGUID().ToString().c_str(), _player->GetName().c_str());
         return;
     }
 
     _player->ModifyMoney(-int64(VOID_STORAGE_UNLOCK_COST));
     _player->UnlockVoidStorage();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     Creature* unit = _player->GetNPCIfCanInteractWith(swapVoidItem.Npc, UNIT_NPC_FLAG_VAULTKEEPER);
     if (!unit)
     {
         TC_LOG_DEBUG("network", "WORLD: HandleVoidSwapItem - %s not found or player can't interact with it.", swapVoidItem.Npc.ToString().c_str());
         return;
     }
 
     if (!_player->IsVoidStorageUnlocked())
     {
         TC_LOG_DEBUG("network", "WORLD: HandleVoidSwapItem - Player (%s, name: %s) queried void storage without unlocking it.", _player->GetGUID().ToString().c_str(), _player->GetName().c_str());
         return;
     }
 
     uint8 oldSlot;
     if (!_player->GetVoidStorageItem(swapVoidItem.VoidItemGuid.GetCounter(), oldSlot))
     {
         TC_LOG_DEBUG("network", "WORLD: HandleVoidSwapItem - %s %s requested swapping an invalid item (slot: %u, itemid: %s).", _player->GetGUID().ToString().c_str(), _player->GetName().c_str(), swapVoidItem.DstSlot, swapVoidItem.VoidItemGuid.ToString().c_str());
         return;
     }
 
     bool usedDestSlot = _player->GetVoidStorageItem(swapVoidItem.DstSlot) != NULL;
     ObjectGuid itemIdDest;
     if (usedDestSlot)
         itemIdDest = ObjectGuid::Create<HighGuid::Item>(_player->GetVoidStorageItem(swapVoidItem.DstSlot)->ItemId);
 
     if (!_player->SwapVoidStorageItem(oldSlot, swapVoidItem.DstSlot))
     {
         SendVoidStorageTransferResult(VOID_TRANSFER_ERROR_INTERNAL_ERROR_1);
         return;
     }
 
     WorldPackets::VoidStorage::VoidItemSwapResponse voidItemSwapResponse;
     voidItemSwapResponse.VoidItemA = swapVoidItem.VoidItemGuid;
     voidItemSwapResponse.VoidItemSlotA = swapVoidItem.DstSlot;
     if (usedDestSlot)
     {
         voidItemSwapResponse.VoidItemB = itemIdDest;
         voidItemSwapResponse.VoidItemSlotB = oldSlot;
     }
 
     SendPacket(voidItemSwapResponse.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (!_warden || packet.Data.empty())
         return;
 
     _warden->DecryptData(packet.Data.contents(), packet.Data.size());
     uint8 opcode;
     packet.Data >> opcode;
     TC_LOG_DEBUG("warden", "Got packet, opcode %02X, size %u", opcode, uint32(packet.Data.size()));
     packet.Data.hexlike();
 
     switch (opcode)
     {
         case WARDEN_CMSG_MODULE_MISSING:
             _warden->SendModuleToClient();
             break;
         case WARDEN_CMSG_MODULE_OK:
             _warden->RequestHash();
             break;
         case WARDEN_CMSG_CHEAT_CHECKS_RESULT:
             _warden->HandleData(packet.Data);
             break;
         case WARDEN_CMSG_MEM_CHECKS_RESULT:
             TC_LOG_DEBUG("warden", "NYI WARDEN_CMSG_MEM_CHECKS_RESULT received!");
             break;
         case WARDEN_CMSG_HASH_RESULT:
             _warden->HandleHashResult(packet.Data);
             _warden->InitializeModule();
             break;
         case WARDEN_CMSG_MODULE_FAILED:
             TC_LOG_DEBUG("warden", "NYI WARDEN_CMSG_MODULE_FAILED received!");
             break;
         default:
             TC_LOG_DEBUG("warden", "Got unknown warden opcode %02X of size %u.", opcode, uint32(packet.Data.size() - 1));
             break;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     TC_LOG_DEBUG("network", "Received whois command from player %s for character %s",
         GetPlayer()->GetName().c_str(), packet.CharName.c_str());
 
     if (!HasPermission(rbac::RBAC_PERM_OPCODE_WHOIS))
     {
         SendNotification(LANG_YOU_NOT_HAVE_PERMISSION);
         return;
     }
 
     if (packet.CharName.empty() || !normalizePlayerName(packet.CharName))
     {
         SendNotification(LANG_NEED_CHARACTER_NAME);
         return;
     }
 
     Player* player = ObjectAccessor::FindConnectedPlayerByName(packet.CharName);
     if (!player)
     {
         SendNotification(LANG_PLAYER_NOT_EXIST_OR_OFFLINE, packet.CharName.c_str());
         return;
     }
 
     PreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_ACCOUNT_WHOIS);
     stmt->setUInt32(0, player->GetSession()->GetAccountId());
 
     PreparedQueryResult result = LoginDatabase.Query(stmt);
     if (!result)
     {
         SendNotification(LANG_ACCOUNT_FOR_PLAYER_NOT_FOUND, packet.CharName.c_str());
         return;
     }
 
     Field* fields = result->Fetch();
     std::string acc = fields[0].GetString();
     if (acc.empty())
         acc = "Unknown";
 
     std::string email = fields[1].GetString();
     if (email.empty())
         email = "Unknown";
 
     std::string lastip = fields[2].GetString();
     if (lastip.empty())
         lastip = "Unknown";
 
     WorldPackets::Who::WhoIsResponse response;
     response.AccountName = packet.CharName + "'s " + "account is " + acc + ", e-mail: " + email + ", last ip: " + lastip;
     SendPacket(response.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Todo:: : handle following packet values VirtualRealmNames ShowEnemies ShowArenaPlayers ExactName ServerInfo

 {
     WorldPackets::Who::WhoRequest& request = whoRequest.Request;
 
     TC_LOG_DEBUG("network", "WorldSession::HandleWhoOpcode: MinLevel: %u, MaxLevel: %u, Name: %s (VirtualRealmName: %s), Guild: %s (GuildVirtualRealmName: %s), RaceFilter: %d, ClassFilter: %d, Areas: " SZFMTD ", Words: " SZFMTD ".",
         request.MinLevel, request.MaxLevel, request.Name.c_str(), request.VirtualRealmName.c_str(), request.Guild.c_str(), request.GuildVirtualRealmName.c_str(),
         request.RaceFilter, request.ClassFilter, whoRequest.Areas.size(), request.Words.size());
 
     // zones count, client limit = 10 (2.0.10)
     // can't be received from real client or broken packet
     if (whoRequest.Areas.size() > 10)
         return;
 
     // user entered strings count, client limit=4 (checked on 2.0.10)
     // can't be received from real client or broken packet
     if (request.Words.size() > 4)
         return;
 
 
     std::vector<std::wstring> wWords;
     wWords.resize(request.Words.size());
     for (size_t i = 0; i < request.Words.size(); ++i)
     {
         TC_LOG_DEBUG("network", "WorldSession::HandleWhoOpcode: Word: %s", request.Words[i].Word.c_str());
 
         // user entered string, it used as universal search pattern(guild+player name)?
         if (!Utf8toWStr(request.Words[i].Word, wWords[i]))
             continue;
 
         wstrToLower(wWords[i]);
     }
 
     std::wstring wPlayerName;
     std::wstring wGuildName;
 
     if (!(Utf8toWStr(request.Name, wPlayerName) && Utf8toWStr(request.Guild, wGuildName)))
         return;
 
     wstrToLower(wPlayerName);
     wstrToLower(wGuildName);
 
     // client send in case not set max level value 100 but Trinity supports 255 max level,
     // update it to show GMs with characters after 100 level
     if (whoRequest.Request.MaxLevel >= MAX_LEVEL)
         whoRequest.Request.MaxLevel = STRONG_MAX_LEVEL;
 
     uint32 team = _player->GetTeam();
 
     uint32 gmLevelInWhoList  = sWorld->getIntConfig(CONFIG_GM_LEVEL_IN_WHO_LIST);
 
     WorldPackets::Who::WhoResponsePkt response;
 
     boost::shared_lock<boost::shared_mutex> lock(*HashMapHolder<Player>::GetLock());
 
     HashMapHolder<Player>::MapType const& m = ObjectAccessor::GetPlayers();
     for (HashMapHolder<Player>::MapType::const_iterator itr = m.begin(); itr != m.end(); ++itr)
     {
         Player* target = itr->second;
         // player can see member of other team only if has RBAC_PERM_TWO_SIDE_WHO_LIST
         if (target->GetTeam() != team && !HasPermission(rbac::RBAC_PERM_TWO_SIDE_WHO_LIST))
             continue;
 
         // player can see MODERATOR, GAME MASTER, ADMINISTRATOR only if has RBAC_PERM_WHO_SEE_ALL_SEC_LEVELS
         if (target->GetSession()->GetSecurity() > AccountTypes(gmLevelInWhoList) && !HasPermission(rbac::RBAC_PERM_WHO_SEE_ALL_SEC_LEVELS))
             continue;
 
         // do not process players which are not in world
         if (!target->IsInWorld())
             continue;
 
         // check if target is globally visible for player
         if (!target->IsVisibleGloballyFor(_player))
             continue;
 
         // check if target's level is in level range
         uint8 lvl = target->getLevel();
         if (lvl < request.MinLevel || lvl > request.MaxLevel)
             continue;
 
         // check if class matches classmask
         if (request.ClassFilter >= 0 && !(request.ClassFilter & (1 << target->getClass())))
             continue;
 
         // check if race matches racemask
         if (request.RaceFilter >= 0 && !(request.RaceFilter & (1 << target->getRace())))
             continue;
 
         if (!whoRequest.Areas.empty())
         {
             if (std::find(whoRequest.Areas.begin(), whoRequest.Areas.end(), target->GetZoneId()) == whoRequest.Areas.end())
                 continue;
         }
 
         std::wstring wTargetName;
 
         if (!Utf8toWStr(target->GetName(), wTargetName))
             continue;
 
         wstrToLower(wTargetName);
 
         if (!wPlayerName.empty() && wTargetName.find(wPlayerName) == std::wstring::npos)
             continue;
 
         Guild* targetGuild = target->GetGuild();
         std::wstring wTargetGuildName;
 
         if (!Utf8toWStr(targetGuild ? targetGuild->GetName() : "", wTargetGuildName))
             continue;
 
         wstrToLower(wTargetGuildName);
 
         if (!wGuildName.empty() && wTargetGuildName.find(wGuildName) == std::wstring::npos)
             continue;
 
         if (!wWords.empty())
         {
             std::string aName;
             if (AreaTableEntry const* areaEntry = sAreaTableStore.LookupEntry(target->GetZoneId()))
                 aName = areaEntry->AreaName_lang;
 
             bool show = false;
             for (size_t i = 0; i < wWords.size(); ++i)
             {
                 if (!wWords[i].empty())
                 {
                     if (wTargetName.find(wWords[i]) != std::wstring::npos ||
                         wTargetGuildName.find(wWords[i]) != std::wstring::npos ||
                         Utf8FitTo(aName, wWords[i]))
                     {
                         show = true;
                         break;
                     }
                 }
             }
 
             if (!show)
                 continue;
         }
 
         WorldPackets::Who::WhoEntry whoEntry;
         if (!whoEntry.PlayerData.Initialize(target->GetGUID(), target))
             continue;
 
         if (targetGuild)
         {
             whoEntry.GuildGUID = targetGuild->GetGUID();
             whoEntry.GuildVirtualRealmAddress = GetVirtualRealmAddress();
             whoEntry.GuildName = targetGuild->GetName();
         }
 
         whoEntry.AreaID = target->GetZoneId();
         whoEntry.IsGM = target->IsGameMaster();
 
         response.Response.Entries.push_back(whoEntry);
 
         // 50 is maximum player count sent to client - can be overridden
         // through config, but is unstable
         if (response.Response.Entries.size() >= sWorld->getIntConfig(CONFIG_MAX_WHO))
             break;
     }
 
     SendPacket(response.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::HandleWorldTeleportOpcode ( WorldPackets::Misc::WorldTeleport & worldTeleport )

 {
     if (GetPlayer()->IsInFlight())
     {
         TC_LOG_DEBUG("network", "Player '%s' (%s) in flight, ignore worldport command.",
             GetPlayer()->GetName().c_str(), GetPlayer()->GetGUID().ToString().c_str());
         return;
     }
 
     TC_LOG_DEBUG("network", "CMSG_WORLD_TELEPORT: Player = %s, map = %u, x = %f, y = %f, z = %f, o = %f",
         GetPlayer()->GetName().c_str(), worldTeleport.MapID, worldTeleport.Pos.x, worldTeleport.Pos.y, worldTeleport.Pos.z, worldTeleport.Facing);
 
     if (HasPermission(rbac::RBAC_PERM_OPCODE_WORLD_TELEPORT))
         GetPlayer()->TeleportTo(worldTeleport.MapID, worldTeleport.Pos.x, worldTeleport.Pos.y, worldTeleport.Pos.z, worldTeleport.Facing);
     else
         SendNotification(LANG_YOU_NOT_HAVE_PERMISSION);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Todo:: : 6.x find better way for read

 {
     if (packet.Inv.Items.size() != 2)
     {
         TC_LOG_ERROR("network", "HandleWrapItem - Invalid itemCount (" SZFMTD ")", packet.Inv.Items.size());
         return;
     }
 
     // Gift
     uint8 giftContainerSlot = packet.Inv.Items[0].ContainerSlot;
     uint8 giftSlot          = packet.Inv.Items[0].Slot;
     // Item
     uint8 itemContainerSlot = packet.Inv.Items[1].ContainerSlot;
     uint8 itemSlot          = packet.Inv.Items[1].Slot;
 
     TC_LOG_DEBUG("network", "HandleWrapItem - Receive giftContainerSlot = %u, giftSlot = %u, itemContainerSlot = %u, itemSlot = %u", giftContainerSlot, giftSlot, itemContainerSlot, itemSlot);
 
     Item* gift = _player->GetItemByPos(giftContainerSlot, giftSlot);
     if (!gift)
     {
         _player->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, gift, NULL);
         return;
     }
 
     if (!(gift->GetTemplate()->GetFlags() & ITEM_FLAG_WRAPPER)) // cheating: non-wrapper wrapper
     {
         _player->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, gift, NULL);
         return;
     }
 
     Item* item = _player->GetItemByPos(itemContainerSlot, itemSlot);
     if (!item)
     {
         _player->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, item, NULL);
         return;
     }
 
     if (item == gift) // not possable with pacjket from real client
     {
         _player->SendEquipError(EQUIP_ERR_CANT_WRAP_WRAPPED, item, NULL);
         return;
     }
 
     if (item->IsEquipped())
     {
         _player->SendEquipError(EQUIP_ERR_CANT_WRAP_EQUIPPED, item, NULL);
         return;
     }
 
     if (!item->GetGuidValue(ITEM_FIELD_GIFTCREATOR).IsEmpty()) // HasFlag(ITEM_FIELD_FLAGS, ITEM_FLAGS_WRAPPED);
     {
         _player->SendEquipError(EQUIP_ERR_CANT_WRAP_WRAPPED, item, NULL);
         return;
     }
 
     if (item->IsBag())
     {
         _player->SendEquipError(EQUIP_ERR_CANT_WRAP_BAGS, item, NULL);
         return;
     }
 
     if (item->IsSoulBound())
     {
         _player->SendEquipError(EQUIP_ERR_CANT_WRAP_BOUND, item, NULL);
         return;
     }
 
     if (item->GetMaxStackCount() != 1)
     {
         _player->SendEquipError(EQUIP_ERR_CANT_WRAP_STACKABLE, item, NULL);
         return;
     }
 
     // maybe not correct check  (it is better than nothing)
     if (item->GetTemplate()->GetMaxCount() > 0)
     {
         _player->SendEquipError(EQUIP_ERR_CANT_WRAP_UNIQUE, item, NULL);
         return;
     }
 
     SQLTransaction trans = CharacterDatabase.BeginTransaction();
 
     PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_CHAR_GIFT);
     stmt->setUInt64(0, item->GetOwnerGUID().GetCounter());
     stmt->setUInt64(1, item->GetGUID().GetCounter());
     stmt->setUInt32(2, item->GetEntry());
     stmt->setUInt32(3, item->GetUInt32Value(ITEM_FIELD_FLAGS));
     trans->Append(stmt);
 
     item->SetEntry(gift->GetEntry());
 
     switch (item->GetEntry())
     {
         case 5042:
             item->SetEntry(5043);
             break;
         case 5048:
             item->SetEntry(5044);
             break;
         case 17303:
             item->SetEntry(17302);
             break;
         case 17304:
             item->SetEntry(17305);
             break;
         case 17307:
             item->SetEntry(17308);
             break;
         case 21830:
             item->SetEntry(21831);
             break;
     }
 
     item->SetGuidValue(ITEM_FIELD_GIFTCREATOR, _player->GetGUID());
     item->SetUInt32Value(ITEM_FIELD_FLAGS, ITEM_FIELD_FLAG_WRAPPED);
     item->SetState(ITEM_CHANGED, _player);
 
     if (item->GetState() == ITEM_NEW) // save new item, to have alway for `character_gifts` record in `item_instance`
     {
         // after save it will be impossible to remove the item from the queue
         item->RemoveFromUpdateQueueOf(_player);
         item->SaveToDB(trans); // item gave inventory record unchanged and can be save standalone
     }
     CharacterDatabase.CommitTransaction(trans);
 
     uint32 count = 1;
     _player->DestroyItemCount(gift, count, true);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool WorldSession::HasPermission ( uint32 permissionId )

 {
     if (!_RBACData)
         LoadPermissions();
 
     bool hasPermission = _RBACData->HasPermission(permission);
     TC_LOG_DEBUG("rbac", "WorldSession::HasPermission [AccountId: %u, Name: %s, realmId: %d]",
                    _RBACData->GetId(), _RBACData->GetName().c_str(), realm.Id.Realm);
 
     return hasPermission;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::InitializeQueryCallbackParameters ( )

private

 {
     // Callback parameters that have pointers in them should be properly
     // initialized to nullptr here.
 }

Here is the caller graph for this function:

void WorldSession::InitializeSession ( )

 {
     AccountInfoQueryHolderPerRealm* realmHolder = new AccountInfoQueryHolderPerRealm();
     if (!realmHolder->Initialize(GetAccountId(), GetBattlenetAccountId()))
     {
         delete realmHolder;
         SendAuthResponse(ERROR_INTERNAL, false);
         return;
     }
 
     AccountInfoQueryHolder* holder = new AccountInfoQueryHolder();
     if (!holder->Initialize(GetAccountId(), GetBattlenetAccountId()))
     {
         delete realmHolder;
         delete holder;
         SendAuthResponse(ERROR_INTERNAL, false);
         return;
     }
 
     _realmAccountLoginCallback = CharacterDatabase.DelayQueryHolder(realmHolder);
     _accountLoginCallback = LoginDatabase.DelayQueryHolder(holder);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::InitializeSessionCallback	(	SQLQueryHolder *	realmHolder,
		SQLQueryHolder *	holder
	)

 {
     LoadAccountData(realmHolder->GetPreparedResult(AccountInfoQueryHolderPerRealm::GLOBAL_ACCOUNT_DATA), GLOBAL_CACHE_MASK);
     LoadTutorialsData(realmHolder->GetPreparedResult(AccountInfoQueryHolderPerRealm::TUTORIALS));
     _collectionMgr->LoadAccountToys(holder->GetPreparedResult(AccountInfoQueryHolder::GLOBAL_ACCOUNT_TOYS));
     _collectionMgr->LoadAccountHeirlooms(holder->GetPreparedResult(AccountInfoQueryHolder::GLOBAL_ACCOUNT_HEIRLOOMS));
 
     if (!m_inQueue)
         SendAuthResponse(ERROR_OK, false);
     else
         SendAuthWaitQue(0);
 
     SetInQueue(false);
     ResetTimeOutTime();
 
     SendSetTimeZoneInformation();
     SendFeatureSystemStatusGlueScreen();
     SendAddonsInfo();
     SendClientCacheVersion(sWorld->getIntConfig(CONFIG_CLIENTCACHE_VERSION));
     SendTutorialsData();
 
     if (PreparedQueryResult characterCountsResult = holder->GetPreparedResult(AccountInfoQueryHolder::GLOBAL_REALM_CHARACTER_COUNTS))
     {
         do
         {
             Field* fields = characterCountsResult->Fetch();
             _realmCharacterCounts[Battlenet::RealmHandle{ fields[3].GetUInt8(), fields[4].GetUInt8(), fields[2].GetUInt32() }.GetAddress()] = fields[1].GetUInt8();
 
         } while (characterCountsResult->NextRow());
     }
 
     WorldPackets::Battlenet::SetSessionState bnetConnected;
     bnetConnected.State = 1;
     SendPacket(bnetConnected.Write());
 
     _battlePetMgr->LoadFromDB(holder->GetPreparedResult(AccountInfoQueryHolder::BATTLE_PETS),
                               holder->GetPreparedResult(AccountInfoQueryHolder::BATTLE_PET_SLOTS));
 
     delete realmHolder;
     delete holder;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::InitWarden ( BigNumber * k )

 {
     if (_os == "Win")
     {
         _warden = new WardenWin();
         _warden->Init(this, k);
     }
     else if (_os == "Wn64")
     {
         // Not implemented
     }
     else if (_os == "Mc64")
     {
         // Not implemented
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::InvalidateRBACData ( )

 {
     TC_LOG_DEBUG("rbac", "WorldSession::Invalidaterbac::RBACData [AccountId: %u, Name: %s, realmId: %d]",
                    _RBACData->GetId(), _RBACData->GetName().c_str(), realm.Id.Realm);
     delete _RBACData;
     _RBACData = NULL;
 }

Here is the call graph for this function:

bool WorldSession::IsAddonRegistered ( const std::string & prefix ) const

 {
     if (!_filterAddonMessages) // if we have hit the softcap (64) nothing should be filtered
         return true;
 
     if (_registeredAddonPrefixes.empty())
         return false;
 
     std::vector<std::string>::const_iterator itr = std::find(_registeredAddonPrefixes.begin(), _registeredAddonPrefixes.end(), prefix);
     return itr != _registeredAddonPrefixes.end();
 }

bool WorldSession::IsARecruiter ( ) const

inline

1086 { return isRecruiter; }

WorldSession::isRecruiter

bool isRecruiter

Definition: WorldSession.h:1836

bool WorldSession::IsConnectionIdle ( ) const

inline

         {
             return m_timeOutTime <= 0 && !m_inQueue;
         }

Here is the caller graph for this function:

bool WorldSession::IsLegitCharacterForAccount ( ObjectGuid lowGUID )

inlineprivate

         {
             return _legitCharacters.find(lowGUID) != _legitCharacters.end();
         }

Here is the caller graph for this function:

bool WorldSession::isLogingOut ( ) const

inline

Is the user engaged in a log out process?

943 { return _logoutTime || m_playerLogout; }

WorldSession::_logoutTime

time_t _logoutTime

Definition: WorldSession.h:1819

WorldSession::m_playerLogout

bool m_playerLogout

Definition: WorldSession.h:1822

Here is the caller graph for this function:

void WorldSession::KickPlayer ( )

Kick a player out of the World.

 {
     for (uint8 i = 0; i < 2; ++i)
     {
         if (m_Socket[i])
         {
             m_Socket[i]->CloseSocket();
             forceExit = true;
         }
     }
 }

Here is the caller graph for this function:

void WorldSession::LoadAccountData	(	PreparedQueryResult	result,
		uint32	mask
	)

 {
     for (uint32 i = 0; i < NUM_ACCOUNT_DATA_TYPES; ++i)
         if (mask & (1 << i))
             _accountData[i] = AccountData();
 
     if (!result)
         return;
 
     do
     {
         Field* fields = result->Fetch();
         uint32 type = fields[0].GetUInt8();
         if (type >= NUM_ACCOUNT_DATA_TYPES)
         {
             TC_LOG_ERROR("misc", "Table `%s` have invalid account data type (%u), ignore.",
                 mask == GLOBAL_CACHE_MASK ? "account_data" : "character_account_data", type);
             continue;
         }
 
         if ((mask & (1 << type)) == 0)
         {
             TC_LOG_ERROR("misc", "Table `%s` have non appropriate for table  account data type (%u), ignore.",
                 mask == GLOBAL_CACHE_MASK ? "account_data" : "character_account_data", type);
             continue;
         }
 
         _accountData[type].Time = time_t(fields[1].GetUInt32());
         _accountData[type].Data = fields[2].GetString();
     }
     while (result->NextRow());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::LoadPermissions ( )

 {
     uint32 id = GetAccountId();
     uint8 secLevel = GetSecurity();
 
     TC_LOG_DEBUG("rbac", "WorldSession::LoadPermissions [AccountId: %u, Name: %s, realmId: %d, secLevel: %u]",
         id, _accountName.c_str(), realm.Id.Realm, secLevel);
 
     _RBACData = new rbac::RBACData(id, _accountName, realm.Id.Realm, secLevel);
     _RBACData->LoadFromDB();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

PreparedQueryResultFuture WorldSession::LoadPermissionsAsync ( )

 {
     uint32 id = GetAccountId();
     uint8 secLevel = GetSecurity();
 
     TC_LOG_DEBUG("rbac", "WorldSession::LoadPermissions [AccountId: %u, Name: %s, realmId: %d, secLevel: %u]",
         id, _accountName.c_str(), realm.Id.Realm, secLevel);
 
     _RBACData = new rbac::RBACData(id, _accountName, realm.Id.Realm, secLevel);
     return _RBACData->LoadFromDBAsync();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::LoadTutorialsData ( PreparedQueryResult result )

 {
     memset(_tutorials, 0, sizeof(uint32) * MAX_ACCOUNT_TUTORIAL_VALUES);
 
     if (result)
         for (uint8 i = 0; i < MAX_ACCOUNT_TUTORIAL_VALUES; ++i)
             _tutorials[i] = (*result)[i].GetUInt32();
 
     _tutorialsChanged = false;
 }

Here is the caller graph for this function:

void WorldSession::LogoutPlayer ( bool save )

Log the player out

If the player just died before logging out, make him appear as a ghost
Teleport to home if the player is in an invalid instance
If the player is in a guild, update the guild roster and broadcast a logout message to other guild members
Remove pet
Clear whisper whitelist
empty buyback items and save the player in the database
Leave all channels before player delete...
If the player is in a group (or invited), remove him. If the group if then only 1 person, disband the group.

Send update to group and reset stored max enchanting level

Broadcast a logout message to the player's friends

Call script hook before deletion

Remove the player from the world

Pointer already deleted during RemovePlayerFromMap

Send the 'logout complete' packet to the client Client will respond by sending 3x CMSG_CANCEL_TRADE, which we currently dont handle

Since each account can only have one online character at any given time, ensure all characters for active account are marked as offline

 {
     // finish pending transfers before starting the logout
     while (_player && _player->IsBeingTeleportedFar())
         HandleMoveWorldportAckOpcode();
 
     m_playerLogout = true;
     m_playerSave = save;
 
     if (_player)
     {
         ObjectGuid lguid = _player->GetLootGUID();
         if (!lguid.IsEmpty())
             DoLootRelease(lguid);
 
         if (_player->GetDeathTimer())
         {
             _player->getHostileRefManager().deleteReferences();
             _player->BuildPlayerRepop();
             _player->RepopAtGraveyard();
         }
         else if (_player->HasAuraType(SPELL_AURA_SPIRIT_OF_REDEMPTION))
         {
             // this will kill character by SPELL_AURA_SPIRIT_OF_REDEMPTION
             _player->RemoveAurasByType(SPELL_AURA_MOD_SHAPESHIFT);
             _player->KillPlayer();
             _player->BuildPlayerRepop();
             _player->RepopAtGraveyard();
         }
         else if (_player->HasPendingBind())
         {
             _player->RepopAtGraveyard();
             _player->SetPendingBind(0, 0);
         }
 
         //drop a flag if player is carrying it
         if (Battleground* bg = _player->GetBattleground())
             bg->EventPlayerLoggedOut(_player);
 
         if (!_player->m_InstanceValid && !_player->IsGameMaster())
             _player->TeleportTo(_player->m_homebindMapId, _player->m_homebindX, _player->m_homebindY, _player->m_homebindZ, _player->GetOrientation());
 
         sOutdoorPvPMgr->HandlePlayerLeaveZone(_player, _player->GetZoneId());
 
         for (int i=0; i < PLAYER_MAX_BATTLEGROUND_QUEUES; ++i)
         {
             if (BattlegroundQueueTypeId bgQueueTypeId = _player->GetBattlegroundQueueTypeId(i))
             {
                 _player->RemoveBattlegroundQueueId(bgQueueTypeId);
                 BattlegroundQueue& queue = sBattlegroundMgr->GetBattlegroundQueue(bgQueueTypeId);
                 queue.RemovePlayer(_player->GetGUID(), true);
             }
         }
 
         // Repop at GraveYard or other player far teleport will prevent saving player because of not present map
         // Teleport player immediately for correct player save
         while (_player->IsBeingTeleportedFar())
             HandleMoveWorldportAckOpcode();
 
         if (Guild* guild = sGuildMgr->GetGuildById(_player->GetGuildId()))
             guild->HandleMemberLogout(this);
 
         _player->RemovePet(NULL, PET_SAVE_AS_CURRENT, true);
 
         _player->ClearWhisperWhiteList();
 
         // some save parts only correctly work in case player present in map/player_lists (pets, etc)
         if (save)
         {
             uint32 eslot;
             for (int j = BUYBACK_SLOT_START; j < BUYBACK_SLOT_END; ++j)
             {
                 eslot = j - BUYBACK_SLOT_START;
                 _player->SetGuidValue(PLAYER_FIELD_INV_SLOT_HEAD + (j * 4), ObjectGuid::Empty);
                 _player->SetUInt32Value(PLAYER_FIELD_BUYBACK_PRICE_1 + eslot, 0);
                 _player->SetUInt32Value(PLAYER_FIELD_BUYBACK_TIMESTAMP_1 + eslot, 0);
             }
             _player->SaveToDB();
         }
 
         _player->CleanupChannels();
 
         _player->UninviteFromGroup();
 
         // remove player from the group if he is:
         // a) in group; b) not in raid group; c) logging out normally (not being kicked or disconnected)
         if (_player->GetGroup() && !_player->GetGroup()->isRaidGroup() && m_Socket[CONNECTION_TYPE_REALM])
             _player->RemoveFromGroup();
 
         if (_player->GetGroup())
         {
             _player->GetGroup()->SendUpdate();
             _player->GetGroup()->ResetMaxEnchantingLevel();
         }
 
         sSocialMgr->SendFriendStatus(_player, FRIEND_OFFLINE, _player->GetGUID(), true);
         _player->RemoveSocial();
 
         sScriptMgr->OnPlayerLogout(_player);
 
         // the player may not be in the world when logging out
         // e.g if he got disconnected during a transfer to another map
         // calls to GetMap in this case may cause crashes
         _player->CleanupsBeforeDelete();
         TC_LOG_INFO("entities.player.character", "Account: %u (IP: %s) Logout Character:[%s] (%s) Level: %d",
             GetAccountId(), GetRemoteAddress().c_str(), _player->GetName().c_str(), _player->GetGUID().ToString().c_str(), _player->getLevel());
 
         if (Map* _map = _player->FindMap())
             _map->RemovePlayerFromMap(_player, true);
 
         SetPlayer(NULL); 
 
         SendPacket(WorldPackets::Character::LogoutComplete().Write());
         TC_LOG_DEBUG("network", "SESSION: Sent SMSG_LOGOUT_COMPLETE Message");
 
         PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_ACCOUNT_ONLINE);
         stmt->setUInt32(0, GetAccountId());
         CharacterDatabase.Execute(stmt);
     }
 
     if (m_Socket[CONNECTION_TYPE_INSTANCE])
     {
         m_Socket[CONNECTION_TYPE_INSTANCE]->CloseSocket();
         m_Socket[CONNECTION_TYPE_INSTANCE].reset();
     }
 
     m_playerLogout = false;
     m_playerSave = false;
     m_playerRecentlyLogout = true;
     SetLogoutStartTime(0);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::LogUnexpectedOpcode	(	WorldPacket *	packet,
		const char *	status,
		const char *	reason
	)

private

Logging helper for unexpected opcodes.

 {
     TC_LOG_ERROR("network.opcode", "Received unexpected opcode %s Status: %s Reason: %s from %s",
         GetOpcodeNameForLogging(static_cast<OpcodeClient>(packet->GetOpcode())).c_str(), status, reason, GetPlayerInfo().c_str());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::LogUnprocessedTail ( WorldPacket * packet )

private

Logging helper for unexpected opcodes.

 {
     if (!sLog->ShouldLog("network.opcode", LOG_LEVEL_TRACE) || packet->rpos() >= packet->wpos())
         return;
 
     TC_LOG_TRACE("network.opcode", "Unprocessed tail data (read stop at %u from %u) Opcode %s from %s",
         uint32(packet->rpos()), uint32(packet->wpos()), GetOpcodeNameForLogging(static_cast<OpcodeClient>(packet->GetOpcode())).c_str(), GetPlayerInfo().c_str());
     packet->print_storage();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::moveItems	(	Item *	myItems[],
		Item *	hisItems[]
	)

private

 {
     Player* trader = _player->GetTrader();
     if (!trader)
         return;
 
     for (uint8 i = 0; i < TRADE_SLOT_TRADED_COUNT; ++i)
     {
         ItemPosCountVec traderDst;
         ItemPosCountVec playerDst;
         bool traderCanTrade = (myItems[i] == NULL || trader->CanStoreItem(NULL_BAG, NULL_SLOT, traderDst, myItems[i], false) == EQUIP_ERR_OK);
         bool playerCanTrade = (hisItems[i] == NULL || _player->CanStoreItem(NULL_BAG, NULL_SLOT, playerDst, hisItems[i], false) == EQUIP_ERR_OK);
         if (traderCanTrade && playerCanTrade)
         {
             // Ok, if trade item exists and can be stored
             // If we trade in both directions we had to check, if the trade will work before we actually do it
             // A roll back is not possible after we stored it
             if (myItems[i])
             {
                 // logging
                 TC_LOG_DEBUG("network", "partner storing: %s", myItems[i]->GetGUID().ToString().c_str());
                 if (HasPermission(rbac::RBAC_PERM_LOG_GM_TRADE))
                 {
                     sLog->outCommand(_player->GetSession()->GetAccountId(), "GM %s (Account: %u) trade: %s (Entry: %d Count: %u) to player: %s (Account: %u)",
                         _player->GetName().c_str(), _player->GetSession()->GetAccountId(),
                         myItems[i]->GetTemplate()->GetDefaultLocaleName(), myItems[i]->GetEntry(), myItems[i]->GetCount(),
                         trader->GetName().c_str(), trader->GetSession()->GetAccountId());
                 }
 
                 // adjust time (depends on /played)
                 if (myItems[i]->HasFlag(ITEM_FIELD_FLAGS, ITEM_FIELD_FLAG_BOP_TRADEABLE))
                     myItems[i]->SetUInt32Value(ITEM_FIELD_CREATE_PLAYED_TIME, trader->GetTotalPlayedTime()-(_player->GetTotalPlayedTime()-myItems[i]->GetUInt32Value(ITEM_FIELD_CREATE_PLAYED_TIME)));
                 // store
                 trader->MoveItemToInventory(traderDst, myItems[i], true, true);
             }
             if (hisItems[i])
             {
                 // logging
                 TC_LOG_DEBUG("network", "player storing: %s", hisItems[i]->GetGUID().ToString().c_str());
                 if (HasPermission(rbac::RBAC_PERM_LOG_GM_TRADE))
                 {
                     sLog->outCommand(trader->GetSession()->GetAccountId(), "GM %s (Account: %u) trade: %s (Entry: %d Count: %u) to player: %s (Account: %u)",
                         trader->GetName().c_str(), trader->GetSession()->GetAccountId(),
                         hisItems[i]->GetTemplate()->GetDefaultLocaleName(), hisItems[i]->GetEntry(), hisItems[i]->GetCount(),
                         _player->GetName().c_str(), _player->GetSession()->GetAccountId());
                 }
 
                 // adjust time (depends on /played)
                 if (hisItems[i]->HasFlag(ITEM_FIELD_FLAGS, ITEM_FIELD_FLAG_BOP_TRADEABLE))
                     hisItems[i]->SetUInt32Value(ITEM_FIELD_CREATE_PLAYED_TIME, _player->GetTotalPlayedTime()-(trader->GetTotalPlayedTime()-hisItems[i]->GetUInt32Value(ITEM_FIELD_CREATE_PLAYED_TIME)));
                 // store
                 _player->MoveItemToInventory(playerDst, hisItems[i], true, true);
             }
         }
         else
         {
             // in case of fatal error log error message
             // return the already removed items to the original owner
             if (myItems[i])
             {
                 if (!traderCanTrade)
                     TC_LOG_ERROR("network", "trader can't store item: %s", myItems[i]->GetGUID().ToString().c_str());
                 if (_player->CanStoreItem(NULL_BAG, NULL_SLOT, playerDst, myItems[i], false) == EQUIP_ERR_OK)
                     _player->MoveItemToInventory(playerDst, myItems[i], true, true);
                 else
                     TC_LOG_ERROR("network", "player can't take item back: %s", myItems[i]->GetGUID().ToString().c_str());
             }
             // return the already removed items to the original owner
             if (hisItems[i])
             {
                 if (!playerCanTrade)
                     TC_LOG_ERROR("network", "player can't store item: %s", hisItems[i]->GetGUID().ToString().c_str());
                 if (trader->CanStoreItem(NULL_BAG, NULL_SLOT, traderDst, hisItems[i], false) == EQUIP_ERR_OK)
                     trader->MoveItemToInventory(traderDst, hisItems[i], true, true);
                 else
                     TC_LOG_ERROR("network", "trader can't take item back: %s", hisItems[i]->GetGUID().ToString().c_str());
             }
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

privatedelete

bool WorldSession::PlayerDisconnected ( ) const

 {
     return !(m_Socket[CONNECTION_TYPE_REALM] && m_Socket[CONNECTION_TYPE_REALM]->IsOpen() &&
              m_Socket[CONNECTION_TYPE_INSTANCE] && m_Socket[CONNECTION_TYPE_INSTANCE]->IsOpen());
 }

bool WorldSession::PlayerLoading ( ) const

inline

889 { return !m_playerLoading.IsEmpty(); }

WorldSession::m_playerLoading

ObjectGuid m_playerLoading

Definition: WorldSession.h:1821

ObjectGuid::IsEmpty

bool IsEmpty() const

Definition: ObjectGuid.h:242

Here is the caller graph for this function:

bool WorldSession::PlayerLogout ( ) const

inline

890 { return m_playerLogout; }

WorldSession::m_playerLogout

bool m_playerLogout

Definition: WorldSession.h:1822

Here is the caller graph for this function:

bool WorldSession::PlayerLogoutWithSave ( ) const

inline

891 { return m_playerLogout && m_playerSave; }

WorldSession::m_playerLogout

bool m_playerLogout

Definition: WorldSession.h:1822

WorldSession::m_playerSave

bool m_playerSave

Definition: WorldSession.h:1824

bool WorldSession::PlayerRecentlyLoggedOut ( ) const

inline

892 { return m_playerRecentlyLogout; }

WorldSession::m_playerRecentlyLogout

bool m_playerRecentlyLogout

Definition: WorldSession.h:1823

Here is the caller graph for this function:

void WorldSession::ProcessQueryCallbacks ( )

private

HandleCharEnumOpcode and HandleCharUndeleteEnumOpcode

HandleCharCreateOpcode

HandleCharCustomizeOpcode

HandleCharRaceOrFactionChangeOpcode

HandlePlayerLoginOpcode

HandleAddFriendOpcode

HandleUndeleteCooldownStatusOpcode wait until no char undelete is in progress

HandleCharUndeleteOpcode

 {
     PreparedQueryResult result;
 
     if (_realmAccountLoginCallback.valid() && _realmAccountLoginCallback.wait_for(std::chrono::seconds(0)) == std::future_status::ready &&
         _accountLoginCallback.valid() && _accountLoginCallback.wait_for(std::chrono::seconds(0)) == std::future_status::ready)
         InitializeSessionCallback(_realmAccountLoginCallback.get(), _accountLoginCallback.get());
 
     if (_charEnumCallback.IsReady())
     {
         _charEnumCallback.GetResult(result);
 
         if (_charEnumCallback.GetParam())
             HandleCharUndeleteEnum(result);
         else
             HandleCharEnum(result);
 
         _charEnumCallback.FreeResult();
     }
 
     if (_charCreateCallback.IsReady())
     {
         _charCreateCallback.GetResult(result);
         HandleCharCreateCallback(result, _charCreateCallback.GetParam().get());
     }
 
     if (_charCustomizeCallback.IsReady())
     {
         _charCustomizeCallback.GetResult(result);
         HandleCharCustomizeCallback(result, _charCustomizeCallback.GetParam().get());
         _charCustomizeCallback.Reset();
     }
 
     if (_charFactionChangeCallback.IsReady())
     {
         _charFactionChangeCallback.GetResult(result);
         HandleCharRaceOrFactionChangeCallback(result, _charFactionChangeCallback.GetParam().get());
         _charFactionChangeCallback.Reset();
     }
 
     if (_charLoginCallback.valid() && _charLoginCallback.wait_for(std::chrono::seconds(0)) == std::future_status::ready)
     {
         SQLQueryHolder* param = _charLoginCallback.get();
         HandlePlayerLogin((LoginQueryHolder*)param);
     }
 
     if (_addFriendCallback.IsReady())
     {
         std::string param = _addFriendCallback.GetParam();
         _addFriendCallback.GetResult(result);
         HandleAddFriendOpcodeCallBack(result, param);
         _addFriendCallback.FreeResult();
     }
 
     //- HandleCharRenameOpcode
     if (_charRenameCallback.IsReady())
     {
         _charRenameCallback.GetResult(result);
         HandleCharRenameCallBack(result, _charRenameCallback.GetParam().get());
         _charRenameCallback.Reset();
     }
 
     if (!_charUndeleteCallback.GetStage() && _undeleteCooldownStatusCallback.IsReady())
     {
         _undeleteCooldownStatusCallback.GetResult(result);
         HandleUndeleteCooldownStatusCallback(result);
     }
 
     if (_charUndeleteCallback.IsReady())
     {
         _charUndeleteCallback.GetResult(result);
         HandleCharUndeleteCallback(result, _charUndeleteCallback.GetParam().get());
     }
 
     //- HandleCharAddIgnoreOpcode
     if (_addIgnoreCallback.valid() && _addIgnoreCallback.wait_for(std::chrono::seconds(0)) == std::future_status::ready)
     {
         result = _addIgnoreCallback.get();
         HandleAddIgnoreOpcodeCallBack(result);
     }
 
     //- SendStabledPet
     if (_sendStabledPetCallback.IsReady())
     {
         ObjectGuid param = _sendStabledPetCallback.GetParam();
         _sendStabledPetCallback.GetResult(result);
         SendStablePetCallback(result, param);
         _sendStabledPetCallback.FreeResult();
     }
 
     //- HandleStablePet
     if (_stablePetCallback.valid() && _stablePetCallback.wait_for(std::chrono::seconds(0)) == std::future_status::ready)
     {
         result = _stablePetCallback.get();
         HandleStablePetCallback(result);
     }
 
     //- HandleUnstablePet
     if (_unstablePetCallback.IsReady())
     {
         uint32 param = _unstablePetCallback.GetParam();
         _unstablePetCallback.GetResult(result);
         HandleUnstablePetCallback(result, param);
         _unstablePetCallback.FreeResult();
     }
 
     //- HandleStableSwapPet
     if (_stableSwapCallback.IsReady())
     {
         uint32 param = _stableSwapCallback.GetParam();
         _stableSwapCallback.GetResult(result);
         HandleStableSwapPetCallback(result, param);
         _stableSwapCallback.FreeResult();
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::QueuePacket ( WorldPacket * new_packet )

Add an incoming packet to the queue.

 {
     _recvQueue.add(new_packet);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::ReadAddonsInfo ( ByteBuffer & data )

Todo:: Find out when to not use CRC/pubkey, and other possible states.

 {
     if (data.rpos() + 4 > data.size())
         return;
 
     uint32 size;
     data >> size;
 
     if (!size)
         return;
 
     if (size > 0xFFFFF)
     {
         TC_LOG_DEBUG("addon", "WorldSession::ReadAddonsInfo: AddOnInfo too big, size %u", size);
         return;
     }
 
     uLongf uSize = size;
 
     uint32 pos = data.rpos();
 
     ByteBuffer addonInfo;
     addonInfo.resize(size);
 
     m_addonsList.clear();
 
     if (uncompress(addonInfo.contents(), &uSize, data.contents() + pos, data.size() - pos) == Z_OK)
     {
         uint32 addonsCount;
         addonInfo >> addonsCount;                         // addons count
 
         for (uint32 i = 0; i < addonsCount; ++i)
         {
             std::string addonName;
             uint8 enabled;
             uint32 crc, unk1;
 
             // check next addon data format correctness
             if (addonInfo.rpos() + 1 > addonInfo.size())
                 return;
 
             addonInfo >> addonName;
 
             addonInfo >> enabled >> crc >> unk1;
 
             TC_LOG_DEBUG("addon", "AddOn: %s (CRC: 0x%x) - enabled: 0x%x - Unknown2: 0x%x", addonName.c_str(), crc, enabled, unk1);
 
             AddonInfo addon(addonName, enabled, crc, 2, true);
 
             SavedAddon const* savedAddon = AddonMgr::GetAddonInfo(addonName);
             if (savedAddon)
             {
                 if (addon.CRC != savedAddon->CRC)
                     TC_LOG_WARN("addon", " Addon: %s: modified (CRC: 0x%x) - accountID %d)", addon.Name.c_str(), savedAddon->CRC, GetAccountId());
                 else
                     TC_LOG_DEBUG("addon", "Addon: %s: validated (CRC: 0x%x) - accountID %d", addon.Name.c_str(), savedAddon->CRC, GetAccountId());
             }
             else
             {
                 AddonMgr::SaveAddon(addon);
                 TC_LOG_WARN("addon", "Addon: %s: unknown (CRC: 0x%x) - accountId %d (storing addon name and checksum to database)", addon.Name.c_str(), addon.CRC, GetAccountId());
             }
 
             m_addonsList.push_back(addon);
         }
 
         uint32 currentTime;
         addonInfo >> currentTime;
         TC_LOG_DEBUG("addon", "AddOn: CurrentTime: %u", currentTime);
     }
     else
         TC_LOG_DEBUG("addon", "AddOn: Addon packet uncompress error!");
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::ResetClientTimeDelay ( )

inline

1065 { m_clientTimeDelay = 0; }

WorldSession::m_clientTimeDelay

std::atomic< uint32 > m_clientTimeDelay

Definition: WorldSession.h:1828

Here is the caller graph for this function:

void WorldSession::ResetTimeOutTime ( )

inline

         {
             m_timeOutTime = int32(sWorld->getIntConfig(CONFIG_SOCKET_TIMEOUTTIME));
         }

Here is the caller graph for this function:

void WorldSession::SaveTutorialsData ( SQLTransaction & trans )

 {
     if (!_tutorialsChanged)
         return;
 
     PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_HAS_TUTORIALS);
     stmt->setUInt32(0, GetAccountId());
     bool hasTutorials = bool(CharacterDatabase.Query(stmt));
     // Modify data in DB
     stmt = CharacterDatabase.GetPreparedStatement(hasTutorials ? CHAR_UPD_TUTORIALS : CHAR_INS_TUTORIALS);
     for (uint8 i = 0; i < MAX_ACCOUNT_TUTORIAL_VALUES; ++i)
         stmt->setUInt32(i, _tutorials[i]);
     stmt->setUInt32(MAX_ACCOUNT_TUTORIAL_VALUES, GetAccountId());
     trans->Append(stmt);
 
     _tutorialsChanged = false;
 }

Here is the call graph for this function:

void WorldSession::SendActivateTaxiReply ( ActivateTaxiReply reply )

 {
     WorldPackets::Taxi::ActivateTaxiReply data;
     data.Reply = reply;
     SendPacket(data.Write());
     TC_LOG_DEBUG("network", "WORLD: Sent SMSG_ACTIVATETAXIREPLY");
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::SendAddonsInfo ( )

 {
     WorldPackets::ClientConfig::AddonInfo addonInfo;
     addonInfo.Addons = &m_addonsList;
     addonInfo.BannedAddons = AddonMgr::GetBannedAddons();
     SendPacket(addonInfo.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::SendAttackStop ( Unit const * enemy )

 {
     SendPacket(WorldPackets::Combat::SAttackStop(GetPlayer(), enemy).Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::SendAuctionClosedNotification	(	AuctionEntry const *	auction,
		float	mailDelay,
		bool	sold,
		Item const *	item
	)

 {
     WorldPackets::AuctionHouse::AuctionClosedNotification packet;
     packet.Info.Initialize(auction, item);
     packet.ProceedsMailDelay = mailDelay;
     packet.Sold = sold;
     SendPacket(packet.Write());
 }

Here is the call graph for this function:

void WorldSession::SendAuctionCommandResult	(	AuctionEntry *	auction,
		uint32	Action,
		uint32	ErrorCode,
		uint32	bidError = `0`
	)

Notifies the client of the result of his last auction operation. It is called when the player bids, creates, or deletes an auction.

Parameters

auction	The relevant auction object
Action	The action that was performed.
ErrorCode	The resulting error code.
bidError	(Optional) the bid error.

 {
     WorldPackets::AuctionHouse::AuctionCommandResult auctionCommandResult;
     auctionCommandResult.InitializeAuction(auction);
     auctionCommandResult.Command = action;
     auctionCommandResult.ErrorCode = errorCode;
     SendPacket(auctionCommandResult.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::SendAuctionHello	(	ObjectGuid	guid,
		Creature *	unit
	)

 {
     if (GetPlayer()->getLevel() < sWorld->getIntConfig(CONFIG_AUCTION_LEVEL_REQ))
     {
         SendNotification(GetTrinityString(LANG_AUCTION_REQ), sWorld->getIntConfig(CONFIG_AUCTION_LEVEL_REQ));
         return;
     }
 
     AuctionHouseEntry const* ahEntry = AuctionHouseMgr::GetAuctionHouseEntry(unit->getFaction());
     if (!ahEntry)
         return;
 
     WorldPackets::AuctionHouse::AuctionHelloResponse auctionHelloResponse;
     auctionHelloResponse.Guid = guid;
     auctionHelloResponse.OpenForBusiness = true;                         // 3.3.3: 1 - AH enabled, 0 - AH disabled
     SendPacket(auctionHelloResponse.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::SendAuctionOutBidNotification	(	AuctionEntry const *	auction,
		Item const *	item
	)

 {
     WorldPackets::AuctionHouse::AuctionOutBidNotification packet;
     packet.BidAmount = auction->bid;
     packet.MinIncrement = auction->GetAuctionOutBid();
     packet.Info.Initialize(auction, item);
     SendPacket(packet.Write());
 }

Here is the call graph for this function:

void WorldSession::SendAuctionOwnerBidNotification	(	AuctionEntry const *	auction,
		Item const *	item
	)

 {
     WorldPackets::AuctionHouse::AuctionOwnerBidNotification packet;
     packet.Info.Initialize(auction, item);
     packet.Bidder = ObjectGuid::Create<HighGuid::Player>(auction->bidder);
     packet.MinIncrement = auction->GetAuctionOutBid();
     SendPacket(packet.Write());
 }

Here is the call graph for this function:

void WorldSession::SendAuctionWonNotification	(	AuctionEntry const *	auction,
		Item const *	item
	)

 {
     WorldPackets::AuctionHouse::AuctionWonNotification packet;
     packet.Info.Initialize(auction, item);
     SendPacket(packet.Write());
 }

Here is the call graph for this function:

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

 {
     WorldPackets::Auth::AuthResponse response;
     response.Result = code;
 
     if (queued)
     {
         response.WaitInfo = boost::in_place();
         response.WaitInfo->WaitCount = queuePos;
     }
     else if (code == ERROR_OK)
     {
         response.SuccessInfo = boost::in_place();
 
         response.SuccessInfo->AccountExpansionLevel = GetExpansion();
         response.SuccessInfo->ActiveExpansionLevel = GetExpansion();
         response.SuccessInfo->VirtualRealmAddress = GetVirtualRealmAddress();
 
         // Send current home realm. Also there is no need to send it later in realm queries.
         response.SuccessInfo->VirtualRealms.emplace_back(GetVirtualRealmAddress(), true, false,
             sObjectMgr->GetRealmName(realm.Id.Realm), sObjectMgr->GetNormalizedRealmName(realm.Id.Realm));
 
         if (HasPermission(rbac::RBAC_PERM_USE_CHARACTER_TEMPLATES))
             for (auto& templ : sObjectMgr->GetCharacterTemplates())
                 response.SuccessInfo->Templates.emplace_back(templ.second);
 
         response.SuccessInfo->AvailableClasses = &sObjectMgr->GetClassExpansionRequirements();
         response.SuccessInfo->AvailableRaces = &sObjectMgr->GetRaceExpansionRequirements();
     }
 
     SendPacket(response.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::SendAuthWaitQue ( uint32 position )

Handle the authentication waiting queue (to be completed)

 {
     WorldPackets::Auth::AuthResponse response;
     response.Result = ERROR_OK;
 
     if (position)
     {
         response.WaitInfo = boost::in_place();
         response.WaitInfo->WaitCount = position;
     }
 
     SendPacket(response.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::SendBarberShopResult ( BarberShopResult result )

 {
     WorldPackets::Character::BarberShopResultServer packet;
     packet.Result = result;
     SendPacket(packet.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     _battlenetResponseCallbacks[_battlenetRequestToken] = std::move(callback);
     SendBattlenetRequest(serviceHash, methodId, request);
 }

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

 {
     WorldPackets::Battlenet::Notification notification;
     notification.Method.Type = MAKE_PAIR64(methodId, serviceHash);
     notification.Method.ObjectId = 1;
     notification.Method.Token = _battlenetRequestToken++;
 
     if (request->ByteSize())
     {
         notification.Data.resize(request->ByteSize());
         request->SerializePartialToArray(notification.Data.contents(), request->ByteSize());
     }
 
     SendPacket(notification.Write());
 }

Here is the call graph for this function:

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

 {
     WorldPackets::Battlenet::Response bnetResponse;
     bnetResponse.BnetStatus = ERROR_OK;
     bnetResponse.Method.Type = MAKE_PAIR64(methodId, serviceHash);
     bnetResponse.Method.ObjectId = 1;
     bnetResponse.Method.Token = token;
 
     if (response->ByteSize())
     {
         bnetResponse.Data.resize(response->ByteSize());
         response->SerializePartialToArray(bnetResponse.Data.contents(), response->ByteSize());
     }
 
     SendPacket(bnetResponse.Write());
 }

Here is the call graph for this function:

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

 {
     WorldPackets::Battlenet::Response bnetResponse;
     bnetResponse.BnetStatus = BattlenetRpcErrorCode(status);
     bnetResponse.Method.Type = MAKE_PAIR64(methodId, serviceHash);
     bnetResponse.Method.ObjectId = 1;
     bnetResponse.Method.Token = token;
 
     SendPacket(bnetResponse.Write());
 }

Here is the call graph for this function:

void WorldSession::SendBfEntered	(	uint64	queueId,
		bool	relocated,
		bool	onOffense
	)

This is call when player accept to join war.

Parameters

queueId	The queue id of Bf
relocated	Whether player is added to Bf on the spot or teleported from queue
onOffense	Whether player belongs to attacking team or not

 {
     WorldPackets::Battlefield::BFMgrEntering bfMgrEntering;
     bfMgrEntering.ClearedAFK = _player->isAFK();
     bfMgrEntering.Relocated = relocated;
     bfMgrEntering.OnOffense = onOffense;
     bfMgrEntering.QueueID = queueId;
     SendPacket(bfMgrEntering.Write());
 }

Here is the call graph for this function:

void WorldSession::SendBfInvitePlayerToQueue	(	uint64	queueId,
		int8	battleState
	)

This send invitation to player to join the queue.

Parameters

queueId The queue id of Bf

 {
     WorldPackets::Battlefield::BFMgrQueueInvite bfMgrQueueInvite;
     bfMgrQueueInvite.QueueID = queueId;
     bfMgrQueueInvite.BattleState = battleState;
     SendPacket(bfMgrQueueInvite.Write());
 }

Here is the call graph for this function:

void WorldSession::SendBfInvitePlayerToWar	(	uint64	queueId,
		uint32	zoneId,
		uint32	acceptTime
	)

This send to player windows for invite player to join the war.

Parameters

queueId	The queue id of Bf
zoneId	The zone where the battle is (4197 for wg)
acceptTime	Time in second that the player have for accept

 {
     WorldPackets::Battlefield::BFMgrEntryInvite bfMgrEntryInvite;
     bfMgrEntryInvite.QueueID = queueId;
     bfMgrEntryInvite.AreaID = zoneId;
     bfMgrEntryInvite.ExpireTime = time(nullptr) + acceptTime;
     SendPacket(bfMgrEntryInvite.Write());
 }

Here is the call graph for this function:

void WorldSession::SendBfLeaveMessage	(	uint64	queueId,
		int8	battleState,
		bool	relocated,
		BFLeaveReason	reason = `BF_LEAVE_REASON_EXITED`
	)

This is call when player leave battlefield zone.

Parameters

queueId	The queue id of Bf
battleState	Battlefield status
relocated	Whether player is added to Bf on the spot or teleported from queue
reason	Reason why player left battlefield

 {
     WorldPackets::Battlefield::BFMgrEjected bfMgrEjected;
     bfMgrEjected.QueueID = queueId;
     bfMgrEjected.Reason = reason;
     bfMgrEjected.BattleState = battleState;
     bfMgrEjected.Relocated = relocated;
     SendPacket(bfMgrEjected.Write());
 }

Here is the call graph for this function:

void WorldSession::SendBfQueueInviteResponse	(	uint64	queueId,
		uint32	zoneId,
		int8	battleStatus,
		bool	canQueue = `true`,
		bool	loggingIn = `false`
	)

This send packet for inform player that he join queue.

Parameters

queueId	The queue id of Bf
zoneId	The zone where the battle is (4197 for wg)
battleStatus	Battlefield status
canQueue	if able to queue
loggingIn	on log in send queue status

 {
     WorldPackets::Battlefield::BFMgrQueueRequestResponse bfMgrQueueRequestResponse;
     bfMgrQueueRequestResponse.QueueID = queueId;
     bfMgrQueueRequestResponse.AreaID = zoneId;
     bfMgrQueueRequestResponse.Result = canQueue ? 1 : 0;
     bfMgrQueueRequestResponse.BattleState = battleStatus;
     bfMgrQueueRequestResponse.LoggingIn = loggingIn;
     SendPacket(bfMgrQueueRequestResponse.Write());
 }

Here is the call graph for this function:

void WorldSession::SendBindPoint ( Creature * npc )

 {
     // prevent set homebind to instances in any case
     if (GetPlayer()->GetMap()->Instanceable())
         return;
 
     uint32 bindspell = 3286;
 
     // send spell for homebinding (3286)
     npc->CastSpell(_player, bindspell, true);
 
     _player->PlayerTalkClass->SendCloseGossip();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::SendBlackMarketOpenResult	(	ObjectGuid	guid,
		Creature *	auctioneer
	)

 {
     WorldPackets::BlackMarket::BlackMarketOpenResult packet;
     packet.Guid = guid;
     packet.Enable = false;
     SendPacket(packet.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::SendCalendarRaidLockout	(	InstanceSave const *	save,
		bool	add
	)

 {
     time_t currTime = time(NULL);
     if (add)
     {
         WorldPackets::Calendar::CalendarRaidLockoutAdded calendarRaidLockoutAdded;
         calendarRaidLockoutAdded.InstanceID = save->GetInstanceId();
         calendarRaidLockoutAdded.ServerTime = uint32(currTime);
         calendarRaidLockoutAdded.MapID = int32(save->GetMapId());
         calendarRaidLockoutAdded.DifficultyID = save->GetDifficultyID();
         calendarRaidLockoutAdded.TimeRemaining = uint32(save->GetResetTime() - currTime);
         SendPacket(calendarRaidLockoutAdded.Write());
     }
     else
     {
         WorldPackets::Calendar::CalendarRaidLockoutRemoved calendarRaidLockoutRemoved;
         calendarRaidLockoutRemoved.InstanceID = save->GetInstanceId();
         calendarRaidLockoutRemoved.MapID = int32(save->GetMapId());
         calendarRaidLockoutRemoved.DifficultyID = save->GetDifficultyID();
         SendPacket(calendarRaidLockoutRemoved.Write());
     }
 }

Here is the call graph for this function:

void WorldSession::SendCalendarRaidLockoutUpdated ( InstanceSave const * save )

 {
     if (!save)
         return;
 
     ObjectGuid guid = _player->GetGUID();
     TC_LOG_DEBUG("network", "SMSG_CALENDAR_RAID_LOCKOUT_UPDATED [%s] Map: %u, Difficulty %u", guid.ToString().c_str(), save->GetMapId(), save->GetDifficultyID());
 
     time_t currTime = time(NULL);
 
     WorldPackets::Calendar::CalendarRaidLockoutUpdated packet;
     packet.DifficultyID = save->GetDifficultyID();
     packet.MapID = save->GetMapId();
     packet.NewTimeRemaining = 0; // FIXME
     packet.OldTimeRemaining = save->GetResetTime() - currTime;
 
     SendPacket(packet.Write());
 }

Here is the call graph for this function:

void WorldSession::SendCancelTrade ( )

 {
     if (PlayerRecentlyLoggedOut() || PlayerLogout())
         return;
 
     WorldPackets::Trade::TradeStatus info;
     info.Status = TRADE_STATUS_CANCELLED;
     SendTradeStatus(info);
 }

Here is the call graph for this function:

void WorldSession::SendCharCreate ( ResponseCodes result )

 {
     WorldPackets::Character::CreateChar response;
     response.Code = result;
 
     SendPacket(response.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if (result == RESPONSE_SUCCESS)
     {
         WorldPackets::Character::CharCustomizeResponse response(customizeInfo);
         SendPacket(response.Write());
     }
     else
     {
         WorldPackets::Character::CharCustomizeFailed failed;
         failed.Result = uint8(result);
         failed.CharGUID = customizeInfo->CharGUID;
         SendPacket(failed.Write());
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::SendCharDelete ( ResponseCodes result )

 {
     WorldPackets::Character::DeleteChar response;
     response.Code = result;
 
     SendPacket(response.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     WorldPackets::Character::CharFactionChangeResult packet;
     packet.Result = result;
     packet.Guid = factionChangeInfo->Guid;
 
     if (result == RESPONSE_SUCCESS)
     {
         packet.Display = boost::in_place();
         packet.Display->Name = factionChangeInfo->Name;
         packet.Display->SexID = factionChangeInfo->SexID;
         packet.Display->SkinID = *factionChangeInfo->SkinID;
         packet.Display->HairColorID = *factionChangeInfo->HairColorID;
         packet.Display->HairStyleID = *factionChangeInfo->HairStyleID;
         packet.Display->FacialHairStyleID = *factionChangeInfo->FacialHairStyleID;
         packet.Display->FaceID = *factionChangeInfo->FaceID;
         packet.Display->RaceID = factionChangeInfo->RaceID;
     }
 
     SendPacket(packet.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     WorldPackets::Character::CharacterRenameResult packet;
     packet.Result = result;
     packet.Name = renameInfo->NewName;
     if (result == RESPONSE_SUCCESS)
         packet.Guid = renameInfo->Guid;
 
     SendPacket(packet.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::SendChatPlayerNotfoundNotice ( std::string const & name )

 {
     SendPacket(WorldPackets::Chat::ChatPlayerNotfound(name).Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::SendChatRestricted ( ChatRestrictionType restriction )

 {
     WorldPackets::Chat::ChatRestricted packet;
     packet.Reason = restriction;
     SendPacket(packet.Write());
 }

Here is the call graph for this function:

void WorldSession::SendClientCacheVersion ( uint32 version )

 {
     WorldPackets::ClientConfig::ClientCacheVersion cache;
     cache.CacheVersion = version;
 
     SendPacket(cache.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     boost::system::error_code ignored_error;
     boost::asio::ip::tcp::endpoint instanceAddress = realm.GetAddressForClient(boost::asio::ip::address::from_string(GetRemoteAddress(), ignored_error));
     instanceAddress.port(sWorld->getIntConfig(CONFIG_PORT_INSTANCE));
 
     _instanceConnectKey.Fields.AccountId = GetAccountId();
     _instanceConnectKey.Fields.ConnectionType = CONNECTION_TYPE_INSTANCE;
     _instanceConnectKey.Fields.Key = urand(0, 0x7FFFFFFF);
 
     WorldPackets::Auth::ConnectTo connectTo;
     connectTo.Key = _instanceConnectKey.Raw;
     connectTo.Serial = serial;
     connectTo.Payload.Where = instanceAddress;
     connectTo.Con = CONNECTION_TYPE_INSTANCE;
 
     SendPacket(connectTo.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::SendDiscoverNewTaxiNode ( uint32 nodeid )

 {
     if (GetPlayer()->m_taxi.SetTaximaskNode(nodeid))
         SendPacket(WorldPackets::Taxi::NewTaxiPath().Write());
 }

Here is the call graph for this function:

void WorldSession::SendDoFlight	(	uint32	mountDisplayId,
		uint32	path,
		uint32	pathNode = `0`
	)

 {
     // remove fake death
     if (GetPlayer()->HasUnitState(UNIT_STATE_DIED))
         GetPlayer()->RemoveAurasByType(SPELL_AURA_FEIGN_DEATH);
 
     while (GetPlayer()->GetMotionMaster()->GetCurrentMovementGeneratorType() == FLIGHT_MOTION_TYPE)
         GetPlayer()->GetMotionMaster()->MovementExpired(false);
 
     if (mountDisplayId)
         GetPlayer()->Mount(mountDisplayId);
 
     GetPlayer()->GetMotionMaster()->MoveTaxiFlight(path, pathNode);
 }

Here is the call graph for this function:

void WorldSession::SendEnchantmentLog	(	ObjectGuid	target,
		ObjectGuid	caster,
		uint32	itemId,
		uint32	enchantId
	)

 {
     WorldPacket data(SMSG_ENCHANTMENT_LOG, (8+8+4+4));
     data << target;
     data << caster;
     data << uint32(itemId);
     data << uint32(enchantId);
     GetPlayer()->SendMessageToSet(&data, true);
 }

Here is the call graph for this function:

void WorldSession::SendFeatureSystemStatus ( )

START OF DUMMY VALUES

END OF DUMMY VALUES

 {
     WorldPackets::System::FeatureSystemStatus features;
 
     features.ComplaintStatus = 2;
     features.ScrollOfResurrectionRequestsRemaining = 1;
     features.ScrollOfResurrectionMaxRequestsPerDay = 1;
     features.TwitterPostThrottleLimit = 60;
     features.TwitterPostThrottleCooldown = 20;
     features.CfgRealmID = 2;
     features.CfgRealmRecID = 0;
     features.TokenPollTimeSeconds = 300;
     features.TokenRedeemIndex = 0;
     features.VoiceEnabled = false;
     features.BrowserEnabled = false; // Has to be false, otherwise client will crash if "Customer Support" is opened
 
     features.EuropaTicketSystemStatus = boost::in_place();
     features.EuropaTicketSystemStatus->ThrottleState.MaxTries = 10;
     features.EuropaTicketSystemStatus->ThrottleState.PerMilliseconds = 60000;
     features.EuropaTicketSystemStatus->ThrottleState.TryCount = 1;
     features.EuropaTicketSystemStatus->ThrottleState.LastResetTimeBeforeNow = 111111;
     features.ComplaintStatus = 0;
     features.TutorialsEnabled = true;
     features.NPETutorialsEnabled = true;
 
     features.EuropaTicketSystemStatus->TicketsEnabled = sWorld->getBoolConfig(CONFIG_SUPPORT_TICKETS_ENABLED);
     features.EuropaTicketSystemStatus->BugsEnabled = sWorld->getBoolConfig(CONFIG_SUPPORT_BUGS_ENABLED);
     features.EuropaTicketSystemStatus->ComplaintsEnabled = sWorld->getBoolConfig(CONFIG_SUPPORT_COMPLAINTS_ENABLED);
     features.EuropaTicketSystemStatus->SuggestionsEnabled = sWorld->getBoolConfig(CONFIG_SUPPORT_SUGGESTIONS_ENABLED);
 
     features.CharUndeleteEnabled = sWorld->getBoolConfig(CONFIG_FEATURE_SYSTEM_CHARACTER_UNDELETE_ENABLED);
     features.BpayStoreEnabled = sWorld->getBoolConfig(CONFIG_FEATURE_SYSTEM_BPAY_STORE_ENABLED);
 
     SendPacket(features.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::SendFeatureSystemStatusGlueScreen ( )

 {
     WorldPackets::System::FeatureSystemStatusGlueScreen features;
     features.BpayStoreAvailable = false;
     features.BpayStoreDisabledByParentalControls = false;
     features.CharUndeleteEnabled = sWorld->getBoolConfig(CONFIG_FEATURE_SYSTEM_CHARACTER_UNDELETE_ENABLED);
     features.BpayStoreEnabled = sWorld->getBoolConfig(CONFIG_FEATURE_SYSTEM_BPAY_STORE_ENABLED);
 
     SendPacket(features.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     WorldPackets::Item::ItemEnchantTimeUpdate data;
     data.ItemGuid = Itemguid;
     data.DurationLeft = Duration;
     data.Slot = slot;
     data.OwnerGuid = Playerguid;
     SendPacket(data.Write());
 }

Here is the call graph for this function:

bool WorldSession::SendItemInfo	(	uint32	itemid,
		WorldPacket	data
	)

void WorldSession::SendItemPageInfo ( ItemTemplate * itemProto )

bool WorldSession::SendLearnNewTaxiNode ( Creature * unit )

 {
     // find current node
     uint32 curloc = sObjectMgr->GetNearestTaxiNode(unit->GetPositionX(), unit->GetPositionY(), unit->GetPositionZ(), unit->GetMapId(), GetPlayer()->GetTeam());
 
     if (curloc == 0)
         return true;                                        // `true` send to avoid WorldSession::SendTaxiMenu call with one more curlock seartch with same false result.
 
     if (GetPlayer()->m_taxi.SetTaximaskNode(curloc))
     {
         SendPacket(WorldPackets::Taxi::NewTaxiPath().Write());
 
         WorldPackets::Taxi::TaxiNodeStatus data;
         data.Unit = unit->GetGUID();
         data.Status = TAXISTATUS_LEARNED;
         SendPacket(data.Write());
 
         return true;
     }
     else
         return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::SendLfgBootProposalUpdate ( lfg::LfgPlayerBoot const & boot )

 {
     ObjectGuid guid = GetPlayer()->GetGUID();
     lfg::LfgAnswer playerVote = boot.votes.find(guid)->second;
     uint8 votesNum = 0;
     uint8 agreeNum = 0;
     uint32 secsleft = uint8((boot.cancelTime - time(NULL)) / 1000);
     for (lfg::LfgAnswerContainer::const_iterator it = boot.votes.begin(); it != boot.votes.end(); ++it)
     {
         if (it->second != lfg::LFG_ANSWER_PENDING)
         {
             ++votesNum;
             if (it->second == lfg::LFG_ANSWER_AGREE)
                 ++agreeNum;
         }
     }
     TC_LOG_DEBUG("lfg", "SMSG_LFG_BOOT_PROPOSAL_UPDATE %s inProgress: %u - "
         "didVote: %u - agree: %u - victim: %s votes: %u - agrees: %u - left: %u - "
         "needed: %u - reason %s",
         GetPlayerInfo().c_str(), uint8(boot.inProgress), uint8(playerVote != lfg::LFG_ANSWER_PENDING),
         uint8(playerVote == lfg::LFG_ANSWER_AGREE), boot.victim.ToString().c_str(), votesNum, agreeNum,
         secsleft, lfg::LFG_GROUP_KICK_VOTES_NEEDED, boot.reason.c_str());
     WorldPacket data(SMSG_LFG_BOOT_PLAYER, 1 + 1 + 1 + 1 + 8 + 4 + 4 + 4 + 4 + boot.reason.length());
     data << uint8(boot.inProgress);                                 // Vote in progress
     data << uint8(agreeNum >= lfg::LFG_GROUP_KICK_VOTES_NEEDED);    // Did succeed
     data << uint8(playerVote != lfg::LFG_ANSWER_PENDING);           // Did Vote
     data << uint8(playerVote == lfg::LFG_ANSWER_AGREE);             // Agree
     data << boot.victim;                                            // Victim GUID
     data << uint32(votesNum);                                       // Total Votes
     data << uint32(agreeNum);                                       // Agree Count
     data << uint32(secsleft);                                       // Time Left
     data << uint32(lfg::LFG_GROUP_KICK_VOTES_NEEDED);               // Needed Votes
     data << boot.reason.c_str();                                    // Kick reason
     SendPacket(&data);
 }

Here is the call graph for this function:

void WorldSession::SendLfgDisabled ( )

 {
     TC_LOG_DEBUG("lfg", "SMSG_LFG_DISABLED %s", GetPlayerInfo().c_str());
     WorldPacket data(SMSG_LFG_DISABLED, 0);
     SendPacket(&data);
 }

Here is the call graph for this function:

void WorldSession::SendLfgJoinResult ( lfg::LfgJoinResultData const & joinData )

 {
     uint32 size = 0;
     ObjectGuid guid = GetPlayer()->GetGUID();
     uint32 queueId = sLFGMgr->GetQueueId(_player->GetGUID());
     for (lfg::LfgLockPartyMap::const_iterator it = joinData.lockmap.begin(); it != joinData.lockmap.end(); ++it)
         size += 8 + 4 + uint32(it->second.size()) * (4 + 4 + 4 + 4);
 
     TC_LOG_DEBUG("lfg", "SMSG_LFG_JOIN_RESULT %s checkResult: %u checkValue: %u",
         GetPlayerInfo().c_str(), joinData.result, joinData.state);
 
     WorldPacket data(SMSG_LFG_JOIN_RESULT, 4 + 4 + size);
     data << uint32(3);
     data << uint8(joinData.result);                        // Check Result
     data << uint32(queueId);                               // Queue Id
     data << uint8(joinData.state);                         // Check Value
     data << uint32(time(NULL));                            // Join date
     data.WriteBit(guid[2]);
     data.WriteBit(guid[7]);
     data.WriteBit(guid[3]);
     data.WriteBit(guid[0]);
     data.WriteBits(joinData.lockmap.size(), 24);
     for (lfg::LfgLockPartyMap::const_iterator it = joinData.lockmap.begin(); it != joinData.lockmap.end(); ++it)
     {
         ObjectGuid playerGuid = it->first;
         data.WriteBit(playerGuid[7]);
         data.WriteBit(playerGuid[5]);
         data.WriteBit(playerGuid[3]);
         data.WriteBit(playerGuid[6]);
         data.WriteBit(playerGuid[0]);
         data.WriteBit(playerGuid[2]);
         data.WriteBit(playerGuid[4]);
         data.WriteBit(playerGuid[1]);
         data.WriteBits(it->second.size(), 22);
     }
 
     data.WriteBit(guid[4]);
     data.WriteBit(guid[5]);
     data.WriteBit(guid[1]);
     data.WriteBit(guid[6]);
     for (lfg::LfgLockPartyMap::const_iterator it = joinData.lockmap.begin(); it != joinData.lockmap.end(); ++it)
     {
         ObjectGuid playerGuid = it->first;
         for (lfg::LfgLockMap::const_iterator itr = it->second.begin(); itr != it->second.end(); ++itr)
         {
             TC_LOG_TRACE("lfg", "SendLfgJoinResult:: %s DungeonID: %u Lock status: %u Required itemLevel: %u Current itemLevel: %f",
                 playerGuid.ToString().c_str(), (itr->first & 0x00FFFFFF), itr->second.lockStatus, itr->second.requiredItemLevel, itr->second.currentItemLevel);
 
             data << uint32(itr->second.lockStatus);             // Lock status
             data << uint32(itr->second.currentItemLevel);       // Current itemLevel
             data << uint32(itr->second.requiredItemLevel);      // Required itemLevel
             data << uint32(itr->first);                         // Dungeon entry (id + type)
         }
 
         data.WriteByteSeq(playerGuid[2]);
         data.WriteByteSeq(playerGuid[5]);
         data.WriteByteSeq(playerGuid[1]);
         data.WriteByteSeq(playerGuid[0]);
         data.WriteByteSeq(playerGuid[4]);
         data.WriteByteSeq(playerGuid[3]);
         data.WriteByteSeq(playerGuid[6]);
         data.WriteByteSeq(playerGuid[7]);
     }
 
     data.WriteByteSeq(guid[1]);
     data.WriteByteSeq(guid[4]);
     data.WriteByteSeq(guid[3]);
     data.WriteByteSeq(guid[5]);
     data.WriteByteSeq(guid[0]);
     data.WriteByteSeq(guid[7]);
     data.WriteByteSeq(guid[2]);
     data.WriteByteSeq(guid[6]);
 
     SendPacket(&data);
 }

Here is the call graph for this function:

void WorldSession::SendLfgLfrList ( bool update )

 {
     //TC_LOG_DEBUG("lfg", "SMSG_LFG_LFR_LIST %s update: %u",
     //    GetPlayerInfo().c_str(), update ? 1 : 0);
     //WorldPacket data(SMSG_LFG_UPDATE_SEARCH, 1);
     //data << uint8(update);                                 // In Lfg Queue?
     //SendPacket(&data);
 }

void WorldSession::SendLfgOfferContinue ( uint32 dungeonEntry )

 {
     TC_LOG_DEBUG("lfg", "SMSG_LFG_OFFER_CONTINUE %s dungeon entry: %u",
         GetPlayerInfo().c_str(), dungeonEntry);
     WorldPacket data(SMSG_LFG_OFFER_CONTINUE, 4);
     data << uint32(dungeonEntry);
     SendPacket(&data);
 }

Here is the call graph for this function:

void WorldSession::SendLfgPartyLockInfo ( )

 {
     ObjectGuid guid = GetPlayer()->GetGUID();
     Group* group = GetPlayer()->GetGroup();
     if (!group)
         return;
 
     // Get the locked dungeons of the other party members
     lfg::LfgLockPartyMap lockMap;
     for (GroupReference* itr = group->GetFirstMember(); itr != NULL; itr = itr->next())
     {
         Player* plrg = itr->GetSource();
         if (!plrg)
             continue;
 
         ObjectGuid pguid = plrg->GetGUID();
         if (pguid == guid)
             continue;
 
         lockMap[pguid] = sLFGMgr->GetLockedDungeons(pguid);
     }
 
     uint32 size = 0;
     for (lfg::LfgLockPartyMap::const_iterator it = lockMap.begin(); it != lockMap.end(); ++it)
         size += 8 + 4 + uint32(it->second.size()) * (4 + 4 + 4 + 4);
 
     TC_LOG_DEBUG("lfg", "SMSG_LFG_PARTY_INFO %s", GetPlayerInfo().c_str());
     WorldPacket data(SMSG_LFG_PARTY_INFO, 1 + size);
     BuildPartyLockDungeonBlock(data, lockMap);
     SendPacket(&data);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::SendLfgPlayerLockInfo ( )

 {
     ObjectGuid guid = GetPlayer()->GetGUID();
 
     // Get Random dungeons that can be done at a certain level and expansion
     uint8 level = GetPlayer()->getLevel();
     lfg::LfgDungeonSet const& randomDungeons =
         sLFGMgr->GetRandomAndSeasonalDungeons(level, GetExpansion());
 
     // Get player locked Dungeons
     lfg::LfgLockMap const& lock = sLFGMgr->GetLockedDungeons(guid);
     uint32 rsize = uint32(randomDungeons.size());
     uint32 lsize = uint32(lock.size());
 
     TC_LOG_DEBUG("lfg", "SMSG_LFG_PLAYER_INFO %s", GetPlayerInfo().c_str());
     WorldPacket data(SMSG_LFG_PLAYER_INFO, 1 + rsize * (4 + 1 + 4 + 4 + 4 + 4 + 1 + 4 + 4 + 4) + 4 + lsize * (1 + 4 + 4 + 4 + 4 + 1 + 4 + 4 + 4));
 
     data << uint8(randomDungeons.size());                  // Random Dungeon count
     for (lfg::LfgDungeonSet::const_iterator it = randomDungeons.begin(); it != randomDungeons.end(); ++it)
     {
         data << uint32(*it);                               // Dungeon Entry (id + type)
         lfg::LfgReward const* reward = sLFGMgr->GetRandomDungeonReward(*it, level);
         Quest const* quest = NULL;
         bool done = false;
         if (reward)
         {
             quest = sObjectMgr->GetQuestTemplate(reward->firstQuest);
             if (quest)
             {
                 done = !GetPlayer()->CanRewardQuest(quest, false);
                 if (done)
                     quest = sObjectMgr->GetQuestTemplate(reward->otherQuest);
             }
         }
 
         data << uint8(done);
         data << uint32(0);                                              // currencyQuantity
         data << uint32(0);                                              // some sort of overall cap/weekly cap
         data << uint32(0);                                              // currencyID
         data << uint32(0);                                              // tier1Quantity
         data << uint32(0);                                              // tier1Limit
         data << uint32(0);                                              // overallQuantity
         data << uint32(0);                                              // overallLimit
         data << uint32(0);                                              // periodPurseQuantity
         data << uint32(0);                                              // periodPurseLimit
         data << uint32(0);                                              // purseQuantity
         data << uint32(0);                                              // purseLimit
         data << uint32(0);                                              // some sort of reward for completion
         data << uint32(0);                                              // completedEncounters
         data << uint8(0);                                               // Call to Arms eligible
 
         for (uint32 i = 0; i < 3; ++i)
         {
             data << uint32(0);                                          // Call to Arms Role
             //if (role)
             //    BuildQuestReward(data, ctaRoleQuest, GetPlayer());
         }
 
         if (quest)
             BuildQuestReward(data, quest, GetPlayer());
         else
         {
             data << uint32(0);                                          // Money
             data << uint32(0);                                          // XP
             data << uint8(0);                                           // Reward count
         }
     }
 
     BuildPlayerLockDungeonBlock(data, lock);
     SendPacket(&data);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::SendLfgPlayerReward ( lfg::LfgPlayerRewardData const & lfgPlayerRewardData )

 {
     if (!rewardData.rdungeonEntry || !rewardData.sdungeonEntry || !rewardData.quest)
         return;
 
     TC_LOG_DEBUG("lfg", "SMSG_LFG_PLAYER_REWARD %s rdungeonEntry: %u, sdungeonEntry: %u, done: %u",
         GetPlayerInfo().c_str(), rewardData.rdungeonEntry, rewardData.sdungeonEntry, rewardData.done);
 
     uint8 itemNum = rewardData.quest->GetRewItemsCount() + rewardData.quest->GetRewCurrencyCount();
 
     WorldPacket data(SMSG_LFG_PLAYER_REWARD, 4 + 4 + 1 + 4 + 4 + 4 + 4 + 4 + 1 + itemNum * (4 + 4 + 4));
     data << uint32(rewardData.rdungeonEntry);                               // Random Dungeon Finished
     data << uint32(rewardData.sdungeonEntry);                               // Dungeon Finished
     BuildQuestReward(data, rewardData.quest, GetPlayer());
     SendPacket(&data);
 }

Here is the call graph for this function:

void WorldSession::SendLfgQueueStatus ( lfg::LfgQueueStatusData const & queueData )

 {
     TC_LOG_DEBUG("lfg", "SMSG_LFG_QUEUE_STATUS %s state: %s, dungeon: %u, waitTime: %d, "
         "avgWaitTime: %d, waitTimeTanks: %d, waitTimeHealer: %d, waitTimeDps: %d, "
         "queuedTime: %u, tanks: %u, healers: %u, dps: %u",
         GetPlayerInfo().c_str(), lfg::GetStateString(sLFGMgr->GetState(GetPlayer()->GetGUID())).c_str(), queueData.dungeonId, queueData.waitTime, queueData.waitTimeAvg,
         queueData.waitTimeTank, queueData.waitTimeHealer, queueData.waitTimeDps,
         queueData.queuedTime, queueData.tanks, queueData.healers, queueData.dps);
 
     ObjectGuid guid = _player->GetGUID();
     WorldPacket data(SMSG_LFG_QUEUE_STATUS, 4 + 4 + 4 + 4 + 4 + 4 + 1 + 1 + 1 + 4 + 4 + 4 + 4 + 8);
     data.WriteBit(guid[3]);
     data.WriteBit(guid[0]);
     data.WriteBit(guid[2]);
     data.WriteBit(guid[6]);
     data.WriteBit(guid[5]);
     data.WriteBit(guid[7]);
     data.WriteBit(guid[1]);
     data.WriteBit(guid[4]);
 
     data.WriteByteSeq(guid[0]);
     data << uint8(queueData.tanks);                        // Tanks needed
     data << int32(queueData.waitTimeTank);                 // Wait Tanks
     data << uint8(queueData.healers);                      // Healers needed
     data << int32(queueData.waitTimeHealer);               // Wait Healers
     data << uint8(queueData.dps);                          // Dps needed
     data << int32(queueData.waitTimeDps);                  // Wait Dps
     data.WriteByteSeq(guid[4]);
     data.WriteByteSeq(guid[6]);
     data << int32(queueData.waitTime);                     // Wait Time
     data << uint32(queueData.joinTime);                    // Join time
     data << uint32(queueData.dungeonId);                   // Dungeon
     data << uint32(queueData.queuedTime);                  // Player wait time in queue
     data.WriteByteSeq(guid[5]);
     data.WriteByteSeq(guid[7]);
     data.WriteByteSeq(guid[3]);
     data << uint32(queueData.queueId);                     // Queue Id
     data.WriteByteSeq(guid[1]);
     data.WriteByteSeq(guid[2]);
     data << int32(queueData.waitTimeAvg);                  // Average Wait time
     data << uint32(3);
 
     SendPacket(&data);
 }

Here is the call graph for this function:

void WorldSession::SendLfgRoleCheckUpdate ( lfg::LfgRoleCheck const & pRoleCheck )

 {
     lfg::LfgDungeonSet dungeons;
     if (roleCheck.rDungeonId)
         dungeons.insert(roleCheck.rDungeonId);
     else
         dungeons = roleCheck.dungeons;
 
     TC_LOG_DEBUG("lfg", "SMSG_LFG_ROLE_CHECK_UPDATE %s", GetPlayerInfo().c_str());
     WorldPacket data(SMSG_LFG_ROLE_CHECK_UPDATE, 4 + 1 + 1 + dungeons.size() * 4 + 1 + roleCheck.roles.size() * (8 + 1 + 4 + 1));
 
     data << uint32(roleCheck.state);                       // Check result
     data << uint8(roleCheck.state == lfg::LFG_ROLECHECK_INITIALITING);
     data << uint8(dungeons.size());                        // Number of dungeons
     if (!dungeons.empty())
         for (lfg::LfgDungeonSet::iterator it = dungeons.begin(); it != dungeons.end(); ++it)
             data << uint32(sLFGMgr->GetLFGDungeonEntry(*it)); // Dungeon
 
     data << uint8(roleCheck.roles.size());                 // Players in group
     if (!roleCheck.roles.empty())
     {
         // Leader info MUST be sent 1st :S
         ObjectGuid guid = roleCheck.leader;
         uint8 roles = roleCheck.roles.find(guid)->second;
         Player* player = ObjectAccessor::FindConnectedPlayer(guid);
         data << guid;                                      // Guid
         data << uint8(roles > 0);                          // Ready
         data << uint32(roles);                             // Roles
         data << uint8(player ? player->getLevel() : 0);    // Level
 
         for (lfg::LfgRolesMap::const_iterator it = roleCheck.roles.begin(); it != roleCheck.roles.end(); ++it)
         {
             if (it->first == roleCheck.leader)
                 continue;
 
             guid = it->first;
             roles = it->second;
             player = ObjectAccessor::FindConnectedPlayer(guid);
             data << guid;                                  // Guid
             data << uint8(roles > 0);                      // Ready
             data << uint32(roles);                         // Roles
             data << uint8(player ? player->getLevel() : 0);// Level
         }
     }
     SendPacket(&data);
 }

Here is the call graph for this function:

void WorldSession::SendLfgRoleChosen	(	ObjectGuid	guid,
		uint8	roles
	)

 {
     TC_LOG_DEBUG("lfg", "SMSG_LFG_ROLE_CHOSEN %s guid: %s roles: %u",
         GetPlayerInfo().c_str(), guid.ToString().c_str(), roles);
 
     WorldPacket data(SMSG_ROLE_CHOSEN, 8 + 1 + 4);
     data << guid;                                           // Guid
     data << uint8(roles > 0);                              // Ready
     data << uint32(roles);                                 // Roles
     SendPacket(&data);
 }

Here is the call graph for this function:

void WorldSession::SendLfgTeleportError ( uint8 err )

 {
     TC_LOG_DEBUG("lfg", "SMSG_LFG_TELEPORT_DENIED %s reason: %u",
         GetPlayerInfo().c_str(), err);
     WorldPacket data(SMSG_LFG_TELEPORT_DENIED, 4);
     data << uint32(err);                                   // Error
     SendPacket(&data);
 }

Here is the call graph for this function:

void WorldSession::SendLfgUpdateProposal ( lfg::LfgProposal const & proposal )

 {
     ObjectGuid guid = GetPlayer()->GetGUID();
     ObjectGuid gguid = proposal.players.find(guid)->second.group;
     bool silent = !proposal.isNew && gguid == proposal.group;
     uint32 dungeonEntry = proposal.dungeonId;
     uint32 queueId = sLFGMgr->GetQueueId(_player->GetGUID());
     time_t joinTime = sLFGMgr->GetQueueJoinTime(_player->GetGUID());
 
     TC_LOG_DEBUG("lfg", "SMSG_LFG_PROPOSAL_UPDATE %s state: %u",
         GetPlayerInfo().c_str(), proposal.state);
 
     // show random dungeon if player selected random dungeon and it's not lfg group
     if (!silent)
     {
         lfg::LfgDungeonSet const& playerDungeons = sLFGMgr->GetSelectedDungeons(guid);
         if (playerDungeons.find(proposal.dungeonId) == playerDungeons.end())
             dungeonEntry = (*playerDungeons.begin());
     }
 
     dungeonEntry = sLFGMgr->GetLFGDungeonEntry(dungeonEntry);
 
     WorldPacket data(SMSG_LFG_PROPOSAL_UPDATE, 4 + 1 + 4 + 4 + 1 + 1 + proposal.players.size() * (4 + 1 + 1 + 1 + 1 +1));
     data << uint32(joinTime);
     data << uint32(proposal.encounters);                   // Encounters done
     data << uint32(queueId);                               // Queue Id
     data << uint32(3);                                     // Always 3
     data << uint32(dungeonEntry);                          // Dungeon
     data << uint32(proposal.id);                           // Proposal Id
     data << uint8(proposal.state);                         // State
 
     ObjectGuid guid1 = guid;
     ObjectGuid guid2 = gguid;
 
     data.WriteBit(guid2[4]);
     data.WriteBit(guid1[3]);
     data.WriteBit(guid1[7]);
     data.WriteBit(guid1[0]);
     data.WriteBit(guid2[1]);
     data.WriteBit(silent);
     data.WriteBit(guid1[4]);
     data.WriteBit(guid1[5]);
     data.WriteBit(guid2[3]);
     data.WriteBits(proposal.players.size(), 23);
     data.WriteBit(guid2[7]);
 
     for (lfg::LfgProposalPlayerContainer::const_iterator it = proposal.players.begin(); it != proposal.players.end(); ++it)
     {
         lfg::LfgProposalPlayer const& player = it->second;
 
         if (!player.group)
         {
             data.WriteBit(0);
             data.WriteBit(0);
         }
         else
         {
             data.WriteBit(player.group == proposal.group);      // Is group in dungeon
             data.WriteBit(player.group == gguid);               // Same group as the player
         }
 
         data.WriteBit(player.accept == lfg::LFG_ANSWER_AGREE);
         data.WriteBit(player.accept != lfg::LFG_ANSWER_PENDING);
         data.WriteBit(it->first == guid);
     }
 
     data.WriteBit(guid2[5]);
     data.WriteBit(guid1[6]);
     data.WriteBit(guid2[2]);
     data.WriteBit(guid2[6]);
     data.WriteBit(guid1[2]);
     data.WriteBit(guid1[1]);
     data.WriteBit(guid2[0]);
 
     data.WriteByteSeq(guid1[5]);
     data.WriteByteSeq(guid2[3]);
     data.WriteByteSeq(guid2[6]);
     data.WriteByteSeq(guid1[6]);
     data.WriteByteSeq(guid1[0]);
     data.WriteByteSeq(guid2[5]);
     data.WriteByteSeq(guid1[1]);
 
     for (lfg::LfgProposalPlayerContainer::const_iterator it = proposal.players.begin(); it != proposal.players.end(); ++it)
     {
         lfg::LfgProposalPlayer const& player = it->second;
         data << uint32(player.role);
     }
 
     data.WriteByteSeq(guid2[7]);
     data.WriteByteSeq(guid1[4]);
     data.WriteByteSeq(guid2[0]);
     data.WriteByteSeq(guid2[1]);
     data.WriteByteSeq(guid1[2]);
     data.WriteByteSeq(guid1[7]);
     data.WriteByteSeq(guid2[2]);
     data.WriteByteSeq(guid1[3]);
     data.WriteByteSeq(guid2[4]);
 
     SendPacket(&data);
 }

Here is the call graph for this function:

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

 {
     bool join = false;
     bool queued = false;
     uint8 size = uint8(updateData.dungeons.size());
     ObjectGuid guid = _player->GetGUID();
     time_t joinTime = sLFGMgr->GetQueueJoinTime(_player->GetGUID());
     uint32 queueId = sLFGMgr->GetQueueId(_player->GetGUID());
 
     switch (updateData.updateType)
     {
         case lfg::LFG_UPDATETYPE_JOIN_QUEUE_INITIAL:            // Joined queue outside the dungeon
             join = true;
             break;
         case lfg::LFG_UPDATETYPE_JOIN_QUEUE:
         case lfg::LFG_UPDATETYPE_ADDED_TO_QUEUE:                // Rolecheck Success
             join = true;
             queued = true;
             break;
         case lfg::LFG_UPDATETYPE_PROPOSAL_BEGIN:
             join = true;
             break;
         case lfg::LFG_UPDATETYPE_UPDATE_STATUS:
             join = updateData.state != lfg::LFG_STATE_ROLECHECK && updateData.state != lfg::LFG_STATE_NONE;
             queued = updateData.state == lfg::LFG_STATE_QUEUED;
             break;
         default:
             break;
     }
 
     TC_LOG_DEBUG("lfg", "SMSG_LFG_UPDATE_STATUS %s updatetype: %u, party %s",
         GetPlayerInfo().c_str(), updateData.updateType, party ? "true" : "false");
 
     WorldPacket data(SMSG_LFG_UPDATE_STATUS, 1 + 8 + 3 + 2 + 1 + updateData.comment.length() + 4 + 4 + 1 + 1 + 1 + 4 + size);
     data.WriteBit(guid[1]);
     data.WriteBit(party);
     data.WriteBits(size, 24);
     data.WriteBit(guid[6]);
     data.WriteBit(size > 0);                               // Extra info
     data.WriteBits(updateData.comment.length(), 9);
     data.WriteBit(guid[4]);
     data.WriteBit(guid[7]);
     data.WriteBit(guid[2]);
     data.WriteBit(join);                                   // LFG Join
     data.WriteBit(guid[0]);
     data.WriteBit(guid[3]);
     data.WriteBit(guid[5]);
     data.WriteBit(queued);                                 // Join the queue
 
     data << uint8(updateData.updateType);                  // Lfg Update type
     data.WriteString(updateData.comment);
     data << uint32(queueId);                               // Queue Id
     data << uint32(joinTime);                              // Join date
     data.WriteByteSeq(guid[6]);
     for (uint8 i = 0; i < 3; ++i)
         data << uint8(0);                                  // unk - Always 0
 
     data.WriteByteSeq(guid[1]);
     data.WriteByteSeq(guid[2]);
     data.WriteByteSeq(guid[4]);
     data.WriteByteSeq(guid[3]);
     data.WriteByteSeq(guid[5]);
     data.WriteByteSeq(guid[0]);
     data << uint32(3);
     data.WriteByteSeq(guid[7]);
     for (lfg::LfgDungeonSet::const_iterator it = updateData.dungeons.begin(); it != updateData.dungeons.end(); ++it)
         data << uint32(*it);
 
     SendPacket(&data);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::SendListInventory ( ObjectGuid guid )

 {
     TC_LOG_DEBUG("network", "WORLD: Sent SMSG_LIST_INVENTORY");
 
     Creature* vendor = GetPlayer()->GetNPCIfCanInteractWith(vendorGuid, UNIT_NPC_FLAG_VENDOR);
     if (!vendor)
     {
         TC_LOG_DEBUG("network", "WORLD: SendListInventory - %s not found or you can not interact with him.", vendorGuid.ToString().c_str());
         _player->SendSellError(SELL_ERR_CANT_FIND_VENDOR, NULL, ObjectGuid::Empty);
         return;
     }
 
     // remove fake death
     if (GetPlayer()->HasUnitState(UNIT_STATE_DIED))
         GetPlayer()->RemoveAurasByType(SPELL_AURA_FEIGN_DEATH);
 
     // Stop the npc if moving
     if (vendor->HasUnitState(UNIT_STATE_MOVING))
         vendor->StopMoving();
 
     VendorItemData const* vendorItems = vendor->GetVendorItems();
     uint32 rawItemCount = vendorItems ? vendorItems->GetItemCount() : 0;
 
     WorldPackets::NPC::VendorInventory packet;
     packet.Vendor = vendor->GetGUID();
 
     packet.Items.resize(rawItemCount);
 
     const float discountMod = _player->GetReputationPriceDiscount(vendor);
     uint8 count = 0;
     for (uint32 slot = 0; slot < rawItemCount; ++slot)
     {
         VendorItem const* vendorItem = vendorItems->GetItem(slot);
         if (!vendorItem)
             continue;
 
         WorldPackets::NPC::VendorItem& item = packet.Items[count];
 
         if (vendorItem->Type == ITEM_VENDOR_TYPE_ITEM)
         {
             ItemTemplate const* itemTemplate = sObjectMgr->GetItemTemplate(vendorItem->item);
             if (!itemTemplate)
                 continue;
 
             int32 leftInStock = !vendorItem->maxcount ? -1 : vendor->GetVendorItemCurrentCount(vendorItem);
             if (!_player->IsGameMaster()) // ignore conditions if GM on
             {
                 // Respect allowed class
                 if (!(itemTemplate->GetAllowableClass() & _player->getClassMask()) && itemTemplate->GetBonding() == BIND_WHEN_PICKED_UP)
                     continue;
 
                 // Only display items in vendor lists for the team the player is on
                 if ((itemTemplate->GetFlags2() & ITEM_FLAG2_HORDE_ONLY && _player->GetTeam() == ALLIANCE) ||
                     (itemTemplate->GetFlags2() & ITEM_FLAG2_ALLIANCE_ONLY && _player->GetTeam() == HORDE))
                     continue;
 
                 // Items sold out are not displayed in list
                 if (leftInStock == 0)
                     continue;
             }
 
             if (!sConditionMgr->IsObjectMeetingVendorItemConditions(vendor->GetEntry(), vendorItem->item, _player, vendor))
             {
                 TC_LOG_DEBUG("condition", "SendListInventory: conditions not met for creature entry %u item %u", vendor->GetEntry(), vendorItem->item);
                 continue;
             }
 
             int32 price = vendorItem->IsGoldRequired(itemTemplate) ? uint32(floor(itemTemplate->GetBuyPrice() * discountMod)) : 0;
 
             if (int32 priceMod = _player->GetTotalAuraModifier(SPELL_AURA_MOD_VENDOR_ITEMS_PRICES))
                 price -= CalculatePct(price, priceMod);
 
             item.MuID = slot + 1; // client expects counting to start at 1
             item.Durability = itemTemplate->MaxDurability;
             item.ExtendedCostID = vendorItem->ExtendedCost;
             item.Type = vendorItem->Type;
             item.Quantity = leftInStock;
             item.StackCount = itemTemplate->GetBuyCount();
             item.Price = price;
 
             item.Item.ItemID = vendorItem->item;
         }
         else if (vendorItem->Type == ITEM_VENDOR_TYPE_CURRENCY)
         {
             CurrencyTypesEntry const* currencyTemplate = sCurrencyTypesStore.LookupEntry(vendorItem->item);
             if (!currencyTemplate)
                 continue;
 
             if (!vendorItem->ExtendedCost)
                 continue; // there's no price defined for currencies, only extendedcost is used
 
             item.MuID = slot + 1; // client expects counting to start at 1
             item.ExtendedCostID = vendorItem->ExtendedCost;
             item.Item.ItemID = vendorItem->item;
             item.Type = vendorItem->Type;
             item.StackCount = vendorItem->maxcount;
         }
         else
             continue;
 
         if (++count >= MAX_VENDOR_ITEMS)
             break;
     }
 
     // Resize vector to real size (some items can be skipped due to checks)
     packet.Items.resize(count);
 
     SendPacket(packet.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::SendLoadCUFProfiles ( )

 {
     Player* player = GetPlayer();
 
     WorldPackets::Misc::LoadCUFProfiles loadCUFProfiles;
 
     for (uint8 i = 0; i < MAX_CUF_PROFILES; i++)
         if (CUFProfile* cufProfile = player->GetCUFProfile(i))
             loadCUFProfiles.CUFProfiles.push_back(cufProfile);
     SendPacket(loadCUFProfiles.Write());
 }

Here is the call graph for this function:

void WorldSession::SendNameQueryOpcode ( ObjectGuid guid )

 {
     Player* player = ObjectAccessor::FindConnectedPlayer(guid);
 
     WorldPackets::Query::QueryPlayerNameResponse response;
     response.Player = guid;
 
     if (response.Data.Initialize(guid, player))
         response.Result = RESPONSE_SUCCESS; // name known
     else
         response.Result = RESPONSE_FAILURE; // name unknown
 
     SendPacket(response.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::SendNotification	(	char const *	format,
			...
	)

 {
     if (format)
     {
         va_list ap;
         char szStr[1024];
         szStr[0] = '\0';
         va_start(ap, format);
         vsnprintf(szStr, 1024, format, ap);
         va_end(ap);
 
         SendPacket(WorldPackets::Chat::PrintNotification(szStr).Write());
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::SendNotification	(	uint32	stringId,
			...
	)

 {
     char const* format = GetTrinityString(stringId);
     if (format)
     {
         va_list ap;
         char szStr[1024];
         szStr[0] = '\0';
         va_start(ap, stringId);
         vsnprintf(szStr, 1024, format, ap);
         va_end(ap);
 
         SendPacket(WorldPackets::Chat::PrintNotification(szStr).Write());
     }
 }

Here is the call graph for this function:

void WorldSession::SendNotInArenaTeamPacket ( uint8 type )

 {
     WorldPacket data(SMSG_ARENA_ERROR, 4+1);
     uint32 error = 0;
     data << uint32(error);                                  // 0 = ERR_ARENA_NO_TEAM_II, 1 = ERR_ARENA_EXPIRED_CAIS, 2 = ERR_LFG_CANT_USE_BATTLEGROUND
     if (!error)
         data << uint8(type);                                // team type (2=2v2, 3=3v3, 5=5v5), can be used for custom types...
     SendPacket(&data);
 }

Here is the call graph for this function:

void WorldSession::SendPacket	(	WorldPacket const *	packet,
		bool	forced = `false`
	)

Send a packet to the client.

 {
     if (packet->GetOpcode() == NULL_OPCODE)
     {
         TC_LOG_ERROR("network.opcode", "Prevented sending of NULL_OPCODE to %s", GetPlayerInfo().c_str());
         return;
     }
     else if (packet->GetOpcode() == UNKNOWN_OPCODE)
     {
         TC_LOG_ERROR("network.opcode", "Prevented sending of UNKNOWN_OPCODE to %s", GetPlayerInfo().c_str());
         return;
     }
 
     ServerOpcodeHandler const* handler = opcodeTable[static_cast<OpcodeServer>(packet->GetOpcode())];
 
     if (!handler)
     {
         TC_LOG_ERROR("network.opcode", "Prevented sending of opcode %u with non existing handler to %s", packet->GetOpcode(), GetPlayerInfo().c_str());
         return;
     }
 
     // Default connection index defined in Opcodes.cpp table
     ConnectionType conIdx = handler->ConnectionIndex;
 
     // Override connection index
     if (packet->GetConnection() != CONNECTION_TYPE_DEFAULT)
     {
         if (packet->GetConnection() != CONNECTION_TYPE_INSTANCE && IsInstanceOnlyOpcode(packet->GetOpcode()))
         {
             TC_LOG_ERROR("network.opcode", "Prevented sending of instance only opcode %u with connection type %u to %s", packet->GetOpcode(), packet->GetConnection(), GetPlayerInfo().c_str());
             return;
         }
 
         conIdx = packet->GetConnection();
     }
 
     if (!m_Socket[conIdx])
     {
         TC_LOG_ERROR("network.opcode", "Prevented sending of %s to non existent socket %u to %s", GetOpcodeNameForLogging(static_cast<OpcodeServer>(packet->GetOpcode())).c_str(), conIdx, GetPlayerInfo().c_str());
         return;
     }
 
     if (!forced)
     {
         if (handler->Status == STATUS_UNHANDLED)
         {
             TC_LOG_ERROR("network.opcode", "Prevented sending disabled opcode %s to %s", GetOpcodeNameForLogging(static_cast<OpcodeServer>(packet->GetOpcode())).c_str(), GetPlayerInfo().c_str());
             return;
         }
     }
 
 #ifdef TRINITY_DEBUG
     // Code for network use statistic
     static uint64 sendPacketCount = 0;
     static uint64 sendPacketBytes = 0;
 
     static time_t firstTime = time(NULL);
     static time_t lastTime = firstTime;                     // next 60 secs start time
 
     static uint64 sendLastPacketCount = 0;
     static uint64 sendLastPacketBytes = 0;
 
     time_t cur_time = time(NULL);
 
     if ((cur_time - lastTime) < 60)
     {
         sendPacketCount+=1;
         sendPacketBytes+=packet->size();
 
         sendLastPacketCount+=1;
         sendLastPacketBytes+=packet->size();
     }
     else
     {
         uint64 minTime = uint64(cur_time - lastTime);
         uint64 fullTime = uint64(lastTime - firstTime);
         TC_LOG_DEBUG("misc", "Send all time packets count: " UI64FMTD " bytes: " UI64FMTD " avr.count/sec: %f avr.bytes/sec: %f time: %u", sendPacketCount, sendPacketBytes, float(sendPacketCount)/fullTime, float(sendPacketBytes)/fullTime, uint32(fullTime));
         TC_LOG_DEBUG("misc", "Send last min packets count: " UI64FMTD " bytes: " UI64FMTD " avr.count/sec: %f avr.bytes/sec: %f", sendLastPacketCount, sendLastPacketBytes, float(sendLastPacketCount)/minTime, float(sendLastPacketBytes)/minTime);
 
         lastTime = cur_time;
         sendLastPacketCount = 1;
         sendLastPacketBytes = packet->wpos();               // wpos is real written size
     }
 #endif                                                      // !TRINITY_DEBUG
 
     sScriptMgr->OnPacketSend(this, *packet);
 
     TC_LOG_TRACE("network.opcode", "S->C: %s %s", GetPlayerInfo().c_str(), GetOpcodeNameForLogging(static_cast<OpcodeServer>(packet->GetOpcode())).c_str());
     m_Socket[conIdx]->SendPacket(*packet);
 }

Here is the call graph for this function:

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

 {
     WorldPackets::Party::PartyCommandResult packet;
 
     packet.Name = member;
     packet.Command = uint8(operation);
     packet.Result = uint8(res);
     packet.ResultData = val;
     packet.ResultGUID = ObjectGuid::Empty;
 
     SendPacket(packet.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::SendPetitionQueryOpcode ( ObjectGuid petitionguid )

 {
     ObjectGuid ownerGUID;
     std::string title = "NO_NAME_FOR_GUID";
 
     WorldPackets::Petition::QueryPetitionResponse responsePacket;
     responsePacket.PetitionID = uint32(petitionGUID.GetCounter());  // PetitionID (in Trinity always same as GUID_LOPART(petition guid))
 
     PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_PETITION);
 
     stmt->setUInt64(0, petitionGUID.GetCounter());
 
     PreparedQueryResult result = CharacterDatabase.Query(stmt);
 
     if (result)
     {
         Field* fields = result->Fetch();
         ownerGUID = ObjectGuid::Create<HighGuid::Player>(fields[0].GetUInt64());
         title     = fields[1].GetString();
     }
     else
     {
         responsePacket.Allow = false;
         SendPacket(responsePacket.Write());
 
         TC_LOG_DEBUG("network", "CMSG_PETITION_QUERY failed for petition (%s)", petitionGUID.ToString().c_str());
         return;
     }
 
     int32 reqSignatures = sWorld->getIntConfig(CONFIG_MIN_PETITION_SIGNS);
 
     WorldPackets::Petition::PetitionInfo petitionInfo;
     petitionInfo.PetitionID = int32(petitionGUID.GetCounter());
     petitionInfo.Petitioner = ownerGUID;
     petitionInfo.MinSignatures = reqSignatures;
     petitionInfo.MaxSignatures = reqSignatures;
     petitionInfo.Title = title;
 
     responsePacket.Allow = true;
     responsePacket.Info = petitionInfo;
 
     SendPacket(responsePacket.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::SendPetitionShowList ( ObjectGuid guid )

 {
     Creature* creature = GetPlayer()->GetNPCIfCanInteractWith(guid, UNIT_NPC_FLAG_PETITIONER);
     if (!creature)
     {
         TC_LOG_DEBUG("network", "WORLD: HandlePetitionShowListOpcode - %s not found or you can't interact with him.", guid.ToString().c_str());
         return;
     }
 
     WorldPackets::Petition::ServerPetitionShowList packet;
     packet.Unit = guid;
     packet.Price = uint32(sWorld->getIntConfig(CONFIG_CHARTER_COST_GUILD));
     SendPacket(packet.Write());
 
     TC_LOG_DEBUG("network", "Sent SMSG_PETITION_SHOW_LIST");
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::SendPetNameInvalid	(	uint32	error,
		std::string const &	name,
		DeclinedName *	declinedName
	)

 {
     WorldPackets::Pet::PetNameInvalid petNameInvalid;
     petNameInvalid.Result = error;
     petNameInvalid.RenameData.NewName = name;
     for (int i = 0; i < MAX_DECLINED_NAME_CASES; i++)
         petNameInvalid.RenameData.DeclinedNames.name[i] = declinedName[i].name[i];
 
     SendPacket(petNameInvalid.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::SendPetStableResult ( uint8 guid )

 {
     WorldPacket data(SMSG_PET_STABLE_RESULT, 1);
     data << uint8(res);
     SendPacket(&data);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::SendPlayerAmbiguousNotice ( std::string const & name )

 {
     SendPacket(WorldPackets::Chat::ChatPlayerAmbiguous(name).Write());
 }

Here is the call graph for this function:

void WorldSession::SendQueryPetNameResponse ( ObjectGuid guid )

 {
     WorldPackets::Query::QueryPetNameResponse response;
 
     response.UnitGUID = guid;
 
     if (Creature* unit = ObjectAccessor::GetCreatureOrPetOrVehicle(*_player, guid))
     {
         response.Allow = true;
         response.Timestamp = unit->GetUInt32Value(UNIT_FIELD_PET_NAME_TIMESTAMP);
         response.Name = unit->GetName();
 
         if (Pet* pet = unit->ToPet())
         {
             if (DeclinedName const* names = pet->GetDeclinedNames())
             {
                 response.HasDeclined = true;
                 response.DeclinedNames = *names;
             }
         }
     }
 
     _player->GetSession()->SendPacket(response.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::SendQueryTimeResponse ( )

 {
     WorldPackets::Query::QueryTimeResponse queryTimeResponse;
     queryTimeResponse.CurrentTime = time(nullptr);
     queryTimeResponse.TimeOutRequest = sWorld->GetNextDailyQuestsResetTime() - queryTimeResponse.CurrentTime;
     SendPacket(queryTimeResponse.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::SendSetPhaseShift	(	std::set< uint32 > const &	phaseIds,
		std::set< uint32 > const &	terrainswaps,
		std::set< uint32 > const &	worldMapAreaSwaps
	)

 {
     WorldPackets::Misc::PhaseShift phaseShift;
     phaseShift.ClientGUID = _player->GetGUID();
     phaseShift.PersonalGUID = _player->GetGUID();
     phaseShift.PhaseShifts = phaseIds;
     phaseShift.VisibleMapIDs = terrainswaps;
     phaseShift.UiWorldMapAreaIDSwaps = worldMapAreaSwaps;
     SendPacket(phaseShift.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::SendSetPlayerDeclinedNamesResult	(	DeclinedNameResult	result,
		ObjectGuid	guid
	)

 {
     WorldPackets::Character::SetPlayerDeclinedNamesResult packet;
     packet.ResultCode = result;
     packet.Player = guid;
 
     SendPacket(packet.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::SendSetTimeZoneInformation ( )

Todo:: : replace dummy values

 {
     WorldPackets::System::SetTimeZoneInformation packet;
     packet.ServerTimeTZ = "Europe/Paris";
     packet.GameTimeTZ = "Europe/Paris";
 
     SendPacket(packet.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::SendShowBank ( ObjectGuid guid )

 {
     m_currentBankerGUID = guid;
     WorldPackets::NPC::ShowBank packet;
     packet.Guid = guid;
     SendPacket(packet.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::SendShowMailBox ( ObjectGuid guid )

 {
     WorldPackets::Mail::ShowMailbox packet;
     packet.PostmasterGUID = guid;
     SendPacket(packet.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::SendSpiritResurrect ( )

 {
     _player->ResurrectPlayer(0.5f, true);
     _player->DurabilityLossAll(0.25f, true);
 
     // get corpse nearest graveyard
     WorldSafeLocsEntry const* corpseGrave = NULL;
     WorldLocation corpseLocation = _player->GetCorpseLocation();
     if (_player->HasCorpse())
     {
         corpseGrave = sObjectMgr->GetClosestGraveYard(corpseLocation.GetPositionX(), corpseLocation.GetPositionY(),
             corpseLocation.GetPositionZ(), corpseLocation.GetMapId(), _player->GetTeam());
     }
 
     // now can spawn bones
     _player->SpawnCorpseBones();
 
     // teleport to nearest from corpse graveyard, if different from nearest to player ghost
     if (corpseGrave)
     {
         WorldSafeLocsEntry const* ghostGrave = sObjectMgr->GetClosestGraveYard(
             _player->GetPositionX(), _player->GetPositionY(), _player->GetPositionZ(), _player->GetMapId(), _player->GetTeam());
 
         if (corpseGrave != ghostGrave)
             _player->TeleportTo(corpseGrave->MapID, corpseGrave->Loc.X, corpseGrave->Loc.Y, corpseGrave->Loc.Z, (corpseGrave->Facing * M_PI) / 180); // Orientation is initially in degrees
         // or update at original position
         else
             _player->UpdateObjectVisibility();
     }
     // or update at original position
     else
         _player->UpdateObjectVisibility();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::SendStablePet ( ObjectGuid guid )

 {
     PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_PET_SLOTS_DETAIL);
 
     stmt->setUInt64(0, _player->GetGUID().GetCounter());
     stmt->setUInt8(1, PET_SAVE_FIRST_STABLE_SLOT);
     stmt->setUInt8(2, PET_SAVE_LAST_STABLE_SLOT);
 
     _sendStabledPetCallback.SetParam(guid);
     _sendStabledPetCallback.SetFutureResult(CharacterDatabase.AsyncQuery(stmt));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::SendStablePetCallback	(	PreparedQueryResult	result,
		ObjectGuid	guid
	)

 {
     if (!GetPlayer())
         return;
 
     WorldPackets::Pet::PetStableList packet;
 
     packet.StableMaster = guid;
 
     Pet* pet = _player->GetPet();
 
     int32 petSlot = 0;
     // not let move dead pet in slot
     if (pet && pet->IsAlive() && pet->getPetType() == HUNTER_PET)
     {
         WorldPackets::Pet::PetStableInfo stableEntry;
         stableEntry.PetSlot = petSlot;
         stableEntry.PetNumber = pet->GetCharmInfo()->GetPetNumber();
         stableEntry.CreatureID = pet->GetEntry();
         stableEntry.DisplayID = pet->GetDisplayId();
         stableEntry.ExperienceLevel = pet->getLevel();
         stableEntry.PetFlags = PET_STABLE_ACTIVE;
         stableEntry.PetName = pet->GetName();                                       
         ++petSlot;
 
         packet.Pets.push_back(stableEntry);
     }
 
     if (result)
     {
         do
         {
             Field* fields = result->Fetch();
             WorldPackets::Pet::PetStableInfo stableEntry;
 
             stableEntry.PetSlot = petSlot;
             stableEntry.PetNumber = fields[1].GetUInt32();          // petnumber
             stableEntry.CreatureID = fields[2].GetUInt32();         // creature entry
             stableEntry.DisplayID = fields[5].GetUInt32();          // creature displayid
             stableEntry.ExperienceLevel = fields[3].GetUInt16();    // level
             stableEntry.PetFlags = PET_STABLE_INACTIVE;
             stableEntry.PetName = fields[4].GetString();            // Name
 
             ++petSlot;
             packet.Pets.push_back(stableEntry);
         }
         while (result->NextRow());
     }
 
     SendPacket(packet.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::SendTabardVendorActivate ( ObjectGuid guid )

 {
     WorldPackets::NPC::PlayerTabardVendorActivate packet;
     packet.Vendor = guid;
     SendPacket(packet.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::SendTaxiMenu ( Creature * unit )

 {
     // find current node
     uint32 curloc = sObjectMgr->GetNearestTaxiNode(unit->GetPositionX(), unit->GetPositionY(), unit->GetPositionZ(), unit->GetMapId(), GetPlayer()->GetTeam());
     if (!curloc)
         return;
 
     bool lastTaxiCheaterState = GetPlayer()->isTaxiCheater();
     if (unit->GetEntry() == 29480)
         GetPlayer()->SetTaxiCheater(true); // Grimwing in Ebon Hold, special case. NOTE: Not perfect, Zul'Aman should not be included according to WoWhead, and I think taxicheat includes it.
 
     TC_LOG_DEBUG("network", "WORLD: CMSG_TAXINODE_STATUS_QUERY %u ", curloc);
 
     WorldPackets::Taxi::ShowTaxiNodes data;
     data.WindowInfo = boost::in_place();
     data.WindowInfo->UnitGUID = unit->GetGUID();
     data.WindowInfo->CurrentNode = curloc;
 
     GetPlayer()->m_taxi.AppendTaximaskTo(data, lastTaxiCheaterState);
 
     SendPacket(data.Write());
 
     GetPlayer()->SetTaxiCheater(lastTaxiCheaterState);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::SendTaxiStatus ( ObjectGuid guid )

 {
     // cheating checks
     Creature* unit = GetPlayer()->GetMap()->GetCreature(guid);
     if (!unit)
     {
         TC_LOG_DEBUG("network", "WorldSession::SendTaxiStatus - %s not found.", guid.ToString().c_str());
         return;
     }
 
     uint32 curloc = sObjectMgr->GetNearestTaxiNode(unit->GetPositionX(), unit->GetPositionY(), unit->GetPositionZ(), unit->GetMapId(), GetPlayer()->GetTeam());
 
     WorldPackets::Taxi::TaxiNodeStatus data;
     data.Unit = guid;
 
     if (!curloc)
         data.Status = TAXISTATUS_NONE;
     else if (unit->GetReactionTo(GetPlayer()) >= REP_NEUTRAL)
         data.Status = GetPlayer()->m_taxi.IsTaximaskNodeKnown(curloc) ? TAXISTATUS_LEARNED : TAXISTATUS_UNLEARNED;
     else
         data.Status = TAXISTATUS_NOT_ELIGIBLE;
 
     SendPacket(data.Write());
 
     TC_LOG_DEBUG("network", "WORLD: Sent SMSG_TAXI_NODE_STATUS");
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     info.Clear();   // reuse packet
     Player* trader = _player->GetTrader();
     info.PartnerIsSameBnetAccount = trader && trader->GetSession()->GetBattlenetAccountId() == GetBattlenetAccountId();
     SendPacket(info.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::SendTrainerBuyFailed	(	ObjectGuid	trainerGUID,
		uint32	spellID,
		int32	trainerFailedReason
	)

 {
     WorldPackets::NPC::TrainerBuyFailed trainerBuyFailed;
     trainerBuyFailed.TrainerGUID = trainerGUID;
     trainerBuyFailed.SpellID = spellID;                             // should be same as in packet from client
     trainerBuyFailed.TrainerFailedReason = trainerFailedReason;     // 1 == "Not enough money for trainer service." 0 == "Trainer service %d unavailable."
     SendPacket(trainerBuyFailed.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::SendTrainerList ( ObjectGuid guid )

 {
     std::string str = GetTrinityString(LANG_NPC_TAINER_HELLO);
     SendTrainerList(guid, str);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::SendTrainerList	(	ObjectGuid	guid,
		std::string const &	strTitle
	)

 {
     TC_LOG_DEBUG("network", "WORLD: SendTrainerList");
 
     Creature* unit = GetPlayer()->GetNPCIfCanInteractWith(guid, UNIT_NPC_FLAG_TRAINER);
     if (!unit)
     {
         TC_LOG_DEBUG("network", "WORLD: SendTrainerList - %s not found or you can not interact with him.", guid.ToString().c_str());
         return;
     }
 
     // remove fake death
     if (GetPlayer()->HasUnitState(UNIT_STATE_DIED))
         GetPlayer()->RemoveAurasByType(SPELL_AURA_FEIGN_DEATH);
 
     TrainerSpellData const* trainer_spells = unit->GetTrainerSpells();
     if (!trainer_spells)
     {
         TC_LOG_DEBUG("network", "WORLD: SendTrainerList - Training spells not found for %s", guid.ToString().c_str());
         return;
     }
 
     WorldPackets::NPC::TrainerList packet;
     packet.TrainerGUID = guid;
     packet.TrainerType = trainer_spells->trainerType;
     packet.Greeting = strTitle;
 
     // reputation discount
     float fDiscountMod = _player->GetReputationPriceDiscount(unit);
 
     packet.Spells.reserve(trainer_spells->spellList.size());
     for (TrainerSpellMap::const_iterator itr = trainer_spells->spellList.begin(); itr != trainer_spells->spellList.end(); ++itr)
     {
         TrainerSpell const* tSpell = &itr->second;
 
         bool valid = true;
         for (uint8 i = 0; i < MAX_TRAINERSPELL_ABILITY_REQS; ++i)
         {
             if (!tSpell->ReqAbility[i])
                 continue;
             if (!_player->IsSpellFitByClassAndRace(tSpell->ReqAbility[i]))
             {
                 valid = false;
                 break;
             }
         }
 
         if (!valid)
             continue;
 
         TrainerSpellState state = _player->GetTrainerSpellState(tSpell);
 
         WorldPackets::NPC::TrainerListSpell spell;
         spell.SpellID = tSpell->SpellID;
         spell.MoneyCost = floor(tSpell->MoneyCost * fDiscountMod);
         spell.ReqSkillLine = tSpell->ReqSkillLine;
         spell.ReqSkillRank = tSpell->ReqSkillRank;
         spell.ReqLevel = tSpell->ReqLevel;
         spell.Usable = (state == TRAINER_SPELL_GREEN_DISABLED ? TRAINER_SPELL_GREEN : state);
 
         uint8 maxReq = 0;
         for (uint8 i = 0; i < MAX_TRAINERSPELL_ABILITY_REQS; ++i)
         {
             if (!tSpell->ReqAbility[i])
                 continue;
 
             if (uint32 prevSpellId = sSpellMgr->GetPrevSpellInChain(tSpell->ReqAbility[i]))
             {
                 spell.ReqAbility[maxReq] = prevSpellId;
                 ++maxReq;
             }
 
             if (maxReq == 2)
                 break;
 
             SpellsRequiringSpellMapBounds spellsRequired = sSpellMgr->GetSpellsRequiredForSpellBounds(tSpell->ReqAbility[i]);
             for (SpellsRequiringSpellMap::const_iterator itr2 = spellsRequired.first; itr2 != spellsRequired.second && maxReq < MAX_TRAINERSPELL_ABILITY_REQS; ++itr2)
             {
                 spell.ReqAbility[maxReq] = itr2->second;
                 ++maxReq;
             }
 
             if (maxReq == 2)
                 break;
         }
 
         packet.Spells.push_back(spell);
     }
 
     SendPacket(packet.Write());
 }

Here is the call graph for this function:

void WorldSession::SendTutorialsData ( )

 {
     WorldPackets::Misc::TutorialFlags packet;
     memcpy(packet.TutorialData, _tutorials, sizeof(_tutorials));
     SendPacket(packet.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     WorldPackets::Character::UndeleteCharacterResponse response;
     response.UndeleteInfo = undeleteInfo;
     response.Result = result;
 
     SendPacket(response.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::SendUndeleteCooldownStatusResponse	(	uint32	currentCooldown,
		uint32	maxCooldown
	)

 {
     WorldPackets::Character::UndeleteCooldownStatusResponse response;
     response.OnCooldown = (currentCooldown > 0);
     response.MaxCooldown = maxCooldown;
     response.CurrentCooldown = currentCooldown;
 
     SendPacket(response.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::SendUpdateTrade ( bool trader_data = true )

 {
     TradeData* view_trade = trader_data ? _player->GetTradeData()->GetTraderData() : _player->GetTradeData();
 
     WorldPackets::Trade::TradeUpdated tradeUpdated;
     tradeUpdated.WhichPlayer = trader_data;
     tradeUpdated.ClientStateIndex = view_trade->GetClientStateIndex();
     tradeUpdated.CurrentStateIndex = view_trade->GetServerStateIndex();
     tradeUpdated.Gold = view_trade->GetMoney();
     tradeUpdated.ProposedEnchantment = view_trade->GetSpell();
 
     for (uint8 i = 0; i < TRADE_SLOT_COUNT; ++i)
     {
         if (Item* item = view_trade->GetItem(TradeSlots(i)))
         {
             WorldPackets::Trade::TradeUpdated::TradeItem tradeItem;
             tradeItem.Slot = i;
             tradeItem.EntryID = item->GetEntry();
             tradeItem.StackCount = item->GetCount();
             tradeItem.GiftCreator = item->GetGuidValue(ITEM_FIELD_GIFTCREATOR);
             if (!item->HasFlag(ITEM_FIELD_FLAGS, ITEM_FIELD_FLAG_WRAPPED))
             {
                 tradeItem.Unwrapped = boost::in_place();
 
                 tradeItem.Unwrapped->Item.Initialize(item);
                 tradeItem.Unwrapped->EnchantID = item->GetEnchantmentId(PERM_ENCHANTMENT_SLOT);
                 tradeItem.Unwrapped->OnUseEnchantmentID = item->GetEnchantmentId(USE_ENCHANTMENT_SLOT);
                 tradeItem.Unwrapped->Creator = item->GetGuidValue(ITEM_FIELD_CREATOR);
                 tradeItem.Unwrapped->Charges = item->GetSpellCharges();
                 tradeItem.Unwrapped->Lock = item->GetTemplate()->GetLockID() && !item->HasFlag(ITEM_FIELD_FLAGS, ITEM_FIELD_FLAG_UNLOCKED);
                 tradeItem.Unwrapped->MaxDurability = item->GetUInt32Value(ITEM_FIELD_MAXDURABILITY);
                 tradeItem.Unwrapped->Durability = item->GetUInt32Value(ITEM_FIELD_DURABILITY);
 
                 for (uint32 s = SOCK_ENCHANTMENT_SLOT; s < MAX_GEM_SOCKETS; ++s)
                     tradeItem.Unwrapped->SocketEnchant[s] = item->GetEnchantmentId(EnchantmentSlot(s + SOCK_ENCHANTMENT_SLOT));
             }
 
             tradeUpdated.Items.push_back(tradeItem);
         }
     }
 
     SendPacket(tradeUpdated.Write());
 }

Here is the call graph for this function:

void WorldSession::SendVoidStorageTransferResult ( VoidTransferError result )

 {
     SendPacket(WorldPackets::VoidStorage::VoidTransferResult(result).Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

 {
     if ((1 << type) & GLOBAL_CACHE_MASK)
     {
         PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_REP_ACCOUNT_DATA);
         stmt->setUInt32(0, GetAccountId());
         stmt->setUInt8(1, type);
         stmt->setUInt32(2, time);
         stmt->setString(3, data);
         CharacterDatabase.Execute(stmt);
     }
     else
     {
         // _player can be NULL and packet received after logout but m_GUID still store correct guid
         if (!m_GUIDLow)
             return;
 
         PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_REP_PLAYER_ACCOUNT_DATA);
         stmt->setUInt64(0, m_GUIDLow);
         stmt->setUInt8(1, type);
         stmt->setUInt32(2, time);
         stmt->setString(3, data);
         CharacterDatabase.Execute(stmt);
     }
 
     _accountData[type].Time = time_t(time);
     _accountData[type].Data = data;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::SetInQueue ( bool state )

inline

Session in auth.queue currently.

940 { m_inQueue = state; }

WorldSession::m_inQueue

bool m_inQueue

Definition: WorldSession.h:1820

Here is the caller graph for this function:

void WorldSession::SetLatency ( uint32 latency )

inline

1064 { m_latency = latency; }

WorldSession::m_latency

std::atomic< uint32 > m_latency

Definition: WorldSession.h:1827

Here is the caller graph for this function:

void WorldSession::SetLogoutStartTime ( time_t requestTime )

inline

Engage the logout process for the user.

         {
             _logoutTime = requestTime;
         }

Here is the caller graph for this function:

void WorldSession::SetPlayer ( Player * player )

 {
     _player = player;
 
     // set m_GUID that can be used while player loggined and later until m_playerRecentlyLogout not reset
     if (_player)
         m_GUIDLow = _player->GetGUID().GetCounter();
 }

Here is the caller graph for this function:

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

inline

1708 { memcpy(_realmListSecret.data(), secret.data(), secret.size()); }

WorldSession::_realmListSecret

std::array< uint8, 32 > _realmListSecret

Definition: WorldSession.h:1809

Here is the caller graph for this function:

void WorldSession::SetSecurity ( AccountTypes security )

inline

931 { _security = security; }

WorldSession::_security

AccountTypes _security

Definition: WorldSession.h:1802

void WorldSession::SetTutorialInt	(	uint8	index,
		uint32	value
	)

inline

         {
             if (_tutorials[index] != value)
             {
                 _tutorials[index] = value;
                 _tutorialsChanged = true;
             }
         }

Here is the caller graph for this function:

bool WorldSession::ShouldLogOut ( time_t currTime ) const

inline

Is logout cooldown expired?

         {
             return (_logoutTime > 0 && currTime >= _logoutTime + 20);
         }

Here is the caller graph for this function:

bool WorldSession::Update	(	uint32	diff,
		PacketFilter &	updater
	)

Update the WorldSession (triggered by World update)

Update Timeout timer.

Before we process anything: If necessary, kick the player from the character select screen
Retrieve packets from the receive queue and call the appropriate handlers not process packets if socket already closed

Delete packet after processing by default

If player didn't log out a while ago, it means packets are being sent while the server does not recognize the client to be in world yet. We will re-add the packets to the bottom of the queue and process them later.

If necessary, log the player out
Cleanup socket pointer if need

 {
     UpdateTimeOutTime(diff);
 
     if (IsConnectionIdle())
         m_Socket[CONNECTION_TYPE_REALM]->CloseSocket();
 
     if (updater.ProcessUnsafe())
         while (_player && _player->IsBeingTeleportedSeamlessly())
             HandleMoveWorldportAckOpcode();
 
     WorldPacket* packet = NULL;
     bool deletePacket = true;
     std::vector<WorldPacket*> requeuePackets;
     uint32 processedPackets = 0;
     time_t currentTime = time(NULL);
 
     while (m_Socket[CONNECTION_TYPE_REALM] && _recvQueue.next(packet, updater))
     {
         ClientOpcodeHandler const* opHandle = opcodeTable[static_cast<OpcodeClient>(packet->GetOpcode())];
         try
         {
             switch (opHandle->Status)
             {
                 case STATUS_LOGGEDIN:
                     if (!_player)
                     {
                         // skip STATUS_LOGGEDIN opcode unexpected errors if player logout sometime ago - this can be network lag delayed packets
                         if (!m_playerRecentlyLogout)
                         {
                             requeuePackets.push_back(packet);
                             deletePacket = false;
                             TC_LOG_DEBUG("network", "Re-enqueueing packet with opcode %s with with status STATUS_LOGGEDIN. "
                                 "Player is currently not in world yet.", GetOpcodeNameForLogging(static_cast<OpcodeClient>(packet->GetOpcode())).c_str());
                         }
                     }
                     else if (_player->IsInWorld() && AntiDOS.EvaluateOpcode(*packet, currentTime))
                     {
                         sScriptMgr->OnPacketReceive(this, *packet);
                         opHandle->Call(this, *packet);
                         LogUnprocessedTail(packet);
                     }
                     // lag can cause STATUS_LOGGEDIN opcodes to arrive after the player started a transfer
                     break;
                 case STATUS_LOGGEDIN_OR_RECENTLY_LOGGOUT:
                     if (!_player && !m_playerRecentlyLogout && !m_playerLogout) // There's a short delay between _player = null and m_playerRecentlyLogout = true during logout
                         LogUnexpectedOpcode(packet, "STATUS_LOGGEDIN_OR_RECENTLY_LOGGOUT",
                             "the player has not logged in yet and not recently logout");
                     else if (AntiDOS.EvaluateOpcode(*packet, currentTime))
                     {
                         // not expected _player or must checked in packet hanlder
                         sScriptMgr->OnPacketReceive(this, *packet);
                         opHandle->Call(this, *packet);
                         LogUnprocessedTail(packet);
                     }
                     break;
                 case STATUS_TRANSFER:
                     if (!_player)
                         LogUnexpectedOpcode(packet, "STATUS_TRANSFER", "the player has not logged in yet");
                     else if (_player->IsInWorld())
                         LogUnexpectedOpcode(packet, "STATUS_TRANSFER", "the player is still in world");
                     else if(AntiDOS.EvaluateOpcode(*packet, currentTime))
                     {
                         sScriptMgr->OnPacketReceive(this, *packet);
                         opHandle->Call(this, *packet);
                         LogUnprocessedTail(packet);
                     }
                     break;
                 case STATUS_AUTHED:
                     // prevent cheating with skip queue wait
                     if (m_inQueue)
                     {
                         LogUnexpectedOpcode(packet, "STATUS_AUTHED", "the player not pass queue yet");
                         break;
                     }
 
                     // some auth opcodes can be recieved before STATUS_LOGGEDIN_OR_RECENTLY_LOGGOUT opcodes
                     // however when we recieve CMSG_CHAR_ENUM we are surely no longer during the logout process.
                     if (packet->GetOpcode() == CMSG_ENUM_CHARACTERS)
                         m_playerRecentlyLogout = false;
 
                     if (AntiDOS.EvaluateOpcode(*packet, currentTime))
                     {
                         sScriptMgr->OnPacketReceive(this, *packet);
                         opHandle->Call(this, *packet);
                         LogUnprocessedTail(packet);
                     }
                     break;
                 case STATUS_NEVER:
                     TC_LOG_ERROR("network.opcode", "Received not allowed opcode %s from %s", GetOpcodeNameForLogging(static_cast<OpcodeClient>(packet->GetOpcode())).c_str()
                         , GetPlayerInfo().c_str());
                     break;
                 case STATUS_UNHANDLED:
                     TC_LOG_ERROR("network.opcode", "Received not handled opcode %s from %s", GetOpcodeNameForLogging(static_cast<OpcodeClient>(packet->GetOpcode())).c_str()
                         , GetPlayerInfo().c_str());
                     break;
             }
         }
         catch (WorldPackets::PacketArrayMaxCapacityException const& pamce)
         {
             TC_LOG_ERROR("network", "PacketArrayMaxCapacityException: %s while parsing %s from %s.",
                 pamce.what(), GetOpcodeNameForLogging(static_cast<OpcodeClient>(packet->GetOpcode())).c_str(), GetPlayerInfo().c_str());
         }
         catch (ByteBufferException const&)
         {
             TC_LOG_ERROR("network", "WorldSession::Update ByteBufferException occured while parsing a packet (opcode: %u) from client %s, accountid=%i. Skipped packet.",
                     packet->GetOpcode(), GetRemoteAddress().c_str(), GetAccountId());
             packet->hexlike();
         }
 
         if (deletePacket)
             delete packet;
 
         deletePacket = true;
 
 #define MAX_PROCESSED_PACKETS_IN_SAME_WORLDSESSION_UPDATE 100
         processedPackets++;
 
         //process only a max amout of packets in 1 Update() call.
         //Any leftover will be processed in next update
         if (processedPackets > MAX_PROCESSED_PACKETS_IN_SAME_WORLDSESSION_UPDATE)
             break;
     }
 
     _recvQueue.readd(requeuePackets.begin(), requeuePackets.end());
 
     if (m_Socket[CONNECTION_TYPE_REALM] && m_Socket[CONNECTION_TYPE_REALM]->IsOpen() && _warden)
         _warden->Update();
 
     ProcessQueryCallbacks();
 
     //check if we are safe to proceed with logout
     //logout procedure should happen only in World::UpdateSessions() method!!!
     if (updater.ProcessUnsafe())
     {
         time_t currTime = time(NULL);
         if (ShouldLogOut(currTime) && m_playerLoading.IsEmpty())
             LogoutPlayer(true);
 
         if (m_Socket[CONNECTION_TYPE_REALM] && GetPlayer() && _warden)
             _warden->Update();
 
         if ((m_Socket[CONNECTION_TYPE_REALM] && !m_Socket[CONNECTION_TYPE_REALM]->IsOpen()) ||
             (m_Socket[CONNECTION_TYPE_INSTANCE] && !m_Socket[CONNECTION_TYPE_INSTANCE]->IsOpen()))
         {
             expireTime -= expireTime > diff ? diff : expireTime;
             if (expireTime < diff || forceExit || !GetPlayer())
             {
                 m_Socket[CONNECTION_TYPE_REALM].reset();
                 m_Socket[CONNECTION_TYPE_INSTANCE].reset();
             }
         }
 
         if (!m_Socket[CONNECTION_TYPE_REALM])
             return false;                                       //Will remove this session from the world session map
     }
 
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSession::UpdateTimeOutTime ( uint32 diff )

inline

         {
             m_timeOutTime -= int32(diff);
         }

Here is the caller graph for this function:

Friends And Related Function Documentation

friend class World

friend

Member Data Documentation

AccountData WorldSession::_accountData[NUM_ACCOUNT_DATA_TYPES]

private

uint32 WorldSession::_accountId

private

QueryResultHolderFuture WorldSession::_accountLoginCallback

private

std::string WorldSession::_accountName

private

QueryCallback<PreparedQueryResult, std::string> WorldSession::_addFriendCallback

private

PreparedQueryResultFuture WorldSession::_addIgnoreCallback

private

uint32 WorldSession::_battlenetAccountId

private

uint32 WorldSession::_battlenetRequestToken

private

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

private

std::unique_ptr<BattlePetMgr> WorldSession::_battlePetMgr

private

QueryCallback<PreparedQueryResult, std::shared_ptr<WorldPackets::Character::CharacterCreateInfo>, true> WorldSession::_charCreateCallback

private

QueryCallback<PreparedQueryResult, std::shared_ptr<WorldPackets::Character::CharCustomizeInfo> > WorldSession::_charCustomizeCallback

private

QueryCallback<PreparedQueryResult, bool> WorldSession::_charEnumCallback

private

QueryCallback<PreparedQueryResult, std::shared_ptr<WorldPackets::Character::CharRaceOrFactionChangeInfo> > WorldSession::_charFactionChangeCallback

private

QueryResultHolderFuture WorldSession::_charLoginCallback

private

QueryCallback<PreparedQueryResult, std::shared_ptr<WorldPackets::Character::CharacterRenameInfo> > WorldSession::_charRenameCallback

private

QueryCallback<PreparedQueryResult, std::shared_ptr<WorldPackets::Character::CharacterUndeleteInfo>, true> WorldSession::_charUndeleteCallback

private

std::unique_ptr<CollectionMgr> WorldSession::_collectionMgr

private

bool WorldSession::_filterAddonMessages

private

ConnectToKey WorldSession::_instanceConnectKey

private

GuidSet WorldSession::_legitCharacters

private

time_t WorldSession::_logoutTime

private

std::string WorldSession::_os

private

Player* WorldSession::_player

private

rbac::RBACData* WorldSession::_RBACData

private

QueryResultHolderFuture WorldSession::_realmAccountLoginCallback

private

std::unordered_map<uint32 , uint8> WorldSession::_realmCharacterCounts

private

std::array<uint8, 32> WorldSession::_realmListSecret

private

LockedQueue<WorldPacket*> WorldSession::_recvQueue

private

std::vector<std::string> WorldSession::_registeredAddonPrefixes

private

AccountTypes WorldSession::_security

private

QueryCallback<PreparedQueryResult, ObjectGuid> WorldSession::_sendStabledPetCallback

private

PreparedQueryResultFuture WorldSession::_stablePetCallback

private

QueryCallback<PreparedQueryResult, uint32> WorldSession::_stableSwapCallback

private

uint32 WorldSession::_tutorials[MAX_ACCOUNT_TUTORIAL_VALUES]

private

bool WorldSession::_tutorialsChanged

private

QueryCallback<PreparedQueryResult, bool, true> WorldSession::_undeleteCooldownStatusCallback

private

QueryCallback<PreparedQueryResult, uint32> WorldSession::_unstablePetCallback

private

Warden* WorldSession::_warden

private

class WorldSession::DosProtection WorldSession::AntiDOS

protected

uint32 WorldSession::expireTime

private

bool WorldSession::forceExit

private

bool WorldSession::isRecruiter

private

AddonsList WorldSession::m_addonsList

private

std::string WorldSession::m_Address

private

std::atomic<uint32> WorldSession::m_clientTimeDelay

private

ObjectGuid WorldSession::m_currentBankerGUID

private

uint8 WorldSession::m_expansion

private

ObjectGuid::LowType WorldSession::m_GUIDLow

private

bool WorldSession::m_inQueue

private

std::atomic<uint32> WorldSession::m_latency

private

time_t WorldSession::m_muteTime

ObjectGuid WorldSession::m_playerLoading

private

bool WorldSession::m_playerLogout

private

bool WorldSession::m_playerRecentlyLogout

private

bool WorldSession::m_playerSave

private

LocaleConstant WorldSession::m_sessionDbcLocale

private

LocaleConstant WorldSession::m_sessionDbLocaleIndex

private

std::shared_ptr<WorldSocket> WorldSession::m_Socket[MAX_CONNECTION_TYPES]

private

std::atomic<int32> WorldSession::m_timeOutTime

uint32 WorldSession::recruiterId

private

The documentation for this class was generated from the following files:

src/server/game/Server/WorldSession.h
src/server/game/Handlers/ArenaTeamHandler.cpp
src/server/game/Handlers/AuctionHouseHandler.cpp
src/server/game/Handlers/AuthHandler.cpp
src/server/game/Handlers/BankHandler.cpp
src/server/game/Handlers/BattlefieldHandler.cpp
src/server/game/Handlers/BattleGroundHandler.cpp
src/server/game/Handlers/BattlenetHandler.cpp
src/server/game/Handlers/BattlePetHandler.cpp
src/server/game/Handlers/BlackMarketHandler.cpp
src/server/game/Handlers/CalendarHandler.cpp
src/server/game/Handlers/ChannelHandler.cpp
src/server/game/Handlers/CharacterHandler.cpp
src/server/game/Handlers/ChatHandler.cpp
src/server/game/Handlers/CombatHandler.cpp
src/server/game/Handlers/DuelHandler.cpp
src/server/game/Handlers/GarrisonHandler.cpp
src/server/game/Handlers/GroupHandler.cpp
src/server/game/Handlers/GuildFinderHandler.cpp
src/server/game/Handlers/GuildHandler.cpp
src/server/game/Handlers/InspectHandler.cpp
src/server/game/Handlers/ItemHandler.cpp
src/server/game/Handlers/LFGHandler.cpp
src/server/game/Handlers/LootHandler.cpp
src/server/game/Handlers/MailHandler.cpp
src/server/game/Handlers/MiscHandler.cpp
src/server/game/Handlers/MovementHandler.cpp
src/server/game/Handlers/NPCHandler.cpp
src/server/game/Handlers/PetHandler.cpp
src/server/game/Handlers/PetitionsHandler.cpp
src/server/game/Handlers/QueryHandler.cpp
src/server/game/Handlers/QuestHandler.cpp
src/server/game/Handlers/ReferAFriendHandler.cpp
src/server/game/Handlers/SceneHandler.cpp
src/server/game/Handlers/SkillHandler.cpp
src/server/game/Handlers/SocialHandler.cpp
src/server/game/Handlers/SpellHandler.cpp
src/server/game/Handlers/TaxiHandler.cpp
src/server/game/Handlers/TicketHandler.cpp
src/server/game/Handlers/TokenHandler.cpp
src/server/game/Handlers/ToyHandler.cpp
src/server/game/Handlers/TradeHandler.cpp
src/server/game/Handlers/VehicleHandler.cpp
src/server/game/Handlers/VoiceChatHandler.cpp
src/server/game/Handlers/VoidStorageHandler.cpp
src/server/game/Server/WorldSession.cpp
src/server/game/Warden/Warden.cpp

Classes

Public Member Functions

Public Attributes

Protected Attributes

Private Types

Private Member Functions

Private Attributes

Friends

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation