Player session in the World. More...

#include "WorldSession.h"

Classes
class	DosProtection

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

	~WorldSession ()
	WorldSession destructor.

bool	PlayerLoading () const

bool	PlayerLogout () const

bool	PlayerRecentlyLoggedOut () const

bool	PlayerLogoutWithSave () const

void	ReadAddonsInfo (ByteBuffer &data)

void	SendAddonsInfo ()

void	ReadMovementInfo (WorldPacket &data, MovementInfo *mi)

void	WriteMovementInfo (WorldPacket data, MovementInfo mi)

void	SendPacket (WorldPacket const *packet)
	Send a packet to the client.

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

void void	SendNotification (uint32 string_id,...)

void	SendPetNameInvalid (uint32 error, std::string const &name, DeclinedName *declinedName)

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

void	SendAreaTriggerMessage (const char *Text,...) ATTR_PRINTF(2

void void	SendSetPhaseShift (uint32 phaseShift)

void	SendQueryTimeResponse ()

void	SendAuthResponse (uint8 code, bool shortForm, uint32 queuePos=0)

void	SendClientCacheVersion (uint32 version)

AccountTypes	GetSecurity () const

bool	CanSkipQueue () const

uint32	GetAccountId () const

Player *	GetPlayer () const

std::string const &	GetPlayerName () const

std::string	GetPlayerInfo () const

uint32	GetCurrentVendor () const

void	SetCurrentVendor (uint32 vendorEntry)

ObjectGuid::LowType	GetGuidLow () const
	Get player guid if available. Use for logging purposes only.

void	SetSecurity (AccountTypes security)

std::string const &	GetRemoteAddress ()

void	SetPlayer (Player *player)

uint8	Expansion () const

void	SetTotalTime (uint32 TotalTime)

uint32	GetTotalTime () const

void	InitWarden (SessionKey const &, std::string const &os)

Warden *	GetWarden ()

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

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

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

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

void	LogoutPlayer (bool save)
	Log the player out

void	KickPlayer (bool setKicked=true)

void	KickPlayer (std::string const &reason, bool setKicked=true)
	Kick a player out of the World.

bool	ValidateHyperlinksAndMaybeKick (std::string_view str)

bool	DisallowHyperlinksAndMaybeKick (std::string_view str)

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

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

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

void	SendNameQueryOpcode (ObjectGuid guid)

void	SendTrainerList (ObjectGuid guid)

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

void	SendListInventory (ObjectGuid guid, uint32 vendorEntry=0)

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	SendBattleGroundList (ObjectGuid guid, BattlegroundTypeId bgTypeId=BATTLEGROUND_RB)

void	SendTradeStatus (TradeStatus status)

void	SendUpdateTrade (bool trader_data=true)

void	SendCancelTrade ()

void	SendPetitionQueryOpcode (ObjectGuid petitionguid)

void	HandleClientCastFlags (WorldPacket &recvPacket, uint8 castFlags, SpellCastTargets &targets)

void	SendPetNameQuery (ObjectGuid guid, uint32 petnumber)

void	SendStablePet (ObjectGuid guid)

void	SendStablePetCallback (ObjectGuid guid, PreparedQueryResult result)

void	SendStableResult (uint8 guid)

bool	CheckStableMaster (ObjectGuid guid)

AccountData *	GetAccountData (AccountDataType type)

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

void	SendAccountDataTimes (uint32 mask)

void	LoadAccountData (PreparedQueryResult result, uint32 mask)

void	LoadTutorialsData (PreparedQueryResult result)

void	SendTutorialsData ()

void	SaveTutorialsData (CharacterDatabaseTransaction trans)

uint32	GetTutorialInt (uint8 index) const

void	SetTutorialInt (uint8 index, uint32 value)

void	SendAuctionHello (ObjectGuid guid, Creature *unit)

void	SendAuctionCommandResult (uint32 auctionId, uint32 Action, uint32 ErrorCode, uint32 bidError=0)

void	SendAuctionBidderNotification (uint32 location, uint32 auctionId, ObjectGuid bidder, uint32 bidSum, uint32 diff, uint32 item_template)

void	SendAuctionOwnerNotification (AuctionEntry *auction)

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	SendArenaTeamCommandResult (uint32 team_action, std::string const &team, std::string const &player, uint32 error_id=0)

void	SendNotInArenaTeamPacket (uint8 type)

void	SendPetitionShowList (ObjectGuid guid)

void	BuildPartyMemberStatsChangedPacket (Player player, WorldPacket data)

void	DoLootRelease (ObjectGuid lguid)

LocaleConstant	GetSessionDbcLocale () const

LocaleConstant	GetSessionDbLocaleIndex () const

char const *	GetAcoreString (uint32 entry) const

uint32	GetLatency () const

void	SetLatency (uint32 latency)

void	UpdateTimeOutTime (uint32 diff)

void	ResetTimeOutTime (bool onlyActive)

bool	IsConnectionIdle () const

uint32	GetRecruiterId () const

bool	IsARecruiter () const

time_t	GetCalendarEventCreationCooldown () const

void	SetCalendarEventCreationCooldown (time_t cooldown)

void	ResetTimeSync ()

void	SendTimeSync ()

void	Handle_NULL (WorldPacket &null)

void	Handle_EarlyProccess (WorldPacket &recvPacket)

void	Handle_ServerSide (WorldPacket &recvPacket)

void	Handle_Deprecated (WorldPacket &recvPacket)

void	HandleCharEnumOpcode (WorldPacket &recvPacket)

void	HandleCharDeleteOpcode (WorldPacket &recvPacket)

void	HandleCharCreateOpcode (WorldPacket &recvPacket)

void	HandlePlayerLoginOpcode (WorldPacket &recvPacket)

void	HandleCharEnum (PreparedQueryResult result)

void	HandlePlayerLoginFromDB (LoginQueryHolder const &holder)

void	HandlePlayerLoginToCharInWorld (Player *pCurrChar)

void	HandlePlayerLoginToCharOutOfWorld (Player *pCurrChar)

void	HandleCharFactionOrRaceChange (WorldPacket &recvData)

void	HandleCharFactionOrRaceChangeCallback (std::shared_ptr< CharacterFactionChangeInfo > factionChangeInfo, PreparedQueryResult result)

void	SendCharCreate (ResponseCodes result)

void	SendCharDelete (ResponseCodes result)

void	SendCharRename (ResponseCodes result, CharacterRenameInfo const *renameInfo)

void	SendCharCustomize (ResponseCodes result, CharacterCustomizeInfo const *customizeInfo)

void	SendCharFactionChange (ResponseCodes result, CharacterFactionChangeInfo const *factionChangeInfo)

void	SendSetPlayerDeclinedNamesResult (DeclinedNameResult result, ObjectGuid guid)

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

void	HandleMoveUnRootAck (WorldPacket &recvPacket)

void	HandleMoveRootAck (WorldPacket &recvPacket)

void	HandleInspectOpcode (WorldPacket &recvPacket)

void	HandleInspectHonorStatsOpcode (WorldPacket &recvPacket)

void	HandleMoveWaterWalkAck (WorldPacket &recvPacket)

void	HandleFeatherFallAck (WorldPacket &recvData)

void	HandleMoveHoverAck (WorldPacket &recvData)

void	HandleMountSpecialAnimOpcode (WorldPacket &recvdata)

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

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

void	HandleRepairItemOpcode (WorldPacket &recvPacket)

void	HandleMoveKnockBackAck (WorldPacket &recvPacket)

void	HandleMoveTeleportAck (WorldPacket &recvPacket)

void	HandleForceSpeedChangeAck (WorldPacket &recvData)

void	HandleRepopRequestOpcode (WorldPacket &recvPacket)

void	HandleAutostoreLootItemOpcode (WorldPacket &recvPacket)

void	HandleLootMoneyOpcode (WorldPacket &recvPacket)

void	HandleLootOpcode (WorldPacket &recvPacket)

void	HandleLootReleaseOpcode (WorldPacket &recvPacket)

void	HandleLootMasterGiveOpcode (WorldPacket &recvPacket)

void	HandleWhoOpcode (WorldPacket &recvPacket)

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

void	HandlePlayerLogoutOpcode (WorldPackets::Character::PlayerLogout &playerLogout)

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

void	HandleGMTicketCreateOpcode (WorldPacket &recvPacket)

void	HandleGMTicketUpdateOpcode (WorldPacket &recvPacket)

void	HandleGMTicketDeleteOpcode (WorldPacket &recvPacket)

void	HandleGMTicketGetTicketOpcode (WorldPacket &recvPacket)

void	HandleGMTicketSystemStatusOpcode (WorldPacket &recvPacket)

void	HandleGMSurveySubmit (WorldPacket &recvPacket)

void	HandleReportLag (WorldPacket &recvPacket)

void	HandleGMResponseResolve (WorldPacket &recvPacket)

void	HandleTogglePvP (WorldPacket &recvPacket)

void	HandleZoneUpdateOpcode (WorldPacket &recvPacket)

void	HandleSetSelectionOpcode (WorldPacket &recvPacket)

void	HandleStandStateChangeOpcode (WorldPacket &recvPacket)

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

void	HandleContactListOpcode (WorldPacket &recvPacket)

void	HandleAddFriendOpcode (WorldPacket &recvPacket)

void	HandleDelFriendOpcode (WorldPacket &recvPacket)

void	HandleAddIgnoreOpcode (WorldPacket &recvPacket)

void	HandleDelIgnoreOpcode (WorldPacket &recvPacket)

void	HandleSetContactNotesOpcode (WorldPacket &recvPacket)

void	HandleBugOpcode (WorldPacket &recvPacket)

void	HandleSetAmmoOpcode (WorldPacket &recvPacket)

void	HandleItemNameQueryOpcode (WorldPacket &recvPacket)

void	HandleAreaTriggerOpcode (WorldPacket &recvPacket)

void	HandleSetFactionAtWar (WorldPacket &recvData)

void	HandleSetFactionCheat (WorldPacket &recvData)

void	HandleSetWatchedFactionOpcode (WorldPacket &recvData)

void	HandleSetFactionInactiveOpcode (WorldPacket &recvData)

void	HandleUpdateAccountData (WorldPacket &recvPacket)

void	HandleRequestAccountData (WorldPacket &recvPacket)

void	HandleSetActionButtonOpcode (WorldPacket &recvPacket)

void	HandleGameObjectUseOpcode (WorldPacket &recPacket)

void	HandleGameobjectReportUse (WorldPacket &recvPacket)

void	HandleNameQueryOpcode (WorldPacket &recvPacket)

void	HandleQueryTimeOpcode (WorldPacket &recvPacket)

void	HandleCreatureQueryOpcode (WorldPacket &recvPacket)
	Only static data is sent in this packet !!!

void	HandleGameObjectQueryOpcode (WorldPacket &recvPacket)
	Only static data is sent in this packet !!!

void	HandleMoveWorldportAckOpcode (WorldPacket &recvPacket)

void	HandleMoveWorldportAck ()

void	HandleMovementOpcodes (WorldPacket &recvPacket)

void	HandleSetActiveMoverOpcode (WorldPacket &recvData)

void	HandleMoveNotActiveMover (WorldPacket &recvData)

void	HandleDismissControlledVehicle (WorldPacket &recvData)

void	HandleRequestVehicleExit (WorldPacket &recvData)

void	HandleChangeSeatsOnControlledVehicle (WorldPacket &recvData)

void	HandleMoveTimeSkippedOpcode (WorldPacket &recvData)

void	HandleRequestRaidInfoOpcode (WorldPacket &recvData)

void	HandleBattlefieldStatusOpcode (WorldPacket &recvData)

void	HandleGroupInviteOpcode (WorldPacket &recvPacket)

void	HandleGroupAcceptOpcode (WorldPacket &recvPacket)

void	HandleGroupDeclineOpcode (WorldPacket &recvPacket)

void	HandleGroupUninviteOpcode (WorldPacket &recvPacket)

void	HandleGroupUninviteGuidOpcode (WorldPacket &recvPacket)

void	HandleGroupSetLeaderOpcode (WorldPacket &recvPacket)

void	HandleGroupDisbandOpcode (WorldPacket &recvPacket)

void	HandleOptOutOfLootOpcode (WorldPacket &recvData)

void	HandleLootMethodOpcode (WorldPacket &recvPacket)

void	HandleLootRoll (WorldPacket &recvData)

void	HandleRequestPartyMemberStatsOpcode (WorldPacket &recvData)

void	HandleGroupSwapSubGroupOpcode (WorldPacket &recvData)

void	HandleRaidTargetUpdateOpcode (WorldPacket &recvData)

void	HandleRaidReadyCheckOpcode (WorldPacket &recvData)

void	HandleRaidReadyCheckFinishedOpcode (WorldPacket &recvData)

void	HandleGroupRaidConvertOpcode (WorldPacket &recvData)

void	HandleGroupChangeSubGroupOpcode (WorldPacket &recvData)

void	HandleGroupAssistantLeaderOpcode (WorldPacket &recvData)

void	HandlePartyAssignmentOpcode (WorldPacket &recvData)

void	HandlePetitionBuyOpcode (WorldPacket &recvData)

void	HandlePetitionShowSignOpcode (WorldPacket &recvData)

void	HandlePetitionQueryOpcode (WorldPacket &recvData)

void	HandlePetitionRenameOpcode (WorldPacket &recvData)

void	HandlePetitionSignOpcode (WorldPacket &recvData)

void	HandlePetitionDeclineOpcode (WorldPacket &recvData)

void	HandleOfferPetitionOpcode (WorldPacket &recvData)

void	HandleTurnInPetitionOpcode (WorldPacket &recvData)

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

void	HandleGuildCreateOpcode (WorldPackets::Guild::GuildCreate &packet)

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

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

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

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

void	HandleGuildInfoOpcode (WorldPackets::Guild::GuildGetInfo &packet)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void	HandleTaxiNodeStatusQueryOpcode (WorldPacket &recvPacket)

void	HandleTaxiQueryAvailableNodes (WorldPacket &recvPacket)

void	HandleActivateTaxiOpcode (WorldPacket &recvPacket)

void	HandleActivateTaxiExpressOpcode (WorldPacket &recvPacket)

void	HandleMoveSplineDoneOpcode (WorldPacket &recvPacket)

void	SendActivateTaxiReply (ActivateTaxiReply reply)

void	HandleTabardVendorActivateOpcode (WorldPacket &recvPacket)

void	HandleTrainerListOpcode (WorldPacket &recvPacket)

void	HandleTrainerBuySpellOpcode (WorldPacket &recvPacket)

void	HandlePetitionShowListOpcode (WorldPacket &recvPacket)

void	HandleGossipHelloOpcode (WorldPacket &recvPacket)

void	HandleGossipSelectOptionOpcode (WorldPacket &recvPacket)

void	HandleSpiritHealerActivateOpcode (WorldPacket &recvPacket)

void	HandleNpcTextQueryOpcode (WorldPacket &recvPacket)

void	HandleBinderActivateOpcode (WorldPacket &recvPacket)

void	HandleListStabledPetsOpcode (WorldPacket &recvPacket)

void	HandleStablePet (WorldPacket &recvPacket)

void	HandleUnstablePet (WorldPacket &recvPacket)

void	HandleBuyStableSlot (WorldPacket &recvPacket)

void	HandleStableRevivePet (WorldPacket &recvPacket)

void	HandleStableSwapPet (WorldPacket &recvPacket)

void	HandleOpenWrappedItemCallback (uint8 bagIndex, uint8 slot, ObjectGuid::LowType itemLowGUID, PreparedQueryResult result)

void	HandleLoadActionsSwitchSpec (PreparedQueryResult result)

void	HandleCharacterAuraFrozen (PreparedQueryResult result)

void	HandleDuelAcceptedOpcode (WorldPacket &recvPacket)

void	HandleDuelCancelledOpcode (WorldPacket &recvPacket)

void	HandleAcceptTradeOpcode (WorldPacket &recvPacket)

void	HandleBeginTradeOpcode (WorldPacket &recvPacket)

void	HandleBusyTradeOpcode (WorldPacket &recvPacket)

void	HandleCancelTradeOpcode (WorldPacket &recvPacket)

void	HandleClearTradeItemOpcode (WorldPacket &recvPacket)

void	HandleIgnoreTradeOpcode (WorldPacket &recvPacket)

void	HandleInitiateTradeOpcode (WorldPacket &recvPacket)

void	HandleSetTradeGoldOpcode (WorldPacket &recvPacket)

void	HandleSetTradeItemOpcode (WorldPacket &recvPacket)

void	HandleUnacceptTradeOpcode (WorldPacket &recvPacket)

void	HandleAuctionHelloOpcode (WorldPacket &recvPacket)

void	HandleAuctionListItems (WorldPacket &recvData)

void	HandleAuctionListBidderItems (WorldPacket &recvData)

void	HandleAuctionSellItem (WorldPacket &recvData)

void	HandleAuctionRemoveItem (WorldPacket &recvData)

void	HandleAuctionListOwnerItems (WorldPacket &recvData)

void	HandleAuctionListOwnerItemsEvent (ObjectGuid creatureGuid)

void	HandleAuctionPlaceBid (WorldPacket &recvData)

void	HandleAuctionListPendingSales (WorldPacket &recvData)

void	HandleBankerActivateOpcode (WorldPacket &recvData)

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

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

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

void	HandleGetMailList (WorldPacket &recvData)

void	HandleSendMail (WorldPacket &recvData)

void	HandleMailTakeMoney (WorldPacket &recvData)

void	HandleMailTakeItem (WorldPacket &recvData)

void	HandleMailMarkAsRead (WorldPacket &recvData)

void	HandleMailReturnToSender (WorldPacket &recvData)

void	HandleMailDelete (WorldPacket &recvData)

void	HandleItemTextQuery (WorldPacket &recvData)

void	HandleMailCreateTextItem (WorldPacket &recvData)

void	HandleQueryNextMailTime (WorldPacket &recvData)

void	HandleCancelChanneling (WorldPacket &recvData)

void	HandleSplitItemOpcode (WorldPacket &recvPacket)

void	HandleSwapInvItemOpcode (WorldPacket &recvPacket)

void	HandleDestroyItemOpcode (WorldPacket &recvPacket)

void	HandleAutoEquipItemOpcode (WorldPacket &recvPacket)

void	HandleItemQuerySingleOpcode (WorldPacket &recvPacket)

void	HandleSellItemOpcode (WorldPacket &recvPacket)

void	HandleBuyItemInSlotOpcode (WorldPacket &recvPacket)

void	HandleBuyItemOpcode (WorldPacket &recvPacket)

void	HandleListInventoryOpcode (WorldPacket &recvPacket)

void	HandleAutoStoreBagItemOpcode (WorldPacket &recvPacket)

void	HandleReadItem (WorldPacket &recvPacket)

void	HandleAutoEquipItemSlotOpcode (WorldPacket &recvPacket)

void	HandleSwapItem (WorldPacket &recvPacket)

void	HandleBuybackItem (WorldPacket &recvPacket)

void	HandleWrapItemOpcode (WorldPacket &recvPacket)

void	HandleAttackSwingOpcode (WorldPacket &recvPacket)

void	HandleAttackStopOpcode (WorldPacket &recvPacket)

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

void	HandleUseItemOpcode (WorldPacket &recvPacket)

void	HandleOpenItemOpcode (WorldPacket &recvPacket)

void	HandleCastSpellOpcode (WorldPacket &recvPacket)

void	HandleCancelCastOpcode (WorldPacket &recvPacket)

void	HandleCancelAuraOpcode (WorldPacket &recvPacket)

void	HandleCancelGrowthAuraOpcode (WorldPacket &recvPacket)

void	HandleCancelAutoRepeatSpellOpcode (WorldPacket &recvPacket)

void	HandleLearnTalentOpcode (WorldPacket &recvPacket)

void	HandleLearnPreviewTalents (WorldPacket &recvPacket)

void	HandleTalentWipeConfirmOpcode (WorldPacket &recvPacket)

void	HandleUnlearnSkillOpcode (WorldPacket &recvPacket)

void	HandleQuestgiverStatusQueryOpcode (WorldPacket &recvPacket)

void	HandleQuestgiverStatusMultipleQuery (WorldPacket &recvPacket)

void	HandleQuestgiverHelloOpcode (WorldPacket &recvPacket)

void	HandleQuestgiverAcceptQuestOpcode (WorldPacket &recvPacket)

void	HandleQuestgiverQueryQuestOpcode (WorldPacket &recvPacket)

void	HandleQuestgiverChooseRewardOpcode (WorldPacket &recvPacket)

void	HandleQuestgiverRequestRewardOpcode (WorldPacket &recvPacket)

void	HandleQuestQueryOpcode (WorldPacket &recvPacket)

void	HandleQuestgiverCancel (WorldPacket &recvData)

void	HandleQuestLogSwapQuest (WorldPacket &recvData)

void	HandleQuestLogRemoveQuest (WorldPacket &recvData)

void	HandleQuestConfirmAccept (WorldPacket &recvData)

void	HandleQuestgiverCompleteQuest (WorldPacket &recvData)

void	HandleQuestgiverQuestAutoLaunch (WorldPacket &recvPacket)

void	HandlePushQuestToParty (WorldPacket &recvPacket)

void	HandleQuestPushResult (WorldPacket &recvPacket)

void	HandleMessagechatOpcode (WorldPacket &recvPacket)

void	SendPlayerNotFoundNotice (std::string const &name)

void	SendPlayerAmbiguousNotice (std::string const &name)

void	SendWrongFactionNotice ()

void	SendChatRestrictedNotice (ChatRestrictionType restriction)

void	HandleTextEmoteOpcode (WorldPacket &recvPacket)

void	HandleChatIgnoredOpcode (WorldPacket &recvPacket)

void	HandleReclaimCorpseOpcode (WorldPacket &recvPacket)

void	HandleCorpseQueryOpcode (WorldPacket &recvPacket)

void	HandleCorpseMapPositionQuery (WorldPacket &recvPacket)

void	HandleResurrectResponseOpcode (WorldPacket &recvPacket)

void	HandleSummonResponseOpcode (WorldPacket &recvData)

void	HandleJoinChannel (WorldPacket &recvPacket)

void	HandleLeaveChannel (WorldPacket &recvPacket)

void	HandleChannelList (WorldPacket &recvPacket)

void	HandleChannelPassword (WorldPacket &recvPacket)

void	HandleChannelSetOwner (WorldPacket &recvPacket)

void	HandleChannelOwner (WorldPacket &recvPacket)

void	HandleChannelModerator (WorldPacket &recvPacket)

void	HandleChannelUnmoderator (WorldPacket &recvPacket)

void	HandleChannelMute (WorldPacket &recvPacket)

void	HandleChannelUnmute (WorldPacket &recvPacket)

void	HandleChannelInvite (WorldPacket &recvPacket)

void	HandleChannelKick (WorldPacket &recvPacket)

void	HandleChannelBan (WorldPacket &recvPacket)

void	HandleChannelUnban (WorldPacket &recvPacket)

void	HandleChannelAnnouncements (WorldPacket &recvPacket)

void	HandleChannelModerateOpcode (WorldPacket &recvPacket)

void	HandleChannelDeclineInvite (WorldPacket &recvPacket)

void	HandleChannelDisplayListQuery (WorldPacket &recvPacket)

void	HandleGetChannelMemberCount (WorldPacket &recvPacket)

void	HandleSetChannelWatch (WorldPacket &recvPacket)

void	HandleClearChannelWatch (WorldPacket &recvPacket)

void	HandleCompleteCinematic (WorldPacket &recvPacket)

void	HandleNextCinematicCamera (WorldPacket &recvPacket)

void	HandlePageTextQueryOpcode (WorldPacket &recvPacket)
	Only static data is sent in this packet !!!

void	HandleTutorialFlag (WorldPacket &recvData)

void	HandleTutorialClear (WorldPacket &recvData)

void	HandleTutorialReset (WorldPacket &recvData)

void	HandlePetAction (WorldPacket &recvData)

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

void	HandlePetActionHelper (Unit *pet, ObjectGuid guid1, uint32 spellid, uint16 flag, ObjectGuid guid2)

void	HandlePetNameQuery (WorldPacket &recvData)

void	HandlePetSetAction (WorldPacket &recvData)

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

void	HandlePetRename (WorldPacket &recvData)

void	HandlePetCancelAuraOpcode (WorldPacket &recvPacket)

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

void	HandlePetCastSpellOpcode (WorldPacket &recvPacket)

void	HandlePetLearnTalent (WorldPacket &recvPacket)

void	HandleLearnPreviewTalentsPet (WorldPacket &recvPacket)

void	HandleSetActionBarToggles (WorldPacket &recvData)

void	HandleCharRenameOpcode (WorldPacket &recvData)

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

void	HandleSetPlayerDeclinedNames (WorldPacket &recvData)

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

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

void	HandleBattlemasterHelloOpcode (WorldPacket &recvData)

void	HandleBattlemasterJoinOpcode (WorldPacket &recvData)

void	HandleBattlegroundPlayerPositionsOpcode (WorldPacket &recvData)

void	HandlePVPLogDataOpcode (WorldPacket &recvData)

void	HandleBattleFieldPortOpcode (WorldPacket &recvData)

void	HandleBattlefieldListOpcode (WorldPacket &recvData)

void	HandleBattlefieldLeaveOpcode (WorldPacket &recvData)

void	HandleBattlemasterJoinArena (WorldPacket &recvData)

void	HandleReportPvPAFK (WorldPacket &recvData)

void	HandleWardenDataOpcode (WorldPacket &recvData)

void	HandleWorldTeleportOpcode (WorldPacket &recvData)

void	HandleMinimapPingOpcode (WorldPacket &recvData)

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

void	HandleFarSightOpcode (WorldPacket &recvData)

void	HandleSetDungeonDifficultyOpcode (WorldPacket &recvData)

void	HandleSetRaidDifficultyOpcode (WorldPacket &recvData)

void	HandleMoveSetCanFlyAckOpcode (WorldPacket &recvData)

void	HandleSetTitleOpcode (WorldPacket &recvData)

void	HandleRealmSplitOpcode (WorldPacket &recvData)

void	HandleTimeSyncResp (WorldPacket &recvData)

void	HandleWhoisOpcode (WorldPacket &recvData)

void	HandleResetInstancesOpcode (WorldPacket &recvData)

void	HandleHearthAndResurrect (WorldPacket &recvData)

void	HandleInstanceLockResponse (WorldPacket &recvPacket)

void	HandleUpdateMissileTrajectory (WorldPacket &recvPacket)

void	SendBfInvitePlayerToWar (uint32 battleId, uint32 zoneId, uint32 time)

void	SendBfInvitePlayerToQueue (uint32 battleId)

void	SendBfQueueInviteResponse (uint32 battleId, uint32 zoneId, bool canQueue=true, bool full=false)

void	SendBfEntered (uint32 battleId)

void	SendBfLeaveMessage (uint32 battleId, BFLeaveReason reason=BF_LEAVE_REASON_EXITED)

void	HandleBfQueueInviteResponse (WorldPacket &recvData)

void	HandleBfEntryInviteResponse (WorldPacket &recvData)

void	HandleBfExitRequest (WorldPacket &recvData)

void	HandleLfgSetCommentOpcode (WorldPacket &recvData)

void	HandleLfgPlayerLockInfoRequestOpcode (WorldPacket &recvData)

void	HandleLfgPartyLockInfoRequestOpcode (WorldPacket &recvData)

void	HandleLfgJoinOpcode (WorldPackets::LFG::LFGJoin &lfgJoin)

void	HandleLfgLeaveOpcode (WorldPackets::LFG::LFGLeave &lfgleave)

void	HandleLfgSetRolesOpcode (WorldPacket &recvData)

void	HandleLfgProposalResultOpcode (WorldPacket &recvData)

void	HandleLfgSetBootVoteOpcode (WorldPacket &recvData)

void	HandleLfgTeleportOpcode (WorldPacket &recvData)

void	HandleLfrSearchJoinOpcode (WorldPacket &recvData)

void	HandleLfrSearchLeaveOpcode (WorldPacket &recvData)

void	HandleLfgGetStatus (WorldPacket &recvData)

void	SendLfgUpdatePlayer (lfg::LfgUpdateData const &updateData)

void	SendLfgUpdateParty (lfg::LfgUpdateData const &updateData)

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

void	HandleArenaTeamQueryOpcode (WorldPacket &recvData)

void	HandleArenaTeamRosterOpcode (WorldPacket &recvData)

void	HandleArenaTeamInviteOpcode (WorldPacket &recvData)

void	HandleArenaTeamAcceptOpcode (WorldPacket &recvData)

void	HandleArenaTeamDeclineOpcode (WorldPacket &recvData)

void	HandleArenaTeamLeaveOpcode (WorldPacket &recvData)

void	HandleArenaTeamRemoveOpcode (WorldPacket &recvData)

void	HandleArenaTeamDisbandOpcode (WorldPacket &recvData)

void	HandleArenaTeamLeaderOpcode (WorldPacket &recvData)

void	HandleAreaSpiritHealerQueryOpcode (WorldPacket &recvData)

void	HandleAreaSpiritHealerQueueOpcode (WorldPacket &recvData)

void	HandleCancelMountAuraOpcode (WorldPacket &recvData)

void	HandleSelfResOpcode (WorldPacket &recvData)

void	HandleComplainOpcode (WorldPacket &recvData)

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

void	HandleSocketOpcode (WorldPacket &recvData)

void	HandleCancelTempEnchantmentOpcode (WorldPacket &recvData)

void	HandleItemRefundInfoRequest (WorldPacket &recvData)

void	HandleItemRefund (WorldPacket &recvData)

void	HandleChannelVoiceOnOpcode (WorldPacket &recvData)

void	HandleVoiceSessionEnableOpcode (WorldPacket &recvData)

void	HandleSetActiveVoiceChannel (WorldPacket &recvData)

void	HandleSetTaxiBenchmarkOpcode (WorldPacket &recvData)

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

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

void	HandleGuildBankerActivate (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	HandleQueryGuildBankTabText (WorldPackets::Guild::GuildBankTextQuery &packet)

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

void	HandleGrantLevel (WorldPacket &recvData)

void	HandleAcceptGrantLevel (WorldPacket &recvData)

void	HandleCalendarGetCalendar (WorldPacket &recvData)

void	HandleCalendarGetEvent (WorldPacket &recvData)

void	HandleCalendarGuildFilter (WorldPacket &recvData)

void	HandleCalendarArenaTeam (WorldPacket &recvData)

void	HandleCalendarAddEvent (WorldPacket &recvData)

void	HandleCalendarUpdateEvent (WorldPacket &recvData)

void	HandleCalendarRemoveEvent (WorldPacket &recvData)

void	HandleCalendarCopyEvent (WorldPacket &recvData)

void	HandleCalendarEventInvite (WorldPacket &recvData)

void	HandleCalendarEventRsvp (WorldPacket &recvData)

void	HandleCalendarEventRemoveInvite (WorldPacket &recvData)

void	HandleCalendarEventStatus (WorldPacket &recvData)

void	HandleCalendarEventModeratorStatus (WorldPacket &recvData)

void	HandleCalendarComplain (WorldPacket &recvData)

void	HandleCalendarGetNumPending (WorldPacket &recvData)

void	HandleCalendarEventSignup (WorldPacket &recvData)

void	SendCalendarRaidLockout (InstanceSave const *save, bool add)

void	SendCalendarRaidLockoutUpdated (InstanceSave const *save, bool isExtended)

void	HandleSetSavedInstanceExtend (WorldPacket &recvData)

void	HandleSpellClick (WorldPacket &recvData)

void	HandleMirrorImageDataRequest (WorldPacket &recvData)

void	HandleAlterAppearance (WorldPacket &recvData)

void	HandleRemoveGlyph (WorldPacket &recvData)

void	HandleCharCustomize (WorldPacket &recvData)

void	HandleCharCustomizeCallback (std::shared_ptr< CharacterCustomizeInfo > customizeInfo, PreparedQueryResult result)

void	HandleQueryInspectAchievements (WorldPacket &recvData)

void	HandleEquipmentSetSave (WorldPacket &recvData)

void	HandleEquipmentSetDelete (WorldPacket &recvData)

void	HandleEquipmentSetUse (WorldPacket &recvData)

void	HandleWorldStateUITimerUpdate (WorldPacket &recvData)

void	HandleReadyForAccountDataTimes (WorldPacket &recvData)

void	HandleQueryQuestsCompleted (WorldPacket &recvData)

void	HandleQuestPOIQuery (WorldPacket &recvData)

void	HandleEjectPassenger (WorldPacket &data)

void	HandleEnterPlayerVehicle (WorldPacket &data)

void	HandleUpdateProjectilePosition (WorldPacket &recvPacket)

void	HandleTeleportTimeout (bool updateInSessions)

bool	HandleSocketClosed ()

void	SetOfflineTime (uint32 time)

uint32	GetOfflineTime () const

bool	IsKicked () const

void	SetKicked (bool val)

bool	IsSocketClosed () const

QueryCallbackProcessor &	GetQueryProcessor ()

TransactionCallback &	AddTransactionCallback (TransactionCallback &&callback)

SQLQueryHolderCallback &	AddQueryHolderCallback (SQLQueryHolderCallback &&callback)

void	InitializeSession ()

void	InitializeSessionCallback (CharacterDatabaseQueryHolder const &realmHolder, uint32 clientCacheVersion)

Public Attributes
time_t	m_muteTime

std::atomic< time_t >	m_timeOutTime

uint32	_lastAuctionListItemsMSTime

uint32	_lastAuctionListOwnerItemsMSTime

Protected Attributes
class WorldSession::DosProtection	AntiDOS

Private Types
typedef std::list< AddonInfo >	AddonsList

Private Member Functions
void	ProcessQueryCallbacks ()

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

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

bool	recoveryItem (Item *pItem)

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

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

bool	IsLegitCharacterForAccount (ObjectGuid guid)

void	ComputeNewClockDelta ()

	WorldSession (WorldSession const &right)=delete

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

Private Attributes
QueryCallbackProcessor	_queryProcessor

AsyncCallbackProcessor< TransactionCallback >	_transactionCallbacks

AsyncCallbackProcessor< SQLQueryHolderCallback >	_queryHolderProcessor

GuidSet	_legitCharacters

ObjectGuid::LowType	m_GUIDLow

Player *	_player

std::shared_ptr< WorldSocket >	m_Socket

std::string	m_Address

AccountTypes	_security

bool	_skipQueue

uint32	_accountId

std::string	_accountName

uint8	m_expansion

uint32	m_total_time

std::unique_ptr< Warden >	_warden

time_t	_logoutTime

bool	m_inQueue

bool	m_playerLoading

bool	m_playerLogout

bool	m_playerRecentlyLogout

bool	m_playerSave

LocaleConstant	m_sessionDbcLocale

LocaleConstant	m_sessionDbLocaleIndex

std::atomic< uint32 >	m_latency

AccountData	m_accountData [NUM_ACCOUNT_DATA_TYPES]

uint32	m_Tutorials [MAX_ACCOUNT_TUTORIAL_VALUES]

bool	m_TutorialsChanged

AddonsList	m_addonsList

uint32	recruiterId

bool	isRecruiter

LockedQueue< WorldPacket * >	_recvQueue

uint32	m_currentVendorEntry

ObjectGuid	m_currentBankerGUID

uint32	_offlineTime

bool	_kicked

time_t	_calendarEventCreationCooldown

std::atomic< uint32 >	_addonMessageReceiveCount

CircularBuffer< std::pair< int64, uint32 > >	_timeSyncClockDeltaQueue

int64	_timeSyncClockDelta

std::map< uint32, uint32 >	_pendingTimeSyncRequests

uint32	_timeSyncNextCounter

uint32	_timeSyncTimer

Friends
class	World

Detailed Description

Player session in the World.

Member Typedef Documentation

◆ AddonsList

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

private

Constructor & Destructor Documentation

◆ WorldSession() [1/2]

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

WorldSession constructor.

                                                                                                                    :
    m_muteTime(mute_time),
    m_timeOutTime(0),
    _lastAuctionListItemsMSTime(0),
    _lastAuctionListOwnerItemsMSTime(0),
    AntiDOS(this),
    m_GUIDLow(0),
    _player(nullptr),
    m_Socket(sock),
    _security(sec),
    _skipQueue(skipQueue),
    _accountId(id),
    _accountName(std::move(name)),
    m_expansion(expansion),
    m_total_time(TotalTime),
    _logoutTime(0),
    m_inQueue(false),
    m_playerLoading(false),
    m_playerLogout(false),
    m_playerRecentlyLogout(false),
    m_playerSave(false),
    m_sessionDbcLocale(sWorld->GetDefaultDbcLocale()),
    m_sessionDbLocaleIndex(locale),
    m_latency(0),
    m_TutorialsChanged(false),
    recruiterId(recruiter),
    isRecruiter(isARecruiter),
    m_currentVendorEntry(0),
    _calendarEventCreationCooldown(0),
    _addonMessageReceiveCount(0),
    _timeSyncClockDeltaQueue(6),
    _timeSyncClockDelta(0),
    _pendingTimeSyncRequests()
{
    memset(m_Tutorials, 0, sizeof(m_Tutorials));
 
    _offlineTime = 0;
    _kicked = false;
 
    _timeSyncNextCounter = 0;
    _timeSyncTimer = 0;
 
    if (sock)
    {
        m_Address = sock->GetRemoteIpAddress().to_string();
        ResetTimeOutTime(false);
        LoginDatabase.Execute("UPDATE account SET online = 1 WHERE id = {};", GetAccountId()); // One-time query
    }
}

References _kicked, _offlineTime, _timeSyncNextCounter, _timeSyncTimer, GetAccountId(), LoginDatabase, m_Address, m_Tutorials, and ResetTimeOutTime().

◆ ~WorldSession()

WorldSession::~WorldSession ( )

WorldSession destructor.

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

{
    LoginDatabase.Execute("UPDATE account SET totaltime = {} WHERE id = {}", GetTotalTime(), GetAccountId());
 
    if (_player)
        LogoutPlayer(true);
 
    if (m_Socket)
    {
        m_Socket->CloseSocket();
        m_Socket = nullptr;
    }
 
    WorldPacket* packet = nullptr;
    while (_recvQueue.next(packet))
        delete packet;
 
    LoginDatabase.Execute("UPDATE account SET online = 0 WHERE id = {};", GetAccountId());     // One-time query
}

References _player, _recvQueue, GetAccountId(), GetTotalTime(), LoginDatabase, LogoutPlayer(), m_Socket, and LockedQueue< T, StorageType >::next().

◆ WorldSession() [2/2]

WorldSession::WorldSession ( WorldSession const & right )

privatedelete

Member Function Documentation

◆ AddQueryHolderCallback()

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

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

References _queryHolderProcessor, and AsyncCallbackProcessor< T >::AddCallback().

Referenced by HandlePlayerLoginOpcode(), InitializeSession(), and Pet::LoadPetFromDB().

◆ AddTransactionCallback()

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

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

References _transactionCallbacks, and AsyncCallbackProcessor< T >::AddCallback().

◆ BuildPartyMemberStatsChangedPacket()

void WorldSession::BuildPartyMemberStatsChangedPacket	(	Player *	player,
		WorldPacket *	data
	)

{
    uint32 mask = player->GetGroupUpdateFlag();
 
    if (mask == GROUP_UPDATE_FLAG_NONE)
        return;
 
    if (mask & GROUP_UPDATE_FLAG_POWER_TYPE)                // if update power type, update current/max power also
        mask |= (GROUP_UPDATE_FLAG_CUR_POWER | GROUP_UPDATE_FLAG_MAX_POWER);
 
    if (mask & GROUP_UPDATE_FLAG_PET_POWER_TYPE)            // same for pets
        mask |= (GROUP_UPDATE_FLAG_PET_CUR_POWER | GROUP_UPDATE_FLAG_PET_MAX_POWER);
 
    uint32 byteCount = 0;
    for (int i = 1; i < GROUP_UPDATE_FLAGS_COUNT; ++i)
        if (mask & (1 << i))
            byteCount += GroupUpdateLength[i];
 
    data->Initialize(SMSG_PARTY_MEMBER_STATS, 8 + 4 + byteCount);
    *data << player->GetPackGUID();
    *data << uint32(mask);
 
    if (mask & GROUP_UPDATE_FLAG_STATUS)
    {
        uint16 playerStatus = MEMBER_STATUS_ONLINE;
        if (player->IsPvP())
            playerStatus |= MEMBER_STATUS_PVP;
 
        if (!player->IsAlive())
        {
            if (player->HasPlayerFlag(PLAYER_FLAGS_GHOST))
                playerStatus |= MEMBER_STATUS_GHOST;
            else
                playerStatus |= MEMBER_STATUS_DEAD;
        }
 
        if (player->IsFFAPvP())
            playerStatus |= MEMBER_STATUS_PVP_FFA;
 
        if (player->isAFK())
            playerStatus |= MEMBER_STATUS_AFK;
 
        if (player->isDND())
            playerStatus |= MEMBER_STATUS_DND;
 
        *data << uint16(playerStatus);
    }
 
    if (mask & GROUP_UPDATE_FLAG_CUR_HP)
        *data << uint32(player->GetHealth());
 
    if (mask & GROUP_UPDATE_FLAG_MAX_HP)
        *data << uint32(player->GetMaxHealth());
 
    Powers powerType = player->getPowerType();
    if (mask & GROUP_UPDATE_FLAG_POWER_TYPE)
        *data << uint8(powerType);
 
    if (mask & GROUP_UPDATE_FLAG_CUR_POWER)
        *data << uint16(player->GetPower(powerType));
 
    if (mask & GROUP_UPDATE_FLAG_MAX_POWER)
        *data << uint16(player->GetMaxPower(powerType));
 
    if (mask & GROUP_UPDATE_FLAG_LEVEL)
        *data << uint16(player->GetLevel());
 
    if (mask & GROUP_UPDATE_FLAG_ZONE)
        *data << uint16(player->GetZoneId());
 
    if (mask & GROUP_UPDATE_FLAG_POSITION)
    {
        *data << uint16(player->GetPositionX());
        *data << uint16(player->GetPositionY());
    }
 
    if (mask & GROUP_UPDATE_FLAG_AURAS)
    {
        uint64 auramask = player->GetAuraUpdateMaskForRaid();
        *data << uint64(auramask);
        for (uint32 i = 0; i < MAX_AURAS_GROUP_UPDATE; ++i)
        {
            if (auramask & (uint64(1) << i))
            {
                AuraApplication const* aurApp = player->GetVisibleAura(i);
                *data << uint32(aurApp ? aurApp->GetBase()->GetId() : 0);
                *data << uint8(1);
            }
        }
    }
 
    Pet* pet = player->GetPet();
    if (mask & GROUP_UPDATE_FLAG_PET_GUID)
    {
        if (pet)
            *data << pet->GetGUID();
        else
            *data << (uint64) 0;
    }
 
    if (mask & GROUP_UPDATE_FLAG_PET_NAME)
    {
        if (pet)
            *data << pet->GetName();
        else
            *data << uint8(0);
    }
 
    if (mask & GROUP_UPDATE_FLAG_PET_MODEL_ID)
    {
        if (pet)
            *data << uint16(pet->GetDisplayId());
        else
            *data << uint16(0);
    }
 
    if (mask & GROUP_UPDATE_FLAG_PET_CUR_HP)
    {
        if (pet)
            *data << uint32(pet->GetHealth());
        else
            *data << uint32(0);
    }
 
    if (mask & GROUP_UPDATE_FLAG_PET_MAX_HP)
    {
        if (pet)
            *data << uint32(pet->GetMaxHealth());
        else
            *data << uint32(0);
    }
 
    if (mask & GROUP_UPDATE_FLAG_PET_POWER_TYPE)
    {
        if (pet)
            *data << uint8(pet->getPowerType());
        else
            *data << uint8(0);
    }
 
    if (mask & GROUP_UPDATE_FLAG_PET_CUR_POWER)
    {
        if (pet)
            *data << uint16(pet->GetPower(pet->getPowerType()));
        else
            *data << uint16(0);
    }
 
    if (mask & GROUP_UPDATE_FLAG_PET_MAX_POWER)
    {
        if (pet)
            *data << uint16(pet->GetMaxPower(pet->getPowerType()));
        else
            *data << uint16(0);
    }
 
    if (mask & GROUP_UPDATE_FLAG_PET_AURAS)
    {
        if (pet)
        {
            uint64 auramask = pet->GetAuraUpdateMaskForRaid();
            *data << uint64(auramask);
            for (uint32 i = 0; i < MAX_AURAS_GROUP_UPDATE; ++i)
            {
                if (auramask & (uint64(1) << i))
                {
                    AuraApplication const* aurApp = pet->GetVisibleAura(i);
                    *data << uint32(aurApp ? aurApp->GetBase()->GetId() : 0);
                    *data << uint8(aurApp ? aurApp->GetFlags() : 0);
                }
            }
        }
        else
            *data << uint64(0);
    }
 
    if (mask & GROUP_UPDATE_FLAG_VEHICLE_SEAT)
    {
        if (Vehicle* veh = player->GetVehicle())
            * data << uint32(veh->GetVehicleInfo()->m_seatID[player->m_movementInfo.transport.seat]);
        else
            *data << uint32(0);
    }
}

Referenced by Group::UpdatePlayerOutOfRange().

◆ CanOpenMailBox()

bool WorldSession::CanOpenMailBox ( ObjectGuid guid )

{
    if (guid == _player->GetGUID())
    {
        if (_player->GetSession()->GetSecurity() < SEC_MODERATOR)
        {
            LOG_ERROR("network.opcode", "{} attempt open mailbox in cheating way.", _player->GetName());
            return false;
        }
    }
    else if (guid.IsGameObject())
    {
        if (!_player->GetGameObjectIfCanInteractWith(guid, GAMEOBJECT_TYPE_MAILBOX))
            return false;
    }
    else if (guid.IsAnyTypeCreature())
    {
        if (!_player->GetNPCIfCanInteractWith(guid, UNIT_NPC_FLAG_MAILBOX))
            return false;
    }
    else
        return false;
 
    return true;
}

References _player, GAMEOBJECT_TYPE_MAILBOX, Player::GetGameObjectIfCanInteractWith(), Object::GetGUID(), WorldObject::GetName(), Player::GetNPCIfCanInteractWith(), GetSecurity(), Player::GetSession(), ObjectGuid::IsAnyTypeCreature(), ObjectGuid::IsGameObject(), LOG_ERROR, SEC_MODERATOR, and UNIT_NPC_FLAG_MAILBOX.

Referenced by HandleGetMailList(), HandleMailCreateTextItem(), HandleMailDelete(), HandleMailMarkAsRead(), HandleMailReturnToSender(), HandleMailTakeItem(), HandleMailTakeMoney(), and HandleSendMail().

◆ CanSkipQueue()

bool WorldSession::CanSkipQueue ( ) const

inline

359{ return _skipQueue; }

References _skipQueue.

Referenced by World::AddSession_().

◆ CanUseBank()

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;
}

References Object::GetGUID(), Player::GetNPCIfCanInteractWith(), GetPlayer(), m_currentBankerGUID, and UNIT_NPC_FLAG_BANKER.

Referenced by HandleAutoBankItemOpcode(), HandleAutoStoreBankItemOpcode(), HandleBuyBankSlotOpcode(), HandleSwapInvItemOpcode(), and HandleSwapItem().

◆ CheckStableMaster()

bool WorldSession::CheckStableMaster ( ObjectGuid guid )

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

References GetPlayer(), LOG_DEBUG, SPELL_AURA_OPEN_STABLE, ObjectGuid::ToString(), and UNIT_NPC_FLAG_STABLEMASTER.

Referenced by HandleBuyStableSlot(), HandleListStabledPetsOpcode(), HandleStablePet(), HandleStableSwapPet(), and HandleUnstablePet().

◆ ComputeNewClockDelta()

void WorldSession::ComputeNewClockDelta ( )

private

{
    // implementation of the technique described here: https://web.archive.org/web/20180430214420/http://www.mine-control.com/zack/timesync/timesync.html
    // to reduce the skew induced by dropped TCP packets that get resent.
 
    std::vector<uint32> latencies;
    std::vector<int64> clockDeltasAfterFiltering;
 
    for (auto& pair : _timeSyncClockDeltaQueue.content())
        latencies.push_back(pair.second);
 
    uint32 latencyMedian = median(latencies);
    uint32 latencyStandardDeviation = standard_deviation(latencies);
 
    uint32 sampleSizeAfterFiltering = 0;
    for (auto& pair : _timeSyncClockDeltaQueue.content())
    {
        if (pair.second <= latencyMedian + latencyStandardDeviation) {
            clockDeltasAfterFiltering.push_back(pair.first);
            sampleSizeAfterFiltering++;
        }
    }
 
    if (sampleSizeAfterFiltering != 0)
    {
        int64 meanClockDelta = static_cast<int64>(mean(clockDeltasAfterFiltering));
        if (std::abs(meanClockDelta - _timeSyncClockDelta) > 25)
            _timeSyncClockDelta = meanClockDelta;
    }
    else if (_timeSyncClockDelta == 0)
    {
        std::pair<int64, uint32> back = _timeSyncClockDeltaQueue.peak_back();
        _timeSyncClockDelta = back.first;
    }
}

References _timeSyncClockDelta, _timeSyncClockDeltaQueue, CircularBuffer< T >::content(), mean(), median(), CircularBuffer< T >::peak_back(), and standard_deviation().

Referenced by HandleTimeSyncResp().

◆ DisallowHyperlinksAndMaybeKick()

bool WorldSession::DisallowHyperlinksAndMaybeKick ( std::string_view str )

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

References CONFIG_CHAT_STRICT_LINK_CHECKING_KICK, GetPlayer(), KickPlayer(), LOG_ERROR, STRING_VIEW_FMT_ARG, and sWorld.

Referenced by HandleJoinChannel().

◆ DoLootRelease()

void WorldSession::DoLootRelease ( ObjectGuid lguid )

{
    Player*  player = GetPlayer();
    Loot*    loot;
 
    player->SetLootGUID(ObjectGuid::Empty);
    player->SendLootRelease(lguid);
 
    player->RemoveUnitFlag(UNIT_FLAG_LOOTING);
 
    if (!player->IsInWorld())
        return;
 
    if (lguid.IsGameObject())
    {
        GameObject* go = GetPlayer()->GetMap()->GetGameObject(lguid);
 
        // not check distance for GO in case owned GO (fishing bobber case, for example) or Fishing hole GO
        if (!go || ((go->GetOwnerGUID() != _player->GetGUID() && go->GetGoType() != GAMEOBJECT_TYPE_FISHINGHOLE) && !go->IsWithinDistInMap(_player)))
        {
            return;
        }
 
        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);
 
                // Xinef: moved event execution to loot release (after everything is looted)
                // Xinef: 99% sure that this worked like this on blizz
                // Xinef: prevents exploits with just opening GO and spawning bilions of npcs, which can crash core if you know what you're doin ;)
                if (go->GetGoType() == GAMEOBJECT_TYPE_CHEST && go->GetGOInfo()->chest.eventId)
                {
                    LOG_DEBUG("spells.aura", "Chest ScriptStart id {} for GO {}", go->GetGOInfo()->chest.eventId, go->GetSpawnId());
                    player->GetMap()->ScriptsStart(sEventScripts, go->GetGOInfo()->chest.eventId, player, go);
                }
            }
 
            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;
 
        // Xinef: Buggs client? (Opening loot after closing)
        //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;
 
        loot = &pItem->loot;
        ItemTemplate const* proto = pItem->GetTemplate();
 
        // destroy only 5 items from stack in case prospecting and milling
        if (proto->Flags & (ITEM_FLAG_IS_PROSPECTABLE | ITEM_FLAG_IS_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 if (pItem->loot.isLooted() || !(proto->Flags & ITEM_FLAG_HAS_LOOT))
        {
            player->DestroyItem(pItem->GetBagSlot(), pItem->GetSlot(), true);
            return;
        }
    }
    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())
        {
            // skip pickpocketing loot for speed, skinning timer reduction is no-op in fact
            if (!creature->IsAlive())
                creature->AllLootRemovedFromCorpse();
 
            creature->RemoveDynamicFlag(UNIT_DYNFLAG_LOOTABLE);
            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, nullptr);
            }
            // force dynflag update to update looter and lootable info
            creature->ForceValuesUpdateAtIndex(UNIT_DYNAMIC_FLAGS);
        }
    }
 
    //Player is not looking at loot list, he doesn't need to see updates on the loot list
    if (!lguid.IsItem())
    {
        loot->RemoveLooter(player->GetGUID());
    }
}

References _player, GameObject::AddUse(), Creature::AllLootRemovedFromCorpse(), GameObjectTemplate::chest, CLASS_ROGUE, ObjectGuid::Clear(), Loot::clear(), CORPSE_DYNFLAG_LOOTABLE, CORPSE_FIELD_DYNAMIC_FLAGS, Player::DestroyItem(), Player::DestroyItemCount(), ObjectGuid::Empty, GameObjectTemplate::eventId, GameObjectValue::FishingHole, ItemTemplate::Flags, Object::ForceValuesUpdateAtIndex(), GAMEOBJECT_TYPE_CHEST, GAMEOBJECT_TYPE_DOOR, GAMEOBJECT_TYPE_FISHINGHOLE, GAMEOBJECT_TYPE_FISHINGNODE, Item::GetBagSlot(), Unit::getClass(), ObjectAccessor::GetCorpse(), Item::GetCount(), Map::GetCreature(), Map::GetGameObject(), GameObject::GetGOInfo(), GameObject::GetGoType(), GameObject::GetGOValue(), Player::GetGroup(), Object::GetGUID(), Player::GetItemByGuid(), WorldObject::GetMap(), GameObject::GetOwnerGUID(), GetPlayer(), Item::GetSlot(), GameObject::GetSpawnId(), Item::GetTemplate(), GameObject::GetUseCount(), GO_ACTIVATED, GO_JUST_DEACTIVATED, GO_READY, INTERACTION_DISTANCE, Unit::IsAlive(), ObjectGuid::IsCorpse(), ObjectGuid::IsGameObject(), Object::IsInWorld(), ObjectGuid::IsItem(), Loot::isLooted(), GameObject::IsWithinDistInMap(), WorldObject::IsWithinDistInMap(), ITEM_FLAG_HAS_LOOT, ITEM_FLAG_IS_MILLABLE, ITEM_FLAG_IS_PROSPECTABLE, LOG_DEBUG, Corpse::loot, Creature::loot, GameObject::loot, Item::loot, LOOT_PICKPOCKETING, Loot::loot_type, Item::m_lootGenerated, GameObjectValue::MaxOpens, Object::RemoveDynamicFlag(), Object::RemoveFlag(), Loot::RemoveLooter(), Unit::RemoveUnitFlag(), Loot::roundRobinPlayer, Map::ScriptsStart(), Player::SendLootRelease(), Player::SetLootGUID(), GameObject::SetLootState(), sEventScripts, UNIT_DYNAMIC_FLAGS, UNIT_DYNFLAG_LOOTABLE, UNIT_FLAG_LOOTING, and GameObject::UseDoorOrButton().

Referenced by HandleAutostoreLootItemOpcode(), HandleLogoutRequestOpcode(), HandleLootMoneyOpcode(), HandleLootReleaseOpcode(), LogoutPlayer(), Player::RemoveFromWorld(), Player::SendLoot(), and Player::SwapItem().

◆ Expansion()

uint8 WorldSession::Expansion ( ) const

inline

372{ return m_expansion; }

References m_expansion.

Referenced by Player::_LoadHomeBind(), HandleCharCreateOpcode(), HandleLfgPlayerLockInfoRequestOpcode(), lfg::LFGMgr::InitializeLockedDungeons(), and SendAuthResponse().

◆ GetAccountData()

AccountData * WorldSession::GetAccountData ( AccountDataType type )

inline

449{ return &m_accountData[type]; }

WorldSession::m_accountData

AccountData m_accountData[NUM_ACCOUNT_DATA_TYPES]

Definition: WorldSession.h:1167

References m_accountData.

Referenced by HandleRequestAccountData(), and SendAccountDataTimes().

◆ GetAccountId()

uint32 WorldSession::GetAccountId ( ) const

inline

360{ return _accountId; }

References _accountId.

◆ GetAcoreString()

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

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

References GetSessionDbLocaleIndex(), and sObjectMgr.

Referenced by Player::_LoadInventory(), Player::AutoUnequipOffhandIfNeed(), ChatHandler::GetAcoreString(), HandleAddFriendOpcode(), HandleAddIgnoreOpcode(), HandleGMTicketCreateOpcode(), HandleInitiateTradeOpcode(), HandleMessagechatOpcode(), HandleSendMail(), HandleTextEmoteOpcode(), MapMgr::PlayerCannotEnter(), Player::Satisfy(), SendAuctionHello(), SendNotification(), and SendTrainerList().

◆ GetCalendarEventCreationCooldown()

time_t WorldSession::GetCalendarEventCreationCooldown ( ) const

inline

528{ return _calendarEventCreationCooldown; }

References _calendarEventCreationCooldown.

Referenced by HandleCalendarAddEvent(), and HandleCalendarCopyEvent().

◆ GetCurrentVendor()

uint32 WorldSession::GetCurrentVendor ( ) const

inline

365{ return m_currentVendorEntry; }

References m_currentVendorEntry.

Referenced by Player::BuyItemFromVendorSlot(), npc_commandscript::HandleNpcAddVendorItemCommand(), and npc_commandscript::HandleNpcDeleteVendorItemCommand().

◆ GetGuidLow()

ObjectGuid::LowType WorldSession::GetGuidLow ( ) const

Get player guid if available. Use for logging purposes only.

{
    return GetPlayer() ? GetPlayer()->GetGUID().GetCounter() : 0;
}

References ObjectGuid::GetCounter(), Object::GetGUID(), and GetPlayer().

◆ GetLatency()

uint32 WorldSession::GetLatency ( ) const

inline

500{ return m_latency; }

References m_latency.

Referenced by Player::_SaveCharacter(), WorldSession::DosProtection::EvaluateOpcode(), misc_commandscript::HandlePInfoCommand(), and HandleReportLag().

◆ GetOfflineTime()

uint32 WorldSession::GetOfflineTime ( ) const

inline

1066{ return _offlineTime; }

References _offlineTime.

Referenced by World::UpdateSessions().

◆ GetPlayer()

Player * WorldSession::GetPlayer ( ) const

inline

361{ return _player; }

References _player.

◆ GetPlayerInfo()

std::string WorldSession::GetPlayerInfo ( ) const

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

References _player, GetAccountId(), Object::GetGUID(), WorldObject::GetName(), m_playerLoading, and ObjectGuid::ToString().

◆ GetPlayerName()

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

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

References _player, and WorldObject::GetName().

Referenced by ArenaTeam::Disband(), WorldSession::DosProtection::EvaluateOpcode(), ban_commandscript::HandleBanCharacterCommand(), ban_commandscript::HandleBanHelper(), misc_commandscript::HandleKickPlayerCommand(), and misc_commandscript::HandleMuteCommand().

◆ GetQueryProcessor()

QueryCallbackProcessor & WorldSession::GetQueryProcessor ( )

inline

1075{ return _queryProcessor; }

WorldSession::_queryProcessor

QueryCallbackProcessor _queryProcessor

Definition: WorldSession.h:1085

References _queryProcessor.

Referenced by Player::ActivateSpec(), and ServerMailReward::OnLogin().

◆ GetRecruiterId()

uint32 WorldSession::GetRecruiterId ( ) const

inline

524{ return recruiterId; }

References recruiterId.

Referenced by Spell::CheckCast(), Spell::CheckEffectTarget(), Player::GetsRecruitAFriendBonus(), HandleAcceptGrantLevel(), HandleGrantLevel(), HandlePlayerLoginFromDB(), and Player::LoadFromDB().

◆ GetRemoteAddress()

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

inline

◆ GetSecurity()

AccountTypes WorldSession::GetSecurity ( ) const

inline

358{ return _security; }

References _security.

Referenced by ChatHandler::_ParseCommands(), World::AddSession_(), Channel::Announce(), SocialMgr::BroadcastToFriendListers(), GameObject::BuildValuesUpdate(), Unit::BuildValuesUpdate(), CanOpenMailBox(), AchievementMgr::CompletedAchievement(), Channel::FlagsNotify(), SocialMgr::GetFriendInfo(), account_commandscript::HandleAccountCommand(), HandleAddFriendOpcode(), misc_commandscript::HandleAddItemCommand(), HandleCharCreateOpcode(), HandleCharFactionOrRaceChangeCallback(), misc_commandscript::HandleDamageCommand(), misc_commandscript::HandleDevCommand(), misc_commandscript::HandleDieCommand(), ticket_commandscript::HandleGMTicketUnAssignCommand(), HandleLogoutRequestOpcode(), HandleMessagechatOpcode(), misc_commandscript::HandlePInfoCommand(), WorldSocket::HandlePing(), misc_commandscript::HandleSaveCommand(), HandleSendMail(), ArenaSpectator::HandleSpectatorSpectateCommand(), misc_commandscript::HandleUnstuckCommand(), HandleWhoisOpcode(), HandleWhoOpcode(), HandleWorldTeleportOpcode(), ChatHandler::HasLowerSecurityAccount(), ChatHandler::IsAvailable(), Player::IsVisibleGloballyFor(), Channel::JoinChannel(), Channel::JoinNotify(), Channel::KickOrBan(), Channel::LeaveChannel(), Channel::LeaveNotify(), LogCommandUsage(), Channel::Password(), ReadMovementInfo(), World::SendGMText(), MailDraft::SendMailTo(), Channel::SetMode(), Channel::SetOwner(), Channel::ToggleModeration(), and Channel::UnBan().

◆ GetSessionDbcLocale()

LocaleConstant WorldSession::GetSessionDbcLocale ( ) const

inline

496{ return m_sessionDbcLocale; }

References m_sessionDbcLocale.

Referenced by AuctionHouseObject::BuildListAuctionItems(), ChatHandler::GetSessionDbcLocale(), lookup_commandscript::HandleLookupMapCommand(), HandleMailCreateTextItem(), HandleWhoOpcode(), MapMgr::PlayerCannotEnter(), and Player::UpdateLocalChannels().

◆ GetSessionDbLocaleIndex()

LocaleConstant WorldSession::GetSessionDbLocaleIndex ( ) const

inline

497{ return m_sessionDbLocaleIndex; }

References m_sessionDbLocaleIndex.

Referenced by AuctionHouseObject::BuildListAuctionItems(), AchievementMgr::CompletedAchievement(), Guild::Create(), GetAcoreString(), ChatHandler::GetSessionDbLocaleIndex(), HandleCharFactionOrRaceChangeCallback(), HandleCreatureQueryOpcode(), HandleGameObjectQueryOpcode(), HandleItemNameQueryOpcode(), HandleItemQuerySingleOpcode(), HandleNpcTextQueryOpcode(), HandlePageTextQueryOpcode(), Player::hasSpanishClient(), Acore::LocalizedPacketDo< Builder >::operator()(), Acore::LocalizedPacketListDo< Builder >::operator()(), CreatureTextLocalizer< Builder >::operator()(), PlayerMenu::PlayerMenu(), Player::PrepareGossipMenu(), Player::PrettyPrintRequirementsAchievementsList(), Player::PrettyPrintRequirementsItemsList(), Player::PrettyPrintRequirementsQuestList(), PlayerMenu::SendGossipMenu(), SendPetNameQuery(), PlayerMenu::SendPointOfInterest(), Player::SendPreparedQuest(), Player::SendQuestConfirmAccept(), PlayerMenu::SendQuestGiverOfferReward(), PlayerMenu::SendQuestGiverQuestDetails(), PlayerMenu::SendQuestGiverQuestList(), PlayerMenu::SendQuestGiverRequestItems(), PlayerMenu::SendQuestQueryResponse(), Spell::SendResurrectRequest(), SortAuction(), Unit::Whisper(), and Player::Whisper().

◆ GetTotalTime()

uint32 WorldSession::GetTotalTime ( ) const

inline

375{ return m_total_time; }

References m_total_time.

Referenced by ~WorldSession().

◆ GetTutorialInt()

uint32 WorldSession::GetTutorialInt ( uint8 index ) const

inline

457{ return m_Tutorials[index]; }

References m_Tutorials.

Referenced by HandleTutorialFlag().

◆ GetWarden()

Warden * WorldSession::GetWarden ( )

{
    return &(*_warden);
}

◆ Handle_Deprecated()

void WorldSession::Handle_Deprecated ( WorldPacket & recvPacket )

{
    LOG_ERROR("network.opcode", "Received deprecated opcode {} from {}",
        GetOpcodeNameForLogging(static_cast<OpcodeClient>(recvPacket.GetOpcode())), GetPlayerInfo());
}

References WorldPacket::GetOpcode(), GetOpcodeNameForLogging(), GetPlayerInfo(), and LOG_ERROR.

◆ Handle_EarlyProccess()

void WorldSession::Handle_EarlyProccess ( WorldPacket & recvPacket )

{
    LOG_ERROR("network.opcode", "Received opcode {} that must be processed in WorldSocket::ReadDataHandler from {}",
        GetOpcodeNameForLogging(static_cast<OpcodeClient>(recvPacket.GetOpcode())), GetPlayerInfo());
}

References WorldPacket::GetOpcode(), GetOpcodeNameForLogging(), GetPlayerInfo(), and LOG_ERROR.

Referenced by OpcodeTable::Initialize().

◆ Handle_NULL()

void WorldSession::Handle_NULL ( WorldPacket & null )

{
    LOG_ERROR("network.opcode", "Received unhandled opcode {} from {}",
        GetOpcodeNameForLogging(static_cast<OpcodeClient>(null.GetOpcode())), GetPlayerInfo());
}

References WorldPacket::GetOpcode(), GetOpcodeNameForLogging(), GetPlayerInfo(), and LOG_ERROR.

Referenced by OpcodeTable::Initialize().

◆ Handle_ServerSide()

void WorldSession::Handle_ServerSide ( WorldPacket & recvPacket )

{
    LOG_ERROR("network.opcode", "Received server-side opcode {} from {}",
        GetOpcodeNameForLogging(static_cast<OpcodeServer>(recvPacket.GetOpcode())), GetPlayerInfo());
}

References WorldPacket::GetOpcode(), GetOpcodeNameForLogging(), GetPlayerInfo(), and LOG_ERROR.

◆ HandleAcceptGrantLevel()

void WorldSession::HandleAcceptGrantLevel ( WorldPacket & recvData )

{
    LOG_DEBUG("network", "WORLD: CMSG_ACCEPT_LEVEL_GRANT");
 
    ObjectGuid guid;
    recvData >> guid.ReadAsPacked();
 
    Player* other = ObjectAccessor::GetPlayer(*_player, guid);
    if (!other)
        return;
 
    if (GetAccountId() != other->GetSession()->GetRecruiterId())
        return;
 
    if (other->GetGrantableLevels())
        other->SetGrantableLevels(other->GetGrantableLevels() - 1);
    else
        return;
 
    _player->GiveLevel(_player->GetLevel() + 1);
}

References _player, GetAccountId(), Player::GetGrantableLevels(), Unit::GetLevel(), ObjectAccessor::GetPlayer(), GetRecruiterId(), Player::GetSession(), Player::GiveLevel(), LOG_DEBUG, ObjectGuid::ReadAsPacked(), and Player::SetGrantableLevels().

Referenced by OpcodeTable::Initialize().

◆ HandleAcceptTradeOpcode()

void WorldSession::HandleAcceptTradeOpcode ( WorldPacket & recvPacket )

{
    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]  = { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr };
    Item* hisItems[TRADE_SLOT_TRADED_COUNT] = { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr };
    bool myCanCompleteTrade = true, hisCanCompleteTrade = true;
 
    // set before checks for propertly undo at problems (it already set in to client)
    my_trade->SetAccepted(true);
 
    // not accept case incorrect money amount
    if (!_player->HasEnoughMoney(my_trade->GetMoney()))
    {
        SendNotification(LANG_NOT_ENOUGH_GOLD);
        my_trade->SetAccepted(false, true);
        return;
    }
 
    // not accept case incorrect money amount
    if (!trader->HasEnoughMoney(his_trade->GetMoney()))
    {
        trader->GetSession()->SendNotification(LANG_NOT_ENOUGH_GOLD);
        his_trade->SetAccepted(false, true);
        return;
    }
 
    if (_player->GetMoney() >= uint32(MAX_MONEY_AMOUNT) - his_trade->GetMoney())
    {
        _player->SendEquipError(EQUIP_ERR_TOO_MUCH_GOLD, nullptr, nullptr);
        my_trade->SetAccepted(false, true);
        return;
    }
 
    if (trader->GetMoney() >= uint32(MAX_MONEY_AMOUNT) - my_trade->GetMoney())
    {
        trader->SendEquipError(EQUIP_ERR_TOO_MUCH_GOLD, nullptr, nullptr);
        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))
            {
                SendTradeStatus(TRADE_STATUS_TRADE_CANCELED);
                return;
            }
 
            if (item->IsBindedNotWith(trader))
            {
                SendTradeStatus(TRADE_STATUS_NOT_ELIGIBLE);
                SendTradeStatus(TRADE_STATUS_CLOSE_WINDOW/*TRADE_STATUS_TRADE_CANCELED*/);
                return;
            }
        }
 
        if (Item* item = his_trade->GetItem(TradeSlots(i)))
        {
            if (!item->CanBeTraded(false, true))
            {
                SendTradeStatus(TRADE_STATUS_TRADE_CANCELED);
                return;
            }
            //if (item->IsBindedNotWith(_player))   // dont mark as invalid when his item isnt good (not exploitable because if item is invalid trade will fail anyway later on the same check)
            //{
            //    SendTradeStatus(TRADE_STATUS_NOT_ELIGIBLE);
            //    his_trade->SetAccepted(false, true);
            //    return;
            //}
        }
    }
 
    if (his_trade->IsAccepted())
    {
        setAcceptTradeMode(my_trade, his_trade, myItems, hisItems);
 
        Spell* my_spell = nullptr;
        SpellCastTargets my_targets;
 
        Spell* his_spell = nullptr;
        SpellCastTargets his_targets;
 
        // not accept if spell can't be casted 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 casted 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
        trader->GetSession()->SendTradeStatus(TRADE_STATUS_TRADE_ACCEPT);
 
        // test if item will fit in each inventory
        hisCanCompleteTrade = (trader->CanStoreItems(myItems, TRADE_SLOT_TRADED_COUNT) == EQUIP_ERR_OK);
        myCanCompleteTrade = (_player->CanStoreItems(hisItems, TRADE_SLOT_TRADED_COUNT) == EQUIP_ERR_OK);
 
        clearAcceptTradeMode(myItems, hisItems);
 
        // in case of missing space report error
        if (!myCanCompleteTrade)
        {
            clearAcceptTradeMode(my_trade, his_trade);
 
            SendNotification(LANG_NOT_FREE_TRADE_SLOTS);
            trader->GetSession()->SendNotification(LANG_NOT_PARTNER_FREE_TRADE_SLOTS);
            my_trade->SetAccepted(false);
            his_trade->SetAccepted(false);
            delete my_spell;
            delete his_spell;
            return;
        }
        else if (!hisCanCompleteTrade)
        {
            clearAcceptTradeMode(my_trade, his_trade);
 
            SendNotification(LANG_NOT_PARTNER_FREE_TRADE_SLOTS);
            trader->GetSession()->SendNotification(LANG_NOT_FREE_TRADE_SLOTS);
            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);
 
        if( my_trade->GetMoney() >= 10 * GOLD )
        {
            CharacterDatabase.Execute("INSERT INTO log_money VALUES({}, {}, \"{}\", \"{}\", {}, \"{}\", {}, \"goods\", NOW(), {})",
                GetAccountId(), _player->GetGUID().GetCounter(), _player->GetName(), GetRemoteAddress(), trader->GetSession()->GetAccountId(), trader->GetName(), my_trade->GetMoney(), 6);
        }
        if( his_trade->GetMoney() >= 10 * GOLD )
        {
            CharacterDatabase.Execute("INSERT INTO log_money VALUES({}, {}, \"{}\", \"{}\", {}, \"{}\", {}, \"goods\", NOW(), {})",
                trader->GetSession()->GetAccountId(), trader->GetGUID().GetCounter(), trader->GetName(), trader->GetSession()->GetRemoteAddress(), GetAccountId(), _player->GetName(), his_trade->GetMoney(), 6);
        }
 
        // update money
        _player->ModifyMoney(-int32(my_trade->GetMoney()));
        _player->ModifyMoney(his_trade->GetMoney());
        trader->ModifyMoney(-int32(his_trade->GetMoney()));
        trader->ModifyMoney(my_trade->GetMoney());
 
        if (my_spell)
            my_spell->prepare(&my_targets);
 
        if (his_spell)
            his_spell->prepare(&his_targets);
 
        // cleanup
        clearAcceptTradeMode(my_trade, his_trade);
        delete _player->m_trade;
        _player->m_trade = nullptr;
        delete trader->m_trade;
        trader->m_trade = nullptr;
 
        // desynchronized with the other saves here (SaveInventoryAndGoldToDB() not have own transaction guards)
        CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
        _player->SaveInventoryAndGoldToDB(trans);
        trader->SaveInventoryAndGoldToDB(trans);
        CharacterDatabase.CommitTransaction(trans);
 
        trader->GetSession()->SendTradeStatus(TRADE_STATUS_TRADE_COMPLETE);
        SendTradeStatus(TRADE_STATUS_TRADE_COMPLETE);
    }
    else
    {
        trader->GetSession()->SendTradeStatus(TRADE_STATUS_TRADE_ACCEPT);
    }
}

References _player, Player::CanStoreItems(), CharacterDatabase, Spell::CheckCast(), clearAcceptTradeMode(), EQUIP_ERR_OK, EQUIP_ERR_TOO_MUCH_GOLD, GetAccountId(), ObjectGuid::GetCounter(), Object::GetGUID(), TradeData::GetItem(), Player::GetMoney(), TradeData::GetMoney(), WorldObject::GetName(), GetRemoteAddress(), Player::GetSession(), TradeData::GetSpell(), TradeData::GetSpellCastItem(), TradeData::GetTrader(), GOLD, Player::HasEnoughMoney(), TradeData::HasSpellCastItem(), TradeData::IsAccepted(), ITEM_FIELD_GIFTCREATOR, LANG_NOT_ENOUGH_GOLD, LANG_NOT_FREE_TRADE_SLOTS, LANG_NOT_PARTNER_FREE_TRADE_SLOTS, Spell::m_CastItem, Spell::m_targets, Player::m_trade, MAX_MONEY_AMOUNT, Player::ModifyMoney(), Player::MoveItemFromInventory(), moveItems(), Spell::prepare(), Player::SaveInventoryAndGoldToDB(), Spell::SendCastResult(), Player::SendEquipError(), SendNotification(), SendTradeStatus(), TradeData::SetAccepted(), setAcceptTradeMode(), Object::SetGuidValue(), TradeData::SetSpell(), SpellCastTargets::SetTradeItemTarget(), SPELL_CAST_OK, sSpellMgr, TRADE_SLOT_NONTRADED, TRADE_SLOT_TRADED_COUNT, TRADE_STATUS_CLOSE_WINDOW, TRADE_STATUS_NOT_ELIGIBLE, TRADE_STATUS_TRADE_ACCEPT, TRADE_STATUS_TRADE_CANCELED, TRADE_STATUS_TRADE_COMPLETE, and TRIGGERED_FULL_MASK.

Referenced by OpcodeTable::Initialize().

◆ HandleActivateTaxiExpressOpcode()

void WorldSession::HandleActivateTaxiExpressOpcode ( WorldPacket & recvPacket )

{
    LOG_DEBUG("network", "WORLD: Received CMSG_ACTIVATETAXIEXPRESS");
 
    ObjectGuid guid;
    uint32 node_count;
 
    recvData >> guid >> node_count;
 
    Creature* npc = GetPlayer()->GetNPCIfCanInteractWith(guid, UNIT_NPC_FLAG_FLIGHTMASTER);
    if (!npc)
    {
        LOG_DEBUG("network", "WORLD: HandleActivateTaxiExpressOpcode - Unit ({}) not found or you can't interact with it.", guid.ToString());
        SendActivateTaxiReply(ERR_TAXITOOFARAWAY);
        return;
    }
    std::vector<uint32> nodes;
 
    for (uint32 i = 0; i < node_count; ++i)
    {
        uint32 node;
        recvData >> node;
 
        if (!GetPlayer()->m_taxi.IsTaximaskNodeKnown(node) && !GetPlayer()->isTaxiCheater())
        {
            SendActivateTaxiReply(ERR_TAXINOTVISITED);
            recvData.rfinish();
            return;
        }
 
        nodes.push_back(node);
    }
 
    if (nodes.empty())
        return;
 
    LOG_DEBUG("network", "WORLD: Received CMSG_ACTIVATETAXIEXPRESS from {} to {}", nodes.front(), nodes.back());
 
    GetPlayer()->ActivateTaxiPathTo(nodes, npc, 0);
}

References Player::ActivateTaxiPathTo(), ERR_TAXINOTVISITED, ERR_TAXITOOFARAWAY, Player::GetNPCIfCanInteractWith(), GetPlayer(), LOG_DEBUG, ByteBuffer::rfinish(), SendActivateTaxiReply(), ObjectGuid::ToString(), and UNIT_NPC_FLAG_FLIGHTMASTER.

Referenced by OpcodeTable::Initialize().

◆ HandleActivateTaxiOpcode()

void WorldSession::HandleActivateTaxiOpcode ( WorldPacket & recvPacket )

{
    LOG_DEBUG("network", "WORLD: Received CMSG_ACTIVATETAXI");
 
    ObjectGuid guid;
    std::vector<uint32> nodes;
    nodes.resize(2);
    GetPlayer()->SetCanTeleport(true);
    recvData >> guid >> nodes[0] >> nodes[1];
    LOG_DEBUG("network", "WORLD: Received CMSG_ACTIVATETAXI from {} to {}", nodes[0], nodes[1]);
    Creature* npc = GetPlayer()->GetNPCIfCanInteractWith(guid, UNIT_NPC_FLAG_FLIGHTMASTER);
    if (!npc)
    {
        LOG_DEBUG("network", "WORLD: HandleActivateTaxiOpcode - Unit ({}) not found or you can't interact with it.", guid.ToString());
        SendActivateTaxiReply(ERR_TAXITOOFARAWAY);
        return;
    }
 
    if (!GetPlayer()->isTaxiCheater())
    {
        if (!GetPlayer()->m_taxi.IsTaximaskNodeKnown(nodes[0]) || !GetPlayer()->m_taxi.IsTaximaskNodeKnown(nodes[1]))
        {
            SendActivateTaxiReply(ERR_TAXINOTVISITED);
            return;
        }
    }
 
    GetPlayer()->ActivateTaxiPathTo(nodes, npc, 0);
}

References Player::ActivateTaxiPathTo(), ERR_TAXINOTVISITED, ERR_TAXITOOFARAWAY, Player::GetNPCIfCanInteractWith(), GetPlayer(), LOG_DEBUG, SendActivateTaxiReply(), Player::SetCanTeleport(), ObjectGuid::ToString(), and UNIT_NPC_FLAG_FLIGHTMASTER.

Referenced by OpcodeTable::Initialize().

◆ HandleAddFriendOpcode()

void WorldSession::HandleAddFriendOpcode ( WorldPacket & recvPacket )

{
    LOG_DEBUG("network", "WORLD: Received CMSG_ADD_FRIEND");
 
    std::string friendName = GetAcoreString(LANG_FRIEND_IGNORE_UNKNOWN);
    std::string friendNote;
 
    recv_data >> friendName;
    recv_data >> friendNote;
 
    if (!normalizePlayerName(friendName))
        return;
 
    LOG_DEBUG("network", "WORLD: {} asked to add friend : '{}'", GetPlayer()->GetName(), friendName);
 
    ObjectGuid friendGuid = sCharacterCache->GetCharacterGuidByName(friendName);
    if (!friendGuid)
        return;
 
    CharacterCacheEntry const* playerData = sCharacterCache->GetCharacterCacheByGuid(friendGuid);
    if (!playerData)
        return;
 
    uint32 friendAccountId = playerData->AccountId;
    TeamId teamId = Player::TeamIdForRace(playerData->Race);
    FriendsResult friendResult = FRIEND_NOT_FOUND;
 
    if (!AccountMgr::IsPlayerAccount(GetSecurity()) || sWorld->getBoolConfig(CONFIG_ALLOW_GM_FRIEND)|| AccountMgr::IsPlayerAccount(AccountMgr::GetSecurity(friendAccountId, realm.Id.Realm)))
    {
        if (friendGuid)
        {
            if (friendGuid == GetPlayer()->GetGUID())
                friendResult = FRIEND_SELF;
            else if (GetPlayer()->GetTeamId() != teamId && !sWorld->getBoolConfig(CONFIG_ALLOW_TWO_SIDE_ADD_FRIEND)  && AccountMgr::IsPlayerAccount(GetSecurity()))
                friendResult = FRIEND_ENEMY;
            else if (GetPlayer()->GetSocial()->HasFriend(friendGuid))
                friendResult = FRIEND_ALREADY;
            else
            {
                Player* pFriend = ObjectAccessor::FindConnectedPlayer(friendGuid);
                if (pFriend && pFriend->IsVisibleGloballyFor(GetPlayer()) && !AccountMgr::IsGMAccount(pFriend->GetSession()->GetSecurity()))
                    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;
            }
            GetPlayer()->GetSocial()->SetFriendNote(friendGuid, friendNote);
        }
    }
 
    sSocialMgr->SendFriendStatus(GetPlayer(), friendResult, friendGuid, false);
 
    LOG_DEBUG("network", "WORLD: Sent (SMSG_FRIEND_STATUS)");
}

References CharacterCacheEntry::AccountId, CONFIG_ALLOW_GM_FRIEND, CONFIG_ALLOW_TWO_SIDE_ADD_FRIEND, ObjectAccessor::FindConnectedPlayer(), FRIEND_ADDED_OFFLINE, FRIEND_ADDED_ONLINE, FRIEND_ALREADY, FRIEND_ENEMY, FRIEND_LIST_FULL, FRIEND_NOT_FOUND, FRIEND_SELF, GetAcoreString(), GetPlayer(), GetSecurity(), AccountMgr::GetSecurity(), Player::GetSession(), Player::GetSocial(), GetTeamId(), Realm::Id, AccountMgr::IsGMAccount(), AccountMgr::IsPlayerAccount(), Player::IsVisibleGloballyFor(), LANG_FRIEND_IGNORE_UNKNOWN, LOG_DEBUG, normalizePlayerName(), CharacterCacheEntry::Race, realm, RealmHandle::Realm, sCharacterCache, PlayerSocial::SetFriendNote(), SOCIAL_FLAG_FRIEND, sSocialMgr, sWorld, and Player::TeamIdForRace().

Referenced by OpcodeTable::Initialize().

◆ HandleAddIgnoreOpcode()

void WorldSession::HandleAddIgnoreOpcode ( WorldPacket & recvPacket )

{
    std::string ignoreName = GetAcoreString(LANG_FRIEND_IGNORE_UNKNOWN);
 
    recv_data >> ignoreName;
 
    if (!normalizePlayerName(ignoreName))
        return;
 
    LOG_DEBUG("network", "WORLD: {} asked to Ignore: '{}'", GetPlayer()->GetName(), ignoreName);
 
    ObjectGuid ignoreGuid = sCharacterCache->GetCharacterGuidByName(ignoreName);
    if (!ignoreGuid)
        return;
 
    FriendsResult ignoreResult;
 
    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, false);
 
    LOG_DEBUG("network", "WORLD: Sent (SMSG_FRIEND_STATUS)");
}

References FRIEND_IGNORE_ADDED, FRIEND_IGNORE_ALREADY, FRIEND_IGNORE_FULL, FRIEND_IGNORE_SELF, GetAcoreString(), GetPlayer(), LANG_FRIEND_IGNORE_UNKNOWN, LOG_DEBUG, normalizePlayerName(), sCharacterCache, SOCIAL_FLAG_IGNORED, and sSocialMgr.

Referenced by OpcodeTable::Initialize().

◆ HandleAlterAppearance()

void WorldSession::HandleAlterAppearance ( WorldPacket & recvData )

{
    LOG_DEBUG("network", "CMSG_ALTER_APPEARANCE");
 
    uint32 Hair, Color, FacialHair, SkinColor;
    recvData >> Hair >> Color >> FacialHair >> SkinColor;
 
    BarberShopStyleEntry const* bs_hair = sBarberShopStyleStore.LookupEntry(Hair);
 
    if (!bs_hair || bs_hair->type != 0 || bs_hair->race != _player->getRace() || bs_hair->gender != _player->getGender())
        return;
 
    BarberShopStyleEntry const* bs_facialHair = sBarberShopStyleStore.LookupEntry(FacialHair);
 
    if (!bs_facialHair || bs_facialHair->type != 2 || bs_facialHair->race != _player->getRace() || bs_facialHair->gender != _player->getGender())
        return;
 
    BarberShopStyleEntry const* bs_skinColor = sBarberShopStyleStore.LookupEntry(SkinColor);
 
    if (bs_skinColor && (bs_skinColor->type != 3 || bs_skinColor->race != _player->getRace() || bs_skinColor->gender != _player->getGender()))
        return;
 
    GameObject* go = _player->FindNearestGameObjectOfType(GAMEOBJECT_TYPE_BARBER_CHAIR, 5.0f);
    if (!go)
    {
        WorldPacket data(SMSG_BARBER_SHOP_RESULT, 4);
        data << uint32(2);
        SendPacket(&data);
        return;
    }
 
    if (_player->getStandState() != UNIT_STAND_STATE_SIT_LOW_CHAIR + go->GetGOInfo()->barberChair.chairheight)
    {
        WorldPacket data(SMSG_BARBER_SHOP_RESULT, 4);
        data << uint32(2);
        SendPacket(&data);
        return;
    }
 
    uint32 cost = _player->GetBarberShopCost(bs_hair->hair_id, Color, bs_facialHair->hair_id, bs_skinColor);
 
    // 0 - ok
    // 1, 3 - not enough money
    // 2 - you have to seat on barber chair
    if (!_player->HasEnoughMoney(cost))
    {
        WorldPacket data(SMSG_BARBER_SHOP_RESULT, 4);
        data << uint32(1);                                  // no money
        SendPacket(&data);
        return;
    }
    else
    {
        WorldPacket data(SMSG_BARBER_SHOP_RESULT, 4);
        data << uint32(0);                                  // ok
        SendPacket(&data);
    }
 
    _player->ModifyMoney(-int32(cost));                     // it isn't free
    _player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_GOLD_SPENT_AT_BARBER, cost);
 
    _player->SetByteValue(PLAYER_BYTES, 2, uint8(bs_hair->hair_id));
    _player->SetByteValue(PLAYER_BYTES, 3, uint8(Color));
    _player->SetByteValue(PLAYER_BYTES_2, 0, uint8(bs_facialHair->hair_id));
    if (bs_skinColor)
        _player->SetByteValue(PLAYER_BYTES, 0, uint8(bs_skinColor->hair_id));
 
    _player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_VISIT_BARBER_SHOP, 1);
 
    _player->SetStandState(0);                              // stand up
}

References _player, ACHIEVEMENT_CRITERIA_TYPE_GOLD_SPENT_AT_BARBER, ACHIEVEMENT_CRITERIA_TYPE_VISIT_BARBER_SHOP, GameObjectTemplate::barberChair, GameObjectTemplate::chairheight, WorldObject::FindNearestGameObjectOfType(), GAMEOBJECT_TYPE_BARBER_CHAIR, BarberShopStyleEntry::gender, Player::GetBarberShopCost(), Unit::getGender(), GameObject::GetGOInfo(), Unit::getRace(), Unit::getStandState(), BarberShopStyleEntry::hair_id, Player::HasEnoughMoney(), LOG_DEBUG, Player::ModifyMoney(), PLAYER_BYTES, PLAYER_BYTES_2, BarberShopStyleEntry::race, sBarberShopStyleStore, SendPacket(), Object::SetByteValue(), Unit::SetStandState(), SMSG_BARBER_SHOP_RESULT, BarberShopStyleEntry::type, UNIT_STAND_STATE_SIT_LOW_CHAIR, and Player::UpdateAchievementCriteria().

Referenced by OpcodeTable::Initialize().

◆ HandleAreaSpiritHealerQueryOpcode()

void WorldSession::HandleAreaSpiritHealerQueryOpcode ( WorldPacket & recvData )

{
    LOG_DEBUG("network", "WORLD: CMSG_AREA_SPIRIT_HEALER_QUERY");
 
    Battleground* bg = _player->GetBattleground();
 
    ObjectGuid guid;
    recv_data >> guid;
 
    Creature* unit = GetPlayer()->GetMap()->GetCreature(guid);
    if (!unit)
        return;
 
    if (!unit->IsSpiritService())                            // it's not spirit service
        return;
 
    if (bg)
        sBattlegroundMgr->SendAreaSpiritHealerQueryOpcode(_player, bg, guid);
 
    if (Battlefield* bf = sBattlefieldMgr->GetBattlefieldToZoneId(_player->GetZoneId()))
        bf->SendAreaSpiritHealerQueryOpcode(_player, guid);
}

References _player, Player::GetBattleground(), Map::GetCreature(), WorldObject::GetMap(), GetPlayer(), WorldObject::GetZoneId(), Unit::IsSpiritService(), LOG_DEBUG, sBattlefieldMgr, and sBattlegroundMgr.

Referenced by OpcodeTable::Initialize().

◆ HandleAreaSpiritHealerQueueOpcode()

void WorldSession::HandleAreaSpiritHealerQueueOpcode ( WorldPacket & recvData )

{
    LOG_DEBUG("network", "WORLD: CMSG_AREA_SPIRIT_HEALER_QUEUE");
 
    Battleground* bg = _player->GetBattleground();
 
    ObjectGuid guid;
    recv_data >> guid;
 
    Creature* unit = GetPlayer()->GetMap()->GetCreature(guid);
    if (!unit)
        return;
 
    if (!unit->IsSpiritService())                            // it's not spirit service
        return;
 
    if (bg)
        bg->AddPlayerToResurrectQueue(guid, _player->GetGUID());
 
    if (Battlefield* bf = sBattlefieldMgr->GetBattlefieldToZoneId(_player->GetZoneId()))
        bf->AddPlayerToResurrectQueue(guid, _player->GetGUID());
}

References _player, Battleground::AddPlayerToResurrectQueue(), Player::GetBattleground(), Map::GetCreature(), Object::GetGUID(), WorldObject::GetMap(), GetPlayer(), WorldObject::GetZoneId(), Unit::IsSpiritService(), LOG_DEBUG, and sBattlefieldMgr.

Referenced by OpcodeTable::Initialize().

◆ HandleAreaTriggerOpcode()

void WorldSession::HandleAreaTriggerOpcode ( WorldPacket & recvPacket )

{
    uint32 triggerId;
    recv_data >> triggerId;
 
    LOG_DEBUG("network", "CMSG_AREATRIGGER. Trigger ID: {}", triggerId);
 
    Player* player = GetPlayer();
    if (player->IsInFlight())
    {
        LOG_DEBUG("network", "HandleAreaTriggerOpcode: Player '{}' ({}) in flight, ignore Area Trigger ID:{}",
                       player->GetName(), player->GetGUID().ToString(), triggerId);
        return;
    }
 
    AreaTrigger const* atEntry = sObjectMgr->GetAreaTrigger(triggerId);
    if (!atEntry)
    {
        LOG_DEBUG("network", "HandleAreaTriggerOpcode: Player '{}' ({}) send unknown (by DBC) Area Trigger ID:{}",
                       player->GetName(), player->GetGUID().ToString(), triggerId);
        return;
    }
 
    uint32 teamFaction = player->GetTeamId(true) == TEAM_ALLIANCE ? FACTION_MASK_ALLIANCE : FACTION_MASK_HORDE;
    bool isTavernAreatrigger = sObjectMgr->IsTavernAreaTrigger(triggerId, teamFaction);
    if (!player->IsInAreaTriggerRadius(atEntry, isTavernAreatrigger ? 5.f : 0.f))
    {
        LOG_DEBUG("network", "HandleAreaTriggerOpcode: Player {} ({}) too far (trigger map: {} player map: {}), ignore Area Trigger ID: {}",
                       player->GetName(), player->GetGUID().ToString(), atEntry->map, player->GetMapId(), triggerId);
        return;
    }
 
    if (player->isDebugAreaTriggers)
        ChatHandler(this).PSendSysMessage(LANG_DEBUG_AREATRIGGER_REACHED, triggerId);
 
    if (sScriptMgr->OnAreaTrigger(player, atEntry))
        return;
 
    if (player->IsAlive())
        if (uint32 questId = sObjectMgr->GetQuestForAreaTrigger(triggerId))
            if (player->GetQuestStatus(questId) == QUEST_STATUS_INCOMPLETE)
                player->AreaExploredOrEventHappens(questId);
 
    if (isTavernAreatrigger)
    {
        // set resting flag we are in the inn
        player->SetRestFlag(REST_FLAG_IN_TAVERN, atEntry->entry);
 
        if (sWorld->IsFFAPvPRealm())
        {
            if (player->HasByteFlag(UNIT_FIELD_BYTES_2, 1, UNIT_BYTE2_FLAG_FFA_PVP))
            {
                player->RemoveByteFlag(UNIT_FIELD_BYTES_2, 1, UNIT_BYTE2_FLAG_FFA_PVP);
                sScriptMgr->OnFfaPvpStateUpdate(player, false);
 
            }
        }
        return;
    }
 
    if (Battleground* bg = player->GetBattleground())
        if (bg->GetStatus() == STATUS_IN_PROGRESS)
        {
            bg->HandleAreaTrigger(player, triggerId);
            return;
        }
 
    if (OutdoorPvP* pvp = player->GetOutdoorPvP())
        if (pvp->HandleAreaTrigger(_player, triggerId))
            return;
 
    AreaTriggerTeleport const* at = sObjectMgr->GetAreaTriggerTeleport(triggerId);
    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_NOT_IN_RAID:
                case Map::CANNOT_ENTER_INSTANCE_BIND_MISMATCH:
                case Map::CANNOT_ENTER_TOO_MANY_INSTANCES:
                case Map::CANNOT_ENTER_MAX_PLAYERS:
                case Map::CANNOT_ENTER_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->TeleportToEntryPoint();
    }
 
    if (!teleported)
        player->TeleportTo(at->target_mapId, at->target_X, at->target_Y, at->target_Z, at->target_Orientation, TELE_TO_NOT_LEAVE_TRANSPORT);
}

References _player, Player::AreaExploredOrEventHappens(), Map::CANNOT_ENTER_INSTANCE_BIND_MISMATCH, Map::CANNOT_ENTER_MAX_PLAYERS, Map::CANNOT_ENTER_NOT_IN_RAID, Map::CANNOT_ENTER_TOO_MANY_INSTANCES, Map::CANNOT_ENTER_ZONE_IN_COMBAT, AreaTrigger::entry, FACTION_MASK_ALLIANCE, FACTION_MASK_HORDE, Player::GetBattleground(), Player::GetCorpseLocation(), Player::GetGroup(), Object::GetGUID(), WorldObject::GetMap(), WorldLocation::GetMapId(), WorldObject::GetName(), Player::GetOutdoorPvP(), GetPlayer(), Player::GetQuestStatus(), Player::GetTeamId(), Object::HasByteFlag(), Player::HasCorpse(), Unit::IsAlive(), Player::isDebugAreaTriggers, Map::IsDungeon(), Player::IsInAreaTriggerRadius(), Unit::IsInFlight(), LANG_DEBUG_AREATRIGGER_REACHED, LOG_DEBUG, AreaTrigger::map, ChatHandler::PSendSysMessage(), QUEST_STATUS_INCOMPLETE, Object::RemoveByteFlag(), REST_FLAG_IN_TAVERN, Player::ResurrectPlayer(), Player::SetRestFlag(), sMapMgr, sObjectMgr, Player::SpawnCorpseBones(), sScriptMgr, STATUS_IN_PROGRESS, sWorld, AreaTriggerTeleport::target_mapId, AreaTriggerTeleport::target_Orientation, AreaTriggerTeleport::target_X, AreaTriggerTeleport::target_Y, AreaTriggerTeleport::target_Z, TEAM_ALLIANCE, TELE_TO_NOT_LEAVE_TRANSPORT, Player::TeleportTo(), Player::TeleportToEntryPoint(), ObjectGuid::ToString(), UNIT_BYTE2_FLAG_FFA_PVP, and UNIT_FIELD_BYTES_2.

Referenced by OpcodeTable::Initialize().

◆ HandleArenaTeamAcceptOpcode()

void WorldSession::HandleArenaTeamAcceptOpcode ( WorldPacket & recvData )

{
    LOG_DEBUG("network", "CMSG_ARENA_TEAM_ACCEPT");                // empty opcode
 
    ArenaTeam* arenaTeam = sArenaTeamMgr->GetArenaTeamById(_player->GetArenaTeamIdInvited());
    if (!arenaTeam)
        return;
 
    // Check if player is already in another team of the same size
    if (_player->GetArenaTeamId(arenaTeam->GetSlot()))
    {
        SendArenaTeamCommandResult(ERR_ARENA_TEAM_CREATE_S, "", "", ERR_ALREADY_IN_ARENA_TEAM);
        return;
    }
 
    // Only allow members of the other faction to join the team if cross faction interaction is enabled
    if (!sWorld->getBoolConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_GUILD) && _player->GetTeamId() != sCharacterCache->GetCharacterTeamByGuid(arenaTeam->GetCaptain()))
    {
        SendArenaTeamCommandResult(ERR_ARENA_TEAM_CREATE_S, "", "", ERR_ARENA_TEAM_NOT_ALLIED);
        return;
    }
 
    // Add player to team
    if (!arenaTeam->AddMember(_player->GetGUID()))
    {
        SendArenaTeamCommandResult(ERR_ARENA_TEAM_CREATE_S, "", "", ERR_ARENA_TEAM_INTERNAL);
        return;
    }
 
    // Broadcast event
    arenaTeam->BroadcastEvent(ERR_ARENA_TEAM_JOIN_SS, _player->GetGUID(), 2, _player->GetName().c_str(), arenaTeam->GetName(), "");
}

References _player, ArenaTeam::AddMember(), ArenaTeam::BroadcastEvent(), CONFIG_ALLOW_TWO_SIDE_INTERACTION_GUILD, ERR_ALREADY_IN_ARENA_TEAM, ERR_ARENA_TEAM_CREATE_S, ERR_ARENA_TEAM_INTERNAL, ERR_ARENA_TEAM_JOIN_SS, ERR_ARENA_TEAM_NOT_ALLIED, Player::GetArenaTeamId(), Player::GetArenaTeamIdInvited(), ArenaTeam::GetCaptain(), Object::GetGUID(), ArenaTeam::GetName(), WorldObject::GetName(), ArenaTeam::GetSlot(), Player::GetTeamId(), LOG_DEBUG, sArenaTeamMgr, sCharacterCache, SendArenaTeamCommandResult(), and sWorld.

Referenced by OpcodeTable::Initialize().

◆ HandleArenaTeamDeclineOpcode()

void WorldSession::HandleArenaTeamDeclineOpcode ( WorldPacket & recvData )

{
    LOG_DEBUG("network", "CMSG_ARENA_TEAM_DECLINE");               // empty opcode
 
    // Remove invite from player
    _player->SetArenaTeamIdInvited(0);
}

References _player, LOG_DEBUG, and Player::SetArenaTeamIdInvited().

Referenced by OpcodeTable::Initialize().

◆ HandleArenaTeamDisbandOpcode()

void WorldSession::HandleArenaTeamDisbandOpcode ( WorldPacket & recvData )

{
    LOG_DEBUG("network", "CMSG_ARENA_TEAM_DISBAND");
 
    uint32 arenaTeamId;
    recvData >> arenaTeamId;
 
    if (ArenaTeam* arenaTeam = sArenaTeamMgr->GetArenaTeamById(arenaTeamId))
    {
        // Only captain can disband the team
        if (arenaTeam->GetCaptain() != _player->GetGUID())
            return;
 
        // Teams cannot be disbanded during queues
        if (BattlegroundQueueTypeId bgQueue = BattlegroundMgr::BGQueueTypeId(BATTLEGROUND_AA, arenaTeam->GetType()))
        {
            GroupQueueInfo ginfo;
            BattlegroundQueue& queue = sBattlegroundMgr->GetBattlegroundQueue(bgQueue);
            if (queue.GetPlayerGroupInfoData(_player->GetGUID(), &ginfo))
                if (ginfo.IsInvitedToBGInstanceGUID)
                    return;
        }
 
        // Teams cannot be disbanded during fights
        if (arenaTeam->IsFighting())
            return;
 
        arenaTeam->Disband(this);
        delete arenaTeam;
    }
}

References _player, BATTLEGROUND_AA, BattlegroundMgr::BGQueueTypeId(), Object::GetGUID(), BattlegroundQueue::GetPlayerGroupInfoData(), GroupQueueInfo::IsInvitedToBGInstanceGUID, LOG_DEBUG, sArenaTeamMgr, and sBattlegroundMgr.

Referenced by OpcodeTable::Initialize().

◆ HandleArenaTeamInviteOpcode()

void WorldSession::HandleArenaTeamInviteOpcode ( WorldPacket & recvData )

{
    LOG_DEBUG("network", "CMSG_ARENA_TEAM_INVITE");
 
    uint32 arenaTeamId;                                     // arena team id
    std::string invitedName;
 
    Player* player = nullptr;
 
    recvData >> arenaTeamId >> invitedName;
 
    if (!invitedName.empty())
    {
        if (!normalizePlayerName(invitedName))
            return;
 
        player = ObjectAccessor::FindPlayerByName(invitedName, false);
    }
 
    if (!player)
    {
        SendArenaTeamCommandResult(ERR_ARENA_TEAM_CREATE_S, "", invitedName, ERR_ARENA_TEAM_PLAYER_NOT_FOUND_S);
        return;
    }
 
    if (player->GetLevel() < sWorld->getIntConfig(CONFIG_MAX_PLAYER_LEVEL))
    {
        SendArenaTeamCommandResult(ERR_ARENA_TEAM_CREATE_S, "", invitedName, ERR_ARENA_TEAM_TARGET_TOO_LOW_S);
        return;
    }
 
    ArenaTeam* arenaTeam = sArenaTeamMgr->GetArenaTeamById(arenaTeamId);
    if (!arenaTeam)
    {
        SendArenaTeamCommandResult(ERR_ARENA_TEAM_CREATE_S, "", "", ERR_ARENA_TEAM_PLAYER_NOT_IN_TEAM);
        return;
    }
 
    if (GetPlayer()->GetArenaTeamId(arenaTeam->GetSlot()) != arenaTeamId)
    {
        SendArenaTeamCommandResult(ERR_ARENA_TEAM_CREATE_S, "", "", ERR_ARENA_TEAM_PERMISSIONS);
        return;
    }
 
    // OK result but don't send invite
    if (player->GetSocial()->HasIgnore(GetPlayer()->GetGUID()))
        return;
 
    if (!sWorld->getBoolConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_GUILD) && player->GetTeamId() != GetPlayer()->GetTeamId())
    {
        SendArenaTeamCommandResult(ERR_ARENA_TEAM_INVITE_SS, "", "", ERR_ARENA_TEAM_NOT_ALLIED);
        return;
    }
 
    if (player->GetArenaTeamId(arenaTeam->GetSlot()))
    {
        SendArenaTeamCommandResult(ERR_ARENA_TEAM_INVITE_SS, "", invitedName, ERR_ALREADY_IN_ARENA_TEAM_S);
        return;
    }
 
    if (player->GetArenaTeamIdInvited())
    {
        SendArenaTeamCommandResult(ERR_ARENA_TEAM_INVITE_SS, "", invitedName, ERR_ALREADY_INVITED_TO_ARENA_TEAM_S);
        return;
    }
 
    if (arenaTeam->GetMembersSize() >= arenaTeam->GetType() * 2)
    {
        SendArenaTeamCommandResult(ERR_ARENA_TEAM_CREATE_S, arenaTeam->GetName(), "", ERR_ARENA_TEAM_TOO_MANY_MEMBERS_S);
        return;
    }
 
    LOG_DEBUG("bg.battleground", "Player {} Invited {} to Join his ArenaTeam", GetPlayer()->GetName(), invitedName);
 
    player->SetArenaTeamIdInvited(arenaTeam->GetId());
 
    WorldPacket data(SMSG_ARENA_TEAM_INVITE, (8 + 10));
    data << GetPlayer()->GetName();
    data << arenaTeam->GetName();
    player->GetSession()->SendPacket(&data);
 
    LOG_DEBUG("network", "WORLD: Sent SMSG_ARENA_TEAM_INVITE");
}

References CONFIG_ALLOW_TWO_SIDE_INTERACTION_GUILD, CONFIG_MAX_PLAYER_LEVEL, ERR_ALREADY_IN_ARENA_TEAM_S, ERR_ALREADY_INVITED_TO_ARENA_TEAM_S, ERR_ARENA_TEAM_CREATE_S, ERR_ARENA_TEAM_INVITE_SS, ERR_ARENA_TEAM_NOT_ALLIED, ERR_ARENA_TEAM_PERMISSIONS, ERR_ARENA_TEAM_PLAYER_NOT_FOUND_S, ERR_ARENA_TEAM_PLAYER_NOT_IN_TEAM, ERR_ARENA_TEAM_TARGET_TOO_LOW_S, ERR_ARENA_TEAM_TOO_MANY_MEMBERS_S, ObjectAccessor::FindPlayerByName(), Player::GetArenaTeamId(), Player::GetArenaTeamIdInvited(), ArenaTeam::GetId(), Unit::GetLevel(), ArenaTeam::GetMembersSize(), ArenaTeam::GetName(), WorldObject::GetName(), GetPlayer(), Player::GetSession(), ArenaTeam::GetSlot(), Player::GetSocial(), Player::GetTeamId(), GetTeamId(), ArenaTeam::GetType(), PlayerSocial::HasIgnore(), LOG_DEBUG, normalizePlayerName(), sArenaTeamMgr, SendArenaTeamCommandResult(), SendPacket(), Player::SetArenaTeamIdInvited(), SMSG_ARENA_TEAM_INVITE, and sWorld.

Referenced by OpcodeTable::Initialize().

◆ HandleArenaTeamLeaderOpcode()

void WorldSession::HandleArenaTeamLeaderOpcode ( WorldPacket & recvData )

{
    LOG_DEBUG("network", "CMSG_ARENA_TEAM_LEADER");
 
    uint32 arenaTeamId;
    std::string name;
 
    recvData >> arenaTeamId;
    recvData >> name;
 
    // Check for valid arena team
    ArenaTeam* arenaTeam = sArenaTeamMgr->GetArenaTeamById(arenaTeamId);
    if (!arenaTeam)
        return;
 
    // Only captain can pass leadership
    if (arenaTeam->GetCaptain() != _player->GetGUID())
    {
        SendArenaTeamCommandResult(ERR_ARENA_TEAM_CREATE_S, "", "", ERR_ARENA_TEAM_PERMISSIONS);
        return;
    }
 
    if (!normalizePlayerName(name))
        return;
 
    // Check if team member exists
    ArenaTeamMember* member = arenaTeam->GetMember(name);
    if (!member)
    {
        SendArenaTeamCommandResult(ERR_ARENA_TEAM_CREATE_S, "", name, ERR_ARENA_TEAM_PLAYER_NOT_FOUND_S);
        return;
    }
 
    // Check if the target is already team captain
    if (arenaTeam->GetCaptain() == member->Guid)
        return;
 
    arenaTeam->SetCaptain(member->Guid);
 
    // Broadcast event
    arenaTeam->BroadcastEvent(ERR_ARENA_TEAM_LEADER_CHANGED_SSS, ObjectGuid::Empty, 3, _player->GetName().c_str(), name, arenaTeam->GetName());
}

References _player, ArenaTeam::BroadcastEvent(), ObjectGuid::Empty, ERR_ARENA_TEAM_CREATE_S, ERR_ARENA_TEAM_LEADER_CHANGED_SSS, ERR_ARENA_TEAM_PERMISSIONS, ERR_ARENA_TEAM_PLAYER_NOT_FOUND_S, ArenaTeam::GetCaptain(), Object::GetGUID(), ArenaTeam::GetMember(), ArenaTeam::GetName(), WorldObject::GetName(), ArenaTeamMember::Guid, LOG_DEBUG, normalizePlayerName(), sArenaTeamMgr, SendArenaTeamCommandResult(), and ArenaTeam::SetCaptain().

Referenced by OpcodeTable::Initialize().

◆ HandleArenaTeamLeaveOpcode()

void WorldSession::HandleArenaTeamLeaveOpcode ( WorldPacket & recvData )

{
    LOG_DEBUG("network", "CMSG_ARENA_TEAM_LEAVE");
 
    uint32 arenaTeamId;
    recvData >> arenaTeamId;
 
    ArenaTeam* arenaTeam = sArenaTeamMgr->GetArenaTeamById(arenaTeamId);
    if (!arenaTeam)
        return;
 
    // Disallow leave team while in arena
    if (arenaTeam->IsFighting())
    {
        SendArenaTeamCommandResult(ERR_ARENA_TEAM_QUIT_S, "", "", ERR_ARENA_TEAMS_LOCKED);
        return;
    }
 
    // Team captain can't leave the team if other members are still present
    if (_player->GetGUID() == arenaTeam->GetCaptain() && arenaTeam->GetMembersSize() > 1)
    {
        SendArenaTeamCommandResult(ERR_ARENA_TEAM_QUIT_S, "", "", ERR_ARENA_TEAM_LEADER_LEAVE_S);
        return;
    }
 
    // Player cannot be removed during queues
    if (BattlegroundQueueTypeId bgQueue = BattlegroundMgr::BGQueueTypeId(BATTLEGROUND_AA, arenaTeam->GetType()))
    {
        GroupQueueInfo ginfo;
        BattlegroundQueue& queue = sBattlegroundMgr->GetBattlegroundQueue(bgQueue);
        if (queue.GetPlayerGroupInfoData(_player->GetGUID(), &ginfo))
        {
            if (ginfo.IsInvitedToBGInstanceGUID)
            {
                SendArenaTeamCommandResult(ERR_ARENA_TEAM_QUIT_S, "", "", ERR_ARENA_TEAMS_LOCKED);
                return;
            }
        }
    }
 
    // If team consists only of the captain, disband the team
    if (_player->GetGUID() == arenaTeam->GetCaptain())
    {
        arenaTeam->Disband(this);
        delete arenaTeam;
        return;
    }
    else
        arenaTeam->DelMember(_player->GetGUID(), true);
 
    // Broadcast event
    arenaTeam->BroadcastEvent(ERR_ARENA_TEAM_LEAVE_SS, _player->GetGUID(), 2, _player->GetName().c_str(), arenaTeam->GetName(), "");
 
    // Inform player who left
    SendArenaTeamCommandResult(ERR_ARENA_TEAM_QUIT_S, arenaTeam->GetName(), "", 0);
}

References _player, BATTLEGROUND_AA, BattlegroundMgr::BGQueueTypeId(), ArenaTeam::BroadcastEvent(), ArenaTeam::DelMember(), ArenaTeam::Disband(), ERR_ARENA_TEAM_LEADER_LEAVE_S, ERR_ARENA_TEAM_LEAVE_SS, ERR_ARENA_TEAM_QUIT_S, ERR_ARENA_TEAMS_LOCKED, ArenaTeam::GetCaptain(), Object::GetGUID(), ArenaTeam::GetMembersSize(), ArenaTeam::GetName(), WorldObject::GetName(), BattlegroundQueue::GetPlayerGroupInfoData(), ArenaTeam::GetType(), ArenaTeam::IsFighting(), GroupQueueInfo::IsInvitedToBGInstanceGUID, LOG_DEBUG, sArenaTeamMgr, sBattlegroundMgr, and SendArenaTeamCommandResult().

Referenced by OpcodeTable::Initialize().

◆ HandleArenaTeamQueryOpcode()

void WorldSession::HandleArenaTeamQueryOpcode ( WorldPacket & recvData )

{
    LOG_DEBUG("network", "WORLD: Received CMSG_ARENA_TEAM_QUERY");
 
    uint32 arenaTeamId;
    recvData >> arenaTeamId;
 
    if (ArenaTeam* arenaTeam = sArenaTeamMgr->GetArenaTeamById(arenaTeamId))
    {
        arenaTeam->Query(this);
        arenaTeam->SendStats(this);
    }
}

References LOG_DEBUG, and sArenaTeamMgr.

Referenced by OpcodeTable::Initialize().

◆ HandleArenaTeamRemoveOpcode()

void WorldSession::HandleArenaTeamRemoveOpcode ( WorldPacket & recvData )

{
    LOG_DEBUG("network", "CMSG_ARENA_TEAM_REMOVE");
 
    uint32 arenaTeamId;
    std::string name;
 
    recvData >> arenaTeamId;
    recvData >> name;
 
    // Check for valid arena team
    ArenaTeam* arenaTeam = sArenaTeamMgr->GetArenaTeamById(arenaTeamId);
    if (!arenaTeam)
        return;
 
    // Only captain can remove members
    if (arenaTeam->GetCaptain() != _player->GetGUID())
    {
        SendArenaTeamCommandResult(ERR_ARENA_TEAM_CREATE_S, "", "", ERR_ARENA_TEAM_PERMISSIONS);
        return;
    }
 
    if (!normalizePlayerName(name))
        return;
 
    // Check if team member exists
    ArenaTeamMember* member = arenaTeam->GetMember(name);
    if (!member)
    {
        SendArenaTeamCommandResult(ERR_ARENA_TEAM_CREATE_S, "", name, ERR_ARENA_TEAM_PLAYER_NOT_FOUND_S);
        return;
    }
 
    // Captain cannot be removed
    if (arenaTeam->GetCaptain() == member->Guid)
    {
        SendArenaTeamCommandResult(ERR_ARENA_TEAM_QUIT_S, "", "", ERR_ARENA_TEAM_LEADER_LEAVE_S);
        return;
    }
 
    // Team member cannot be removed during queues
    if (BattlegroundQueueTypeId bgQueue = BattlegroundMgr::BGQueueTypeId(BATTLEGROUND_AA, arenaTeam->GetType()))
    {
        GroupQueueInfo ginfo;
        BattlegroundQueue& queue = sBattlegroundMgr->GetBattlegroundQueue(bgQueue);
        if (queue.GetPlayerGroupInfoData(_player->GetGUID(), &ginfo))
        {
            if (ginfo.IsInvitedToBGInstanceGUID)
            {
                SendArenaTeamCommandResult(ERR_ARENA_TEAM_QUIT_S, "", "", ERR_ARENA_TEAMS_LOCKED);
                return;
            }
        }
    }
 
    // Player cannot be removed during fights
    if (arenaTeam->IsFighting())
        return;
 
    arenaTeam->DelMember(member->Guid, true);
 
    // Broadcast event
    arenaTeam->BroadcastEvent(ERR_ARENA_TEAM_REMOVE_SSS, ObjectGuid::Empty, 3, name, arenaTeam->GetName(), _player->GetName());
}

References _player, BATTLEGROUND_AA, BattlegroundMgr::BGQueueTypeId(), ArenaTeam::BroadcastEvent(), ArenaTeam::DelMember(), ObjectGuid::Empty, ERR_ARENA_TEAM_CREATE_S, ERR_ARENA_TEAM_LEADER_LEAVE_S, ERR_ARENA_TEAM_PERMISSIONS, ERR_ARENA_TEAM_PLAYER_NOT_FOUND_S, ERR_ARENA_TEAM_QUIT_S, ERR_ARENA_TEAM_REMOVE_SSS, ERR_ARENA_TEAMS_LOCKED, ArenaTeam::GetCaptain(), Object::GetGUID(), ArenaTeam::GetMember(), ArenaTeam::GetName(), WorldObject::GetName(), BattlegroundQueue::GetPlayerGroupInfoData(), ArenaTeam::GetType(), ArenaTeamMember::Guid, ArenaTeam::IsFighting(), GroupQueueInfo::IsInvitedToBGInstanceGUID, LOG_DEBUG, normalizePlayerName(), sArenaTeamMgr, sBattlegroundMgr, and SendArenaTeamCommandResult().

Referenced by OpcodeTable::Initialize().

◆ HandleArenaTeamRosterOpcode()

void WorldSession::HandleArenaTeamRosterOpcode ( WorldPacket & recvData )

{
    LOG_DEBUG("network", "WORLD: Received CMSG_ARENA_TEAM_ROSTER");
 
    uint32 arenaTeamId;                                     // arena team id
    recvData >> arenaTeamId;
 
    if (ArenaTeam* arenaTeam = sArenaTeamMgr->GetArenaTeamById(arenaTeamId))
        arenaTeam->Roster(this);
}

References LOG_DEBUG, and sArenaTeamMgr.

Referenced by OpcodeTable::Initialize().

◆ HandleAttackStopOpcode()

void WorldSession::HandleAttackStopOpcode ( WorldPacket & recvPacket )

{
    GetPlayer()->AttackStop();
}

References Unit::AttackStop(), and GetPlayer().

Referenced by OpcodeTable::Initialize().

◆ HandleAttackSwingOpcode()

void WorldSession::HandleAttackSwingOpcode ( WorldPacket & recvPacket )

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.

{
    ObjectGuid guid;
    recvData >> guid;
 
    LOG_DEBUG("network", "WORLD: Recvd CMSG_ATTACKSWING: {}", guid.ToString());
 
    Unit* pEnemy = ObjectAccessor::GetUnit(*_player, guid);
 
    if (!pEnemy)
    {
        // stop attack state at client
        SendAttackStop(nullptr);
        return;
    }
 
    if (!_player->IsValidAttackTarget(pEnemy))
    {
        // stop attack state at client
        SendAttackStop(pEnemy);
        return;
    }
 
    if (Vehicle* vehicle = _player->GetVehicle())
    {
        VehicleSeatEntry const* seat = vehicle->GetSeatForPassenger(_player);
        ASSERT(seat);
        if (!(seat->m_flags & VEHICLE_SEAT_FLAG_CAN_ATTACK))
        {
            SendAttackStop(pEnemy);
            return;
        }
    }
 
    _player->Attack(pEnemy, true);
}

References _player, ASSERT, Unit::Attack(), ObjectAccessor::GetUnit(), Unit::GetVehicle(), Unit::IsValidAttackTarget(), LOG_DEBUG, VehicleSeatEntry::m_flags, SendAttackStop(), ObjectGuid::ToString(), and VEHICLE_SEAT_FLAG_CAN_ATTACK.

Referenced by OpcodeTable::Initialize().

◆ HandleAuctionHelloOpcode()

void WorldSession::HandleAuctionHelloOpcode ( WorldPacket & recvPacket )

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

References Player::GetNPCIfCanInteractWith(), GetPlayer(), LOG_DEBUG, Unit::RemoveAurasByType(), SendAuctionHello(), SPELL_AURA_FEIGN_DEATH, ObjectGuid::ToString(), UNIT_NPC_FLAG_AUCTIONEER, and UNIT_STATE_DIED.

Referenced by OpcodeTable::Initialize().

◆ HandleAuctionListBidderItems()

void WorldSession::HandleAuctionListBidderItems ( WorldPacket & recvData )

{
    LOG_DEBUG("network", "WORLD: Received CMSG_AUCTION_LIST_BIDDER_ITEMS");
 
    ObjectGuid guid;                                            //NPC guid
    uint32 listfrom;                                        //page of auctions
    uint32 outbiddedCount;                                  //count of outbidded auctions
 
    recvData >> guid;
    recvData >> listfrom;                                  // not used in fact (this list not have page control in client)
    recvData >> outbiddedCount;
    if (recvData.size() != (16 + outbiddedCount * 4))
    {
        LOG_ERROR("network.opcode", "Client sent bad opcode!!! with count: {} and size : {} (must be: {})", outbiddedCount, (unsigned long)recvData.size(), (16 + outbiddedCount * 4));
        outbiddedCount = 0;
    }
 
    Creature* creature = GetPlayer()->GetNPCIfCanInteractWith(guid, UNIT_NPC_FLAG_AUCTIONEER);
    if (!creature)
    {
        LOG_DEBUG("network", "WORLD: HandleAuctionListBidderItems - Unit ({}) not found or you can't interact with him.", guid.ToString());
        recvData.rfinish();
        return;
    }
 
    // remove fake death
    if (GetPlayer()->HasUnitState(UNIT_STATE_DIED))
        GetPlayer()->RemoveAurasByType(SPELL_AURA_FEIGN_DEATH);
 
    AuctionHouseObject* auctionHouse = sAuctionMgr->GetAuctionsMap(creature->GetFaction());
 
    WorldPacket data(SMSG_AUCTION_BIDDER_LIST_RESULT, (4 + 4 + 4) + 30000); // pussywizard: ensure there is enough memory
    Player* player = GetPlayer();
    data << (uint32) 0;                                     //add 0 as count
    uint32 count = 0;
    uint32 totalcount = 0;
    while (outbiddedCount > 0)                             //add all data, which client requires
    {
        --outbiddedCount;
        uint32 outbiddedAuctionId;
        recvData >> outbiddedAuctionId;
        AuctionEntry* auction = auctionHouse->GetAuction(outbiddedAuctionId);
        if (auction && auction->BuildAuctionInfo(data))
        {
            ++totalcount;
            ++count;
        }
    }
 
    auctionHouse->BuildListBidderItems(data, player, count, totalcount);
    data.put<uint32>(0, count);                           // add count to placeholder
    data << totalcount;
    data << (uint32)300;                                    //unk 2.3.0
    SendPacket(&data);
}

References AuctionEntry::BuildAuctionInfo(), AuctionHouseObject::BuildListBidderItems(), AuctionHouseObject::GetAuction(), Unit::GetFaction(), Player::GetNPCIfCanInteractWith(), GetPlayer(), LOG_DEBUG, LOG_ERROR, ByteBuffer::put(), Unit::RemoveAurasByType(), ByteBuffer::rfinish(), sAuctionMgr, SendPacket(), ByteBuffer::size(), SMSG_AUCTION_BIDDER_LIST_RESULT, SPELL_AURA_FEIGN_DEATH, ObjectGuid::ToString(), UNIT_NPC_FLAG_AUCTIONEER, and UNIT_STATE_DIED.

Referenced by OpcodeTable::Initialize().

◆ HandleAuctionListItems()

void WorldSession::HandleAuctionListItems ( WorldPacket & recvData )

{
    LOG_DEBUG("network", "WORLD: Received CMSG_AUCTION_LIST_ITEMS");
 
    std::string searchedname;
    uint8 levelmin, levelmax, usable;
    uint32 listfrom, auctionSlotID, auctionMainCategory, auctionSubCategory, quality;
    ObjectGuid guid;
 
    recvData >> guid;
    recvData >> listfrom;                                  // start, used for page control listing by 50 elements
    recvData >> searchedname;
 
    recvData >> levelmin >> levelmax;
    recvData >> auctionSlotID >> auctionMainCategory >> auctionSubCategory;
    recvData >> quality >> usable;
 
    //recvData.read_skip<uint8>(); // pussywizard: this is the getAll option
    uint8 getAll;
    recvData >> getAll;
 
    // Read sort block
    uint8 sortOrderCount;
    recvData >> sortOrderCount;
    AuctionSortOrderVector sortOrder;
    for (uint8 i = 0; i < sortOrderCount; i++)
    {
        uint8 sortMode;
        uint8 isDesc;
        recvData >> sortMode;
        recvData >> isDesc;
        AuctionSortInfo sortInfo;
        sortInfo.isDesc = (isDesc == 1);
        sortInfo.sortOrder = static_cast<AuctionSortOrder>(sortMode);
        sortOrder.push_back(std::move(sortInfo));
    }
 
    // remove fake death
    if (_player->HasUnitState(UNIT_STATE_DIED))
    {
        _player->RemoveAurasByType(SPELL_AURA_FEIGN_DEATH);
    }
 
    // pussywizard:
    const uint32 delay = 2000;
    const uint32 now = GameTime::GetGameTimeMS().count();
    uint32 diff = getMSTimeDiff(_lastAuctionListItemsMSTime, now);
    if (diff > delay)
    {
        diff = delay;
    }
    _lastAuctionListItemsMSTime = now + delay - diff;
    std::lock_guard<std::mutex> guard(AsyncAuctionListingMgr::GetTempLock());
    AsyncAuctionListingMgr::GetTempList().push_back(AuctionListItemsDelayEvent(delay - diff, _player->GetGUID(), guid, searchedname, listfrom, levelmin, levelmax, usable, auctionSlotID,
        auctionMainCategory, auctionSubCategory, quality, getAll, sortOrder));
}

References _lastAuctionListItemsMSTime, _player, GameTime::GetGameTimeMS(), Object::GetGUID(), getMSTimeDiff(), AsyncAuctionListingMgr::GetTempList(), AsyncAuctionListingMgr::GetTempLock(), Unit::HasUnitState(), AuctionSortInfo::isDesc, LOG_DEBUG, Unit::RemoveAurasByType(), AuctionSortInfo::sortOrder, SPELL_AURA_FEIGN_DEATH, and UNIT_STATE_DIED.

Referenced by OpcodeTable::Initialize().

◆ HandleAuctionListOwnerItems()

void WorldSession::HandleAuctionListOwnerItems ( WorldPacket & recvData )

{
    // prevent crash caused by malformed packet
    ObjectGuid guid;
    uint32 listfrom;
 
    recvData >> guid;
    recvData >> listfrom;       // not used in fact (this list does not have page control in client)
 
    // pussywizard:
    const uint32 delay = 4500;
    const uint32 now = GameTime::GetGameTimeMS().count();
    if (_lastAuctionListOwnerItemsMSTime > now) // list is pending
        return;
    uint32 diff = getMSTimeDiff(_lastAuctionListOwnerItemsMSTime, now);
    if (diff > delay)
        diff = delay;
 
    _lastAuctionListOwnerItemsMSTime = now + delay; // set longest possible here, actual exectuing will change this to getMSTime of that moment
    _player->m_Events.AddEvent(new AuctionListOwnerItemsDelayEvent(guid, _player->GetGUID(), true), _player->m_Events.CalculateTime(delay - diff));
}

References _lastAuctionListOwnerItemsMSTime, _player, EventProcessor::AddEvent(), EventProcessor::CalculateTime(), GameTime::GetGameTimeMS(), Object::GetGUID(), getMSTimeDiff(), and Unit::m_Events.

Referenced by OpcodeTable::Initialize().

◆ HandleAuctionListOwnerItemsEvent()

void WorldSession::HandleAuctionListOwnerItemsEvent ( ObjectGuid creatureGuid )

{
    LOG_DEBUG("network", "WORLD: Received CMSG_AUCTION_LIST_OWNER_ITEMS");
 
    _lastAuctionListOwnerItemsMSTime = GameTime::GetGameTimeMS().count(); // pussywizard
 
    Creature* creature = GetPlayer()->GetNPCIfCanInteractWith(creatureGuid, UNIT_NPC_FLAG_AUCTIONEER);
    if (!creature)
    {
        LOG_DEBUG("network", "WORLD: HandleAuctionListOwnerItems - Unit ({}) not found or you can't interact with him.", creatureGuid.ToString());
        return;
    }
 
    // remove fake death
    if (GetPlayer()->HasUnitState(UNIT_STATE_DIED))
        GetPlayer()->RemoveAurasByType(SPELL_AURA_FEIGN_DEATH);
 
    AuctionHouseObject* auctionHouse = sAuctionMgr->GetAuctionsMap(creature->GetFaction());
 
    WorldPacket data(SMSG_AUCTION_OWNER_LIST_RESULT, (4 + 4 + 4) + 60000); // pussywizard: ensure there is enough memory
    data << (uint32) 0;                                     // amount place holder
 
    uint32 count = 0;
    uint32 totalcount = 0;
 
    auctionHouse->BuildListOwnerItems(data, _player, count, totalcount);
    data.put<uint32>(0, count);
    data << (uint32) totalcount;
    data << (uint32) 0;
    SendPacket(&data);
}

References _lastAuctionListOwnerItemsMSTime, _player, AuctionHouseObject::BuildListOwnerItems(), Unit::GetFaction(), GameTime::GetGameTimeMS(), Player::GetNPCIfCanInteractWith(), GetPlayer(), LOG_DEBUG, ByteBuffer::put(), Unit::RemoveAurasByType(), sAuctionMgr, SendPacket(), SMSG_AUCTION_OWNER_LIST_RESULT, SPELL_AURA_FEIGN_DEATH, ObjectGuid::ToString(), UNIT_NPC_FLAG_AUCTIONEER, and UNIT_STATE_DIED.

◆ HandleAuctionListPendingSales()

void WorldSession::HandleAuctionListPendingSales ( WorldPacket & recvData )

{
    LOG_DEBUG("network", "WORLD: Received CMSG_AUCTION_LIST_PENDING_SALES");
 
    recvData.read_skip<uint64>();
 
    uint32 count = 0;
 
    WorldPacket data(SMSG_AUCTION_LIST_PENDING_SALES, 4);
    data << uint32(count);                                  // count
    /*for (uint32 i = 0; i < count; ++i)
    {
        data << "";                                         // string
        data << "";                                         // string
        data << uint32(0);
        data << uint32(0);
        data << float(0);
    }*/
    SendPacket(&data);
}

References LOG_DEBUG, ByteBuffer::read_skip(), SendPacket(), and SMSG_AUCTION_LIST_PENDING_SALES.

Referenced by OpcodeTable::Initialize().

◆ HandleAuctionPlaceBid()

void WorldSession::HandleAuctionPlaceBid ( WorldPacket & recvData )

{
    LOG_DEBUG("network", "WORLD: Received CMSG_AUCTION_PLACE_BID");
 
    ObjectGuid auctioneer;
    uint32 auctionId;
    uint32 price;
    recvData >> auctioneer;
    recvData >> auctionId >> price;
 
    if (!auctionId || !price)
        return;                                             //check for cheaters
 
    Creature* creature = GetPlayer()->GetNPCIfCanInteractWith(auctioneer, UNIT_NPC_FLAG_AUCTIONEER);
    if (!creature)
    {
        LOG_DEBUG("network", "WORLD: HandleAuctionPlaceBid - Unit ({}) not found or you can't interact with him.", auctioneer.ToString());
        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(auctionId);
    Player* player = GetPlayer();
 
    if (!auction || auction->owner == player->GetGUID())
    {
        //you cannot bid your own auction:
        SendAuctionCommandResult(0, AUCTION_PLACE_BID, ERR_AUCTION_BID_OWN);
        return;
    }
 
    // impossible have online own another character (use this for speedup check in case online owner)
    Player* auction_owner = ObjectAccessor::FindConnectedPlayer(auction->owner);
    if (!auction_owner && sCharacterCache->GetCharacterAccountIdByGuid(auction->owner) == GetAccountId())
    {
        //you cannot bid your another character auction:
        SendAuctionCommandResult(0, AUCTION_PLACE_BID, ERR_AUCTION_BID_OWN);
        return;
    }
 
    // cheating
    if (price <= auction->bid || price < auction->startbid)
        return;
 
    // price too low for next bid if not buyout
    if ((price < auction->buyout || auction->buyout == 0) &&
            price < auction->bid + auction->GetAuctionOutBid())
    {
        //auction has already higher bid, client tests it!
        return;
    }
 
    if (!player->HasEnoughMoney(price))
    {
        //you don't have enought money!, client tests!
        //SendAuctionCommandResult(auction->auctionId, AUCTION_PLACE_BID, ???);
        return;
    }
 
    CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
 
    if (price < auction->buyout || auction->buyout == 0)
    {
        if (auction->bidder)
        {
            if (auction->bidder == player->GetGUID())
                player->ModifyMoney(-int32(price - auction->bid));
            else
            {
                // mail to last bidder and return money
                sAuctionMgr->SendAuctionOutbiddedMail(auction, price, GetPlayer(), trans);
                player->ModifyMoney(-int32(price));
            }
        }
        else
            player->ModifyMoney(-int32(price));
 
        auction->bidder = player->GetGUID();
        auction->bid = price;
        GetPlayer()->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_AUCTION_BID, price);
 
        CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_AUCTION_BID);
        stmt->SetData(0, auction->bidder.GetCounter());
        stmt->SetData(1, auction->bid);
        stmt->SetData(2, auction->Id);
        trans->Append(stmt);
 
        SendAuctionCommandResult(auction->Id, AUCTION_PLACE_BID, ERR_AUCTION_OK, 0);
    }
    else
    {
        //buyout:
        if (player->GetGUID() == auction->bidder)
            player->ModifyMoney(-int32(auction->buyout - auction->bid));
        else
        {
            player->ModifyMoney(-int32(auction->buyout));
            if (auction->bidder)                          //buyout for bidded auction ..
                sAuctionMgr->SendAuctionOutbiddedMail(auction, auction->buyout, GetPlayer(), trans);
        }
        auction->bidder = player->GetGUID();
        auction->bid = auction->buyout;
        GetPlayer()->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_AUCTION_BID, auction->buyout);
 
        //- Mails must be under transaction control too to prevent data loss
        sAuctionMgr->SendAuctionSalePendingMail(auction, trans);
        sAuctionMgr->SendAuctionSuccessfulMail(auction, trans);
        sAuctionMgr->SendAuctionWonMail(auction, trans);
        sScriptMgr->OnAuctionSuccessful(auctionHouse, auction);
 
        SendAuctionCommandResult(auction->Id, AUCTION_PLACE_BID, ERR_AUCTION_OK);
 
        auction->DeleteFromDB(trans);
 
        sAuctionMgr->RemoveAItem(auction->item_guid);
        auctionHouse->RemoveAuction(auction);
    }
    player->SaveInventoryAndGoldToDB(trans);
    CharacterDatabase.CommitTransaction(trans);
}

References ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_AUCTION_BID, AUCTION_PLACE_BID, AuctionEntry::bid, AuctionEntry::bidder, AuctionEntry::buyout, CHAR_UPD_AUCTION_BID, CharacterDatabase, AuctionEntry::DeleteFromDB(), ERR_AUCTION_BID_OWN, ERR_AUCTION_OK, ObjectAccessor::FindConnectedPlayer(), GetAccountId(), AuctionHouseObject::GetAuction(), AuctionEntry::GetAuctionOutBid(), ObjectGuid::GetCounter(), Unit::GetFaction(), Object::GetGUID(), Player::GetNPCIfCanInteractWith(), GetPlayer(), Player::HasEnoughMoney(), AuctionEntry::Id, AuctionEntry::item_guid, LOG_DEBUG, Player::ModifyMoney(), AuctionEntry::owner, AuctionHouseObject::RemoveAuction(), Unit::RemoveAurasByType(), sAuctionMgr, Player::SaveInventoryAndGoldToDB(), sCharacterCache, SendAuctionCommandResult(), PreparedStatementBase::SetData(), SPELL_AURA_FEIGN_DEATH, sScriptMgr, ObjectGuid::ToString(), UNIT_NPC_FLAG_AUCTIONEER, UNIT_STATE_DIED, and Player::UpdateAchievementCriteria().

Referenced by OpcodeTable::Initialize().

◆ HandleAuctionRemoveItem()

void WorldSession::HandleAuctionRemoveItem ( WorldPacket & recvData )

{
    LOG_DEBUG("network", "WORLD: Received CMSG_AUCTION_REMOVE_ITEM");
 
    ObjectGuid auctioneer;
    uint32 auctionId;
    recvData >> auctioneer;
    recvData >> auctionId;
 
    Creature* creature = GetPlayer()->GetNPCIfCanInteractWith(auctioneer, UNIT_NPC_FLAG_AUCTIONEER);
    if (!creature)
    {
        LOG_DEBUG("network", "WORLD: HandleAuctionRemoveItem - Unit ({}) not found or you can't interact with him.", auctioneer.ToString());
        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(auctionId);
    Player* player = GetPlayer();
 
    CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
    if (auction && auction->owner == player->GetGUID())
    {
        Item* pItem = sAuctionMgr->GetAItem(auction->item_guid);
        if (pItem)
        {
            if (auction->bidder)                        // If we have a bidder, we have to send him the money he paid
            {
                uint32 auctionCut = auction->GetAuctionCut();
                if (!player->HasEnoughMoney(auctionCut))          //player doesn't have enough money, maybe message needed
                    return;
                //some auctionBidderNotification would be needed, but don't know that parts..
                sAuctionMgr->SendAuctionCancelledToBidderMail(auction, trans);
                player->ModifyMoney(-int32(auctionCut));
            }
 
            // item will deleted or added to received mail list
            MailDraft(auction->BuildAuctionMailSubject(AUCTION_CANCELED), AuctionEntry::BuildAuctionMailBody(ObjectGuid::Empty, 0, auction->buyout, auction->deposit))
            .AddItem(pItem)
            .SendMailTo(trans, player, auction, MAIL_CHECK_MASK_COPIED);
        }
        else
        {
            LOG_ERROR("network.opcode", "Auction id: {} has non-existed item (item: {})!!!", auction->Id, auction->item_guid.ToString());
            SendAuctionCommandResult(0, AUCTION_CANCEL, ERR_AUCTION_DATABASE_ERROR);
            return;
        }
    }
    else
    {
        SendAuctionCommandResult(0, AUCTION_CANCEL, ERR_AUCTION_DATABASE_ERROR);
        //this code isn't possible ... maybe there should be assert
        LOG_ERROR("network.opcode", "CHEATER : {}, he tried to cancel auction (id: {}) of another player, or auction is nullptr", player->GetGUID().ToString(), auctionId);
        return;
    }
 
    //inform player, that auction is removed
    SendAuctionCommandResult(auction->Id, AUCTION_CANCEL, ERR_AUCTION_OK);
 
    // Now remove the auction
 
    player->SaveInventoryAndGoldToDB(trans);
    auction->DeleteFromDB(trans);
    CharacterDatabase.CommitTransaction(trans);
 
    sAuctionMgr->RemoveAItem(auction->item_guid);
    auctionHouse->RemoveAuction(auction);
}

References MailDraft::AddItem(), AUCTION_CANCEL, AUCTION_CANCELED, AuctionEntry::bidder, AuctionEntry::BuildAuctionMailBody(), AuctionEntry::BuildAuctionMailSubject(), AuctionEntry::buyout, CharacterDatabase, AuctionEntry::DeleteFromDB(), AuctionEntry::deposit, ObjectGuid::Empty, ERR_AUCTION_DATABASE_ERROR, ERR_AUCTION_OK, AuctionHouseObject::GetAuction(), AuctionEntry::GetAuctionCut(), Unit::GetFaction(), Object::GetGUID(), Player::GetNPCIfCanInteractWith(), GetPlayer(), Player::HasEnoughMoney(), AuctionEntry::Id, AuctionEntry::item_guid, LOG_DEBUG, LOG_ERROR, MAIL_CHECK_MASK_COPIED, Player::ModifyMoney(), AuctionEntry::owner, AuctionHouseObject::RemoveAuction(), Unit::RemoveAurasByType(), sAuctionMgr, Player::SaveInventoryAndGoldToDB(), SendAuctionCommandResult(), MailDraft::SendMailTo(), SPELL_AURA_FEIGN_DEATH, ObjectGuid::ToString(), UNIT_NPC_FLAG_AUCTIONEER, and UNIT_STATE_DIED.

Referenced by OpcodeTable::Initialize().

◆ HandleAuctionSellItem()

void WorldSession::HandleAuctionSellItem ( WorldPacket & recvData )

{
    ObjectGuid auctioneer;
    uint32 itemsCount, etime, bid, buyout;
    recvData >> auctioneer;
    recvData >> itemsCount;
 
    ObjectGuid itemGUIDs[MAX_AUCTION_ITEMS]; // 160 slot = 4x 36 slot bag + backpack 16 slot
    uint32 count[MAX_AUCTION_ITEMS];
    memset(count, 0, sizeof(count));
 
    if (itemsCount > MAX_AUCTION_ITEMS)
    {
        SendAuctionCommandResult(0, AUCTION_SELL_ITEM, ERR_AUCTION_DATABASE_ERROR);
        recvData.rfinish();
        return;
    }
 
    for (uint32 i = 0; i < itemsCount; ++i)
    {
        recvData >> itemGUIDs[i];
        recvData >> count[i];
 
        if (!itemGUIDs[i] || !count[i] || count[i] > 1000)
        {
            recvData.rfinish();
            return;
        }
    }
 
    recvData >> bid;
    recvData >> buyout;
    recvData >> etime;
 
    if (!bid || !etime)
        return;
 
    if (bid > MAX_MONEY_AMOUNT || buyout > MAX_MONEY_AMOUNT)
    {
        LOG_DEBUG("network", "WORLD: HandleAuctionSellItem - Player {} ({}) attempted to sell item with higher price than max gold amount.",
            _player->GetName(), _player->GetGUID().ToString());
        SendAuctionCommandResult(0, AUCTION_SELL_ITEM, ERR_AUCTION_DATABASE_ERROR);
        return;
    }
 
    Creature* creature = GetPlayer()->GetNPCIfCanInteractWith(auctioneer, UNIT_NPC_FLAG_AUCTIONEER);
    if (!creature)
    {
        LOG_DEBUG("network", "WORLD: HandleAuctionSellItem - Unit ({}) not found or you can't interact with him.", auctioneer.ToString());
        return;
    }
 
    AuctionHouseEntry const* auctionHouseEntry = AuctionHouseMgr::GetAuctionHouseEntry(creature->GetFaction());
    if (!auctionHouseEntry)
    {
        LOG_DEBUG("network", "WORLD: HandleAuctionSellItem - Unit ({}) has wrong faction.", auctioneer.ToString());
        return;
    }
 
    etime *= MINUTE;
 
    switch (etime)
    {
        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);
 
    Item* items[MAX_AUCTION_ITEMS];
 
    uint32 finalCount = 0;
    uint32 itemEntry = 0;
 
    for (uint32 i = 0; i < itemsCount; ++i)
    {
        Item* item = _player->GetItemByGuid(itemGUIDs[i]);
 
        if (!item)
        {
            SendAuctionCommandResult(0, AUCTION_SELL_ITEM, ERR_AUCTION_ITEM_NOT_FOUND);
            return;
        }
 
        if (itemEntry == 0)
            itemEntry = item->GetTemplate()->ItemId;
 
        if (sAuctionMgr->GetAItem(item->GetGUID()) || !item->CanBeTraded() || item->IsNotEmptyBag() ||
                item->GetTemplate()->Flags & ITEM_FLAG_CONJURED || item->GetUInt32Value(ITEM_FIELD_DURATION) ||
                item->GetCount() < count[i] || itemEntry != item->GetTemplate()->ItemId)
        {
            SendAuctionCommandResult(0, AUCTION_SELL_ITEM, ERR_AUCTION_DATABASE_ERROR);
            return;
        }
 
        items[i] = item;
        finalCount += count[i];
    }
 
    if (!finalCount)
    {
        SendAuctionCommandResult(0, 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 < itemsCount - 1; ++i)
    {
        for (uint32 j = i + 1; j < itemsCount; ++j)
        {
            if (itemGUIDs[i] == itemGUIDs[j])
            {
                SendAuctionCommandResult(0, AUCTION_SELL_ITEM, ERR_AUCTION_DATABASE_ERROR);
                return;
            }
        }
    }
 
    for (uint32 i = 0; i < itemsCount; ++i)
    {
        Item* item = items[i];
 
        if (item->GetMaxStackCount() < finalCount)
        {
            SendAuctionCommandResult(0, AUCTION_SELL_ITEM, ERR_AUCTION_DATABASE_ERROR);
            return;
        }
    }
 
    for (uint32 i = 0; i < itemsCount; ++i)
    {
        Item* item = items[i];
 
        uint32 auctionTime = uint32(etime * sWorld->getRate(RATE_AUCTION_TIME));
        AuctionHouseObject* auctionHouse = 

Classes

Public Member Functions

Public Attributes

Protected Attributes

Private Types

Private Member Functions

Private Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ AddonsList

Constructor & Destructor Documentation

◆ WorldSession() [1/2]

◆ ~WorldSession()

◆ WorldSession() [2/2]

Member Function Documentation

◆ AddQueryHolderCallback()

◆ AddTransactionCallback()

◆ BuildPartyMemberStatsChangedPacket()

◆ CanOpenMailBox()

◆ CanSkipQueue()

◆ CanUseBank()

◆ CheckStableMaster()

◆ ComputeNewClockDelta()

◆ DisallowHyperlinksAndMaybeKick()

◆ DoLootRelease()

◆ Expansion()

◆ GetAccountData()

◆ GetAccountId()

◆ GetAcoreString()

◆ GetCalendarEventCreationCooldown()

◆ GetCurrentVendor()

◆ GetGuidLow()

◆ GetLatency()

◆ GetOfflineTime()

◆ GetPlayer()

◆ GetPlayerInfo()

◆ GetPlayerName()

◆ GetQueryProcessor()

◆ GetRecruiterId()

◆ GetRemoteAddress()

◆ GetSecurity()

◆ GetSessionDbcLocale()

◆ GetSessionDbLocaleIndex()

◆ GetTotalTime()

◆ GetTutorialInt()

◆ GetWarden()

◆ Handle_Deprecated()

◆ Handle_EarlyProccess()

◆ Handle_NULL()

◆ Handle_ServerSide()

◆ HandleAcceptGrantLevel()

◆ HandleAcceptTradeOpcode()

◆ HandleActivateTaxiExpressOpcode()

◆ HandleActivateTaxiOpcode()

◆ HandleAddFriendOpcode()

◆ HandleAddIgnoreOpcode()

◆ HandleAlterAppearance()

◆ HandleAreaSpiritHealerQueryOpcode()

◆ HandleAreaSpiritHealerQueueOpcode()

◆ HandleAreaTriggerOpcode()

◆ HandleArenaTeamAcceptOpcode()

◆ HandleArenaTeamDeclineOpcode()

◆ HandleArenaTeamDisbandOpcode()

◆ HandleArenaTeamInviteOpcode()

◆ HandleArenaTeamLeaderOpcode()

◆ HandleArenaTeamLeaveOpcode()

◆ HandleArenaTeamQueryOpcode()

◆ HandleArenaTeamRemoveOpcode()

◆ HandleArenaTeamRosterOpcode()

◆ HandleAttackStopOpcode()

◆ HandleAttackSwingOpcode()

◆ HandleAuctionHelloOpcode()

◆ HandleAuctionListBidderItems()

◆ HandleAuctionListItems()

◆ HandleAuctionListOwnerItems()

◆ HandleAuctionListOwnerItemsEvent()

◆ HandleAuctionListPendingSales()

◆ HandleAuctionPlaceBid()

◆ HandleAuctionRemoveItem()