_world_session_8h_source.html

/*

* This file is part of Project SkyFire https://www.projectskyfire.org.

* See LICENSE.md file for Copyright information

*/


#ifndef __WORLDSESSION_H

#define __WORLDSESSION_H


#include "AccountMgr.h"

#include "Authentication/AuthDefines.h"

#include "AddonMgr.h"

#include <atomic>

#include "Common.h"

#include "DatabaseEnv.h"

#include "Object.h"

#include "Opcodes.h"

#include "SharedDefines.h"

#include "World.h"

#include "WorldPacket.h"


class Creature;

class CharacterBooster;

class GameObject;

class InstanceSave;

class Item;

class LoginQueryHolder;

class Object;

class Player;

class Quest;

class SpellCastTargets;

class Unit;

class Warden;

class WorldPacket;

class WorldSocket;

struct AreaTableEntry;

struct AuctionEntry;

struct DeclinedName;

struct ItemTemplate;

struct MovementInfo;


namespace lfg

{

    struct LfgJoinResultData;

    struct LfgPlayerBoot;

    struct LfgProposal;

    struct LfgQueueStatusData;

    struct LfgPlayerRewardData;

    struct LfgRoleCheck;

    struct LfgUpdateData;

}


namespace rbac

{

    class RBACData;

}


enum class AccountDataType

{

    GLOBAL_CONFIG_CACHE = 0,                    // 0x01 g

    PER_CHARACTER_CONFIG_CACHE = 1,                    // 0x02 p

    GLOBAL_BINDINGS_CACHE = 2,                    // 0x04 g

    PER_CHARACTER_BINDINGS_CACHE = 3,                    // 0x08 p

    GLOBAL_MACROS_CACHE = 4,                    // 0x10 g

    PER_CHARACTER_MACROS_CACHE = 5,                    // 0x20 p

    PER_CHARACTER_LAYOUT_CACHE = 6,                    // 0x40 p

    PER_CHARACTER_CHAT_CACHE = 7,                    // 0x80 p

    NUM_ACCOUNT_DATA_TYPES = 8

};


#define GLOBAL_CACHE_MASK           0x15

#define PER_CHARACTER_CACHE_MASK    0xEA


#define REGISTERED_ADDON_PREFIX_SOFTCAP 64


struct AccountData

{

    AccountData() : Time(0), Data("") { }


    time_t Time;

    std::string Data;

};


enum class PartyOperation

{

    PARTY_OP_INVITE = 0,

    PARTY_OP_UNINVITE = 1,

    PARTY_OP_LEAVE = 2,

    PARTY_OP_SWAP = 4

};


enum BFLeaveReason

{

    BF_LEAVE_REASON_CLOSE = 0x00000001,

    //BF_LEAVE_REASON_UNK1      = 0x00000002, (not used)

    //BF_LEAVE_REASON_UNK2      = 0x00000004, (not used)

    BF_LEAVE_REASON_EXITED = 0x00000008,

    BF_LEAVE_REASON_LOW_LEVEL = 0x00000010

};


enum ChatRestrictionType

{

    ERR_CHAT_RESTRICTED = 0,

    ERR_CHAT_THROTTLED = 1,

    ERR_USER_SQUELCHED = 2,

    ERR_YELL_RESTRICTED = 3

};


enum class BarberShopResult

{

    BARBER_SHOP_SUCCESS = 0,

    BARBER_SHOP_NOT_ENOUGH_MONEY = 1,

    BARBER_SHOP_NOT_SITTING = 2

    /*BARBER_SHOP_NOT_ENOUGH_MONEY = 3*/

};


#define DB2_REPLY_BATTLE_PET_ABILITY              3416538071

#define DB2_REPLY_BATTLE_PET_ABILITY_EFFECT       3716901134

#define DB2_REPLY_BATTLE_PET_ABILITY_STATE        1012231747

#define DB2_REPLY_BATTLE_PET_ABILITY_TURN         3973639388

#define DB2_REPLY_BATTLE_PET_BREED_QUALITY        458903206

#define DB2_REPLY_BATTLE_PET_BREED_STATE          1794847238

#define DB2_REPLY_BATTLE_PET_EFFECT_PROPERTIES    1672791226

#define DB2_REPLY_BATTLE_PET_NPC_TEAM_MEMBER      4060454394

#define DB2_REPLY_BATTLE_PET_SPECIES              1821637041

#define DB2_REPLY_BATTLE_PET_SPECIES_STATE        366509520

#define DB2_REPLY_BATTLE_PET_SPECIESX_ABILITY     1143173908

#define DB2_REPLY_BATTLE_PET_STATE                2403627824

#define DB2_REPLY_BATTLE_PET_VISUAL               3282955075

#define DB2_REPLY_BROADCAST_TEXT                  35137211

#define DB2_REPLY_CREATURE                        3386291891

#define DB2_REPLY_CREATURE_DIFFICULTY             3386943305

#define DB2_REPLY_CURVE                           1272569722

#define DB2_REPLY_CURVE_POINT                     1880017466

#define DB2_REPLY_DEVICE_BLACKLIST                983446676

#define DB2_REPLY_DRIVER_BLACKLIST                1326512502

#define DB2_REPLY_GAMEOBJECTS                     331613093

#define DB2_REPLY_ITEM                            1344507586

#define DB2_REPLY_ITEM_SPARSE                     2442913102

#define DB2_REPLY_ITEM_CURRENCY_COST              1876974313

#define DB2_REPLY_ITEM_EXTENDED_COST              3146089301

#define DB2_REPLY_ITEM_TO_BATTLE_PET              1563357608

#define DB2_REPLY_ITEM_TO_MOUNT_SPELL             1440631488

#define DB2_REPLY_ITEM_UPGRADE                    1879459387

#define DB2_REPLY_KEYCHAIN                        1837770388

#define DB2_REPLY_LOCALE                          1065724855

#define DB2_REPLY_LOCATION                        961296167

#define DB2_REPLY_MAP_CHALLENGE_MODE              943410215

#define DB2_REPLY_MARKETING_PROMOTIONS_X_LOCALE   2715021741

#define DB2_REPLY_PATH                            2499044245

#define DB2_REPLY_PATH_NODE                       1000230050

#define DB2_REPLY_PATH_NODE_PROPERTY              4263624740

#define DB2_REPLY_PATH_PROPERTY                   149245792

#define DB2_REPLY_QUEST_PACKAGE_ITEM              3425666288

#define DB2_REPLY_RULE_SET_ITEM_UPGRADE           1840711788

#define DB2_REPLY_RULE_SET_RAID_LOOT_UPGRADE      3978279757

#define DB2_REPLY_SCENE_SCRIPT                    3568395212

#define DB2_REPLY_SCENE_SCRIPT_PACKAGE            3905641993

#define DB2_REPLY_SCENE_SCRIPT_PACKAGE_MEMBER     3830298396

#define DB2_REPLY_SPELL_EFFECT_CAMERA_SHAKES      1939361897

#define DB2_REPLY_SPELL_MISSILE                   1754233351

#define DB2_REPLY_SPELL_MISSILE_MOTION            930182777

#define DB2_REPLY_SPELL_REAGENTS                  2875640223

#define DB2_REPLY_SPELL_VISUAL                    4146370265

#define DB2_REPLY_SPELL_VISUAL_EFFECT_NAME        48336690

#define DB2_REPLY_SPELL_VISUAL_KIT                4102286043

#define DB2_REPLY_SPELLVISUALKITAREAMODEL         22642299461

#define DB2_REPLY_SPELL_VISUAL_KIT_MODEL_ATTACH   4033975491

#define DB2_REPLY_SPELL_VISUAL_MISSILE            1369604944

#define DB2_REPLY_VIGNETTE                        4021368146

#define DB2_REPLY_WB_ACCESS_CONTROL_LIST          1477136115

#define DB2_REPLY_WB_CERT_BLACKLIST               3450573023

#define DB2_REPLY_WB_CERT_WHITELIST               2287306173

#define DB2_REPLY_WB_PERMISSIONS                  4163366139


//class to deal with packet processing

//allows to determine if next packet is safe to be processed


class PacketFilter

{

public:

    explicit PacketFilter(WorldSession* pSession) : m_pSession(pSession) { }

    virtual ~PacketFilter() { }


    virtual bool Process(WorldPacket* /*packet*/) { return true; }

    virtual bool ProcessLogout() const { return true; }

    static uint16 DropHighBytes(uint16 opcode) { return opcode & NUM_OPCODE_HANDLERS; }


protected:

    WorldSession* const m_pSession;


private:

    PacketFilter(PacketFilter const& right) = delete;

    PacketFilter& operator=(PacketFilter const& right) = delete;

};


//process only thread-safe packets in Map::Update()


class MapSessionFilter : public PacketFilter

{

public:

    explicit MapSessionFilter(WorldSession* pSession) : PacketFilter(pSession) { }

    ~MapSessionFilter() { }


    virtual bool Process(WorldPacket* packet);

    //in Map::Update() we do not process player logout!

    virtual bool ProcessLogout() const { return false; }

};


//class used to filer only thread-unsafe packets from queue

//in order to update only be used in World::UpdateSessions()


class WorldSessionFilter : public PacketFilter

{

public:

    explicit WorldSessionFilter(WorldSession* pSession) : PacketFilter(pSession) { }

    ~WorldSessionFilter() { }


    virtual bool Process(WorldPacket* packet);

};


// Proxy structure to contain data passed to callback function,

// only to prevent bloating the parameter list


class CharacterCreateInfo

{

    friend class WorldSession;

    friend class Player;


protected:


    CharacterCreateInfo(std::string const& name, uint8 race, uint8 cclass, uint8 gender, uint8 skin, uint8 face, uint8 hairStyle, uint8 hairColor, uint8 facialHair, uint8 outfitId,

        WorldPacket& data) : Name(name), Race(race), Class(cclass), Gender(gender), Skin(skin), Face(face), HairStyle(hairStyle), HairColor(hairColor), FacialHair(facialHair),

        OutfitId(outfitId), Data(data), CharCount(0)

    { }


    std::string Name;

    uint8 Race;

    uint8 Class;

    uint8 Gender;

    uint8 Skin;

    uint8 Face;

    uint8 HairStyle;

    uint8 HairColor;

    uint8 FacialHair;

    uint8 OutfitId;

    WorldPacket Data;


    uint8 CharCount;

};


class WorldSession

{

public:

    WorldSession(uint32 id, WorldSocket* sock, AccountTypes sec, uint8 expansion, time_t mute_time, LocaleConstant locale, uint32 recruiter, bool isARecruiter, bool hasBoost);

    ~WorldSession();


    bool PlayerLoading() const { return m_playerLoading; }

    bool PlayerLogout() const { return m_playerLogout; }

    bool PlayerLogoutWithSave() const { return m_playerLogout && m_playerSave; }

    bool PlayerRecentlyLoggedOut() const { return m_playerRecentlyLogout; }

    bool PlayerDisconnected() const { return !m_Socket; }


    void ReadAddonsInfo(WorldPacket& data);

    void SendAddonsInfo();

    void SendTimezoneInformation();

    bool IsAddonRegistered(const std::string& prefix) const;


    void SendPacket(WorldPacket const* packet, bool forced = false);

    void LogPacketMarker(std::string const& marker);

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

    void SendNotification(uint32 string_id, ...);

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

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

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

    void SendQueryTimeResponse();

    void SendGroupInviteNotification(const std::string& inviterName, const std::string& realmName, bool inGroup);

    void SendRolePollInform(ObjectGuid guid, uint8 Index);


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

    void SendClientCacheVersion(uint32 version);

    void SendFeatureSystemStatusGlueScreen();


    rbac::RBACData* GetRBACData();

    bool HasPermission(uint32 permissionId);

    void LoadPermissions();

    void InvalidateRBACData(); // Used to force LoadPermissions at next HasPermission check


    void SetVirtualRealmID(uint32 VRealmID) { m_virtualRealmID = VRealmID; }

    uint32 GetVirtualRealmID() const { return m_virtualRealmID; }


    AccountTypes GetSecurity() const { return _security; }

    uint32 GetAccountId() const { return _accountId; }

    Player* GetPlayer() const { return _player; }

    std::string const& GetPlayerName() const;

    std::string GetPlayerInfo() const;


    uint32 GetGuidLow() const;

    void SetSecurity(AccountTypes security) { _security = security; }

    std::string const& GetRemoteAddress() { return m_Address; }

    void SetPlayer(Player* player);

    uint8 Expansion() const { return m_expansion; }


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


    void SetInQueue(bool state) { m_inQueue = state; }


    bool isLogingOut() const { return _logoutTime || m_playerLogout; }


    void LogoutRequest(time_t requestTime)

    {

        _logoutTime = requestTime;

    }


    bool ShouldLogOut(time_t currTime) const

    {

        return (_logoutTime > 0 && currTime >= _logoutTime + 20);

    }


    void LogoutPlayer(bool save);

    void KickPlayer();


    void QueuePacket(WorldPacket* new_packet);

    bool Update(uint32 diff, PacketFilter& updater);


    void SendAuthWaitQue(uint32 position);


    // petition query

    void HandlePetitionQueryOpcode(WorldPacket& recvData);

    void SendPetitionQueryOpcode(uint64 petitionguid);


    // name query

    void HandleNameQueryOpcode(WorldPacket& recvPacket);

    void SendNameQueryOpcode(ObjectGuid guid);


    // pet name query

    void HandlePetNameQuery(WorldPacket& recvData);

    void SendPetNameQuery(ObjectGuid guid, uint64 petNumber);


    // realmname query

    void HandleRealmNameQueryOpcode(WorldPacket& recvPacket);

    void SendRealmNameQueryOpcode(uint32 realmId);


    // TODO: trainer hello

    void HandleTrainerListOpcode(WorldPacket& recvPacket);

    void SendTrainerList(uint64 guid);

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


    // vendor hello

    void HandleListInventoryOpcode(WorldPacket& recvPacket);

    void SendListInventory(uint64 guid);


    // bank hello

    void HandleBankerActivateOpcode(WorldPacket& recvPacket);

    void SendShowBank(ObjectGuid guid);


    // TODO: tabard hello. client message run away?

    void SendTabardVendorActivate(uint64 guid);


    // spirithealer hello

    void HandleSpiritHealerActivateOpcode(WorldPacket& recvPacket);

    void SendSpiritResurrect();


    // binder hello

    void HandleBinderActivateOpcode(WorldPacket& recvPacket);

    void SendBindPoint(Creature* npc);


    // auctioneer hello

    void HandleAuctionHelloOpcode(WorldPacket& recvPacket);

    void SendAuctionHello(ObjectGuid guid, Creature* unit);


    // Battlemaster hello

    void HandleBattlemasterHelloOpcode(WorldPacket& recvData);

    void SendBattleGroundList(uint64 guid, BattlegroundTypeId bgTypeId = BattlegroundTypeId::BATTLEGROUND_RB);


    // petitioneer hello

    void HandlePetitionShowListOpcode(WorldPacket& recvPacket);

    void SendPetitionShowList(uint64 guid);


    // TODO: attack meele? - sphinx ?

    void HandleAttackSwingOpcode(WorldPacket& recvPacket);

    void SendAttackStop(Unit const* enemy);

    void HandleAttackStopOpcode(WorldPacket& recvPacket);

    void HandlePetStopAttack(WorldPacket& recvData);


    // TODO: trade

    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 SendTradeStatus(TradeStatus status);

    void SendUpdateTrade(bool trader_data = true);

    void SendCancelTrade(TradeStatus status);


    // Totem

    void SendTotemCreated(ObjectGuid TotemGUID, uint32 Duration, uint32 SpellID, uint8 Slot);


    // TODO: Spell mod cd, used in the core only by Shaman T10 Elemental 2P Bonus and Player::ModifySpellCooldown however ModifySpellCooldown is deadcode...

    void SendModifyCooldown(ObjectGuid UnitGUID, int32 DeltaTime, int32 SpellID);


    // TODO: currently implemented as some kind of block for HandlePetCastSpellOpcode? #burnit!

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


    // TODO: Pet stable

    void HandleRequestStabledPetsOpcode(WorldPacket& recvPacket);

    void HandleStablePet(WorldPacket& recvPacket);

    void HandleStablePetCallback(PreparedQueryResult result);

    void HandleUnstablePet(WorldPacket& recvPacket);

    void HandleUnstablePetCallback(PreparedQueryResult result, uint32 petId);

    void HandleBuyStableSlot(WorldPacket& recvPacket);

    void HandleStableRevivePet(WorldPacket& recvPacket);

    void HandleStableSwapPet(WorldPacket& recvPacket);

    void HandleStableSwapPetCallback(PreparedQueryResult result, uint32 petId);

    void SendStablePet(uint64 guid);

    void SendStablePetCallback(PreparedQueryResult result, uint64 guid);

    void SendStableResult(uint8 guid);

    bool CheckStableMaster(uint64 guid);


    // Account Data

    AccountData* GetAccountData(AccountDataType type) { return &m_accountData[uint8(type)]; }

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

    void SendAccountDataTimes(uint32 mask);

    void LoadGlobalAccountData();

    void LoadAccountData(PreparedQueryResult result, uint32 mask);


    void LoadTutorialsData();

    void SendTutorialsData();

    void SaveTutorialsData(SQLTransaction& trans);

    uint32 GetTutorialInt(uint8 index) const { return m_Tutorials[index]; }


    void SetTutorialInt(uint8 index, uint32 value)

    {

        if (m_Tutorials[index] != value)

        {

            m_Tutorials[index] = value;

            m_TutorialsChanged = true;

        }

    }


    // TODO: auction

    void HandleAuctionListItems(WorldPacket& recvData);

    void HandleAuctionListBidderItems(WorldPacket& recvData);

    void HandleAuctionSellItem(WorldPacket& recvData);

    void HandleAuctionRemoveItem(WorldPacket& recvData);

    void HandleAuctionListOwnerItems(WorldPacket& recvData);

    void HandleAuctionPlaceBid(WorldPacket& recvData);

    void HandleAuctionListPendingSales(WorldPacket& recvData);

    void SendAuctionCommandResult(AuctionEntry* auction, uint32 Action, uint32 ErrorCode, uint32 bidError = 0);

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

    void SendAuctionOwnerNotification(AuctionEntry* auction);

    void SendAuctionRemovedNotification(uint32 auctionId, uint32 itemEntry, int32 randomPropertyId);


    //Item Enchantment

    void SendEnchantmentLog(uint64 target, uint64 caster, uint64 itemGuid, uint32 itemId, uint32 enchantId, uint32 enchantmentSlot);

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


    //Taxi status

    void HandleTaxiNodeStatusQueryOpcode(WorldPacket& recvPacket);

    void SendTaxiStatus(uint64 guid);


    //TODO: Taxi

    void HandleTaxiQueryAvailableNodes(WorldPacket& recvPacket);

    void SendTaxiMenu(Creature* unit);

    void HandleMoveSplineDoneOpcode(WorldPacket& recvPacket);

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

    bool SendLearnNewTaxiNode(Creature* unit);

    void SendDiscoverNewTaxiNode(uint32 nodeid);

    void SendActivateTaxiReply(ActivateTaxiReply reply);

    void HandleActivateTaxiOpcode(WorldPacket& recvPacket);

    void HandleActivateTaxiExpressOpcode(WorldPacket& recvPacket);


    void BuildPartyMemberStatsChangedPacket(Player* player, WorldPacket* data);


    void DoLootRelease(uint64 lguid);


    // Account mute time

    time_t m_muteTime;


    // Locales

    LocaleConstant GetSessionDbcLocale() const { return m_sessionDbcLocale; }

    LocaleConstant GetSessionDbLocaleIndex() const { return m_sessionDbLocaleIndex; }

    const char* GetSkyFireString(int32 entry) const;


    uint32 GetLatency() const { return m_latency; }

    void SetLatency(uint32 latency) { m_latency = latency; }

    void ResetClientTimeDelay() { m_clientTimeDelay = 0; }

    uint32 getDialogStatus(Player* player, Object* questgiver, uint32 defstatus);


    std::atomic<time_t> m_timeOutTime;


    void UpdateTimeOutTime(uint32 diff)

    {

        if (time_t(diff) > m_timeOutTime)

            m_timeOutTime = 0;

        else

            m_timeOutTime -= diff;

    }


    void ResetTimeOutTime() { m_timeOutTime = sWorld->getIntConfig(WorldIntConfigs::CONFIG_SOCKET_TIMEOUTTIME); }

    bool IsConnectionIdle() const { return (m_timeOutTime <= 0 && !m_inQueue); }


    // Recruit-A-Friend Handling

    uint32 GetRecruiterId() const { return recruiterId; }

    bool IsARecruiter() const { return isRecruiter; }


    // Boost

    bool HasBoost() const { return m_hasBoost; }

    void SetBoosting(bool boost, bool saveToDB = true);


    z_stream_s* GetCompressionStream() { return _compressionStream; }


public:                                                 // opcodes handlers

    void Handle_NULL(WorldPacket& recvPacket);          // not used

    void Handle_EarlyProccess(WorldPacket& recvPacket); // just mark packets processed in WorldSocket::OnRead

    void Handle_EarlyProccessContinued(WorldPacket& recvPacket); //Found in sniffs

    void Handle_Deprecated(WorldPacket& recvPacket) const;    // never used anymore by client

    void SendCharacterLoginFailed(ResponseCodes reason);


    void HandleCharEnumOpcode(WorldPacket& recvPacket);

    void HandleCharDeleteOpcode(WorldPacket& recvPacket);

    void HandleCharCreateOpcode(WorldPacket& recvPacket);

    void HandleCharCreateCallback(PreparedQueryResult result, CharacterCreateInfo* createInfo);

    void HandlePlayerLoginOpcode(WorldPacket& recvPacket);

    void HandleLoadScreenOpcode(WorldPacket& recvPacket);

    void HandleCharEnum(PreparedQueryResult result);

    void HandlePlayerLogin(LoginQueryHolder* holder);

    void HandleCharFactionOrRaceChange(WorldPacket& recvData);

    void HandleRandomizeCharNameOpcode(WorldPacket& recvData);

    void HandleReorderCharacters(WorldPacket& recvData);

    void HandleOpeningCinematic(WorldPacket& recvData);


    // played time

    void HandlePlayedTime(WorldPacket& recvPacket);


    // Boost

    void SendBattlePayDistributionUpdate(uint64 playerGuid, int8 bonusId, int32 bonusFlag, int32 textId, std::string const& bonusText, std::string const& bonusText2);

    void HandleBattleCharBoost(WorldPacket& recvPacket);


    // new

    void HandleMoveUnRootAck(WorldPacket& recvPacket);

    void HandleMoveRootAck(WorldPacket& recvPacket);

    void HandleMoveGravityAck(WorldPacket& recvData);

    void HandleReturnToGraveyard(WorldPacket& recvPacket);


    // new inspect

    void HandleInspectOpcode(WorldPacket& recvPacket);


    // new party stats

    void HandleInspectHonorStatsOpcode(WorldPacket& recvPacket);


    void HandleMoveWaterWalkAck(WorldPacket& recvPacket);

    void HandleFeatherFallAck(WorldPacket& recvData);


    void HandleMoveHoverAck(WorldPacket& recvData);


    void HandleMountSpecialAnimOpcode(WorldPacket& recvdata);


    // character view

    void HandleShowingHelmOpcode(WorldPacket& recvData);

    void HandleShowingCloakOpcode(WorldPacket& recvData);


    // repair

    void HandleRepairItemOpcode(WorldPacket& recvPacket);


    // Knockback

    void HandleMoveKnockBackAck(WorldPacket& recvPacket);


    void HandleMoveTeleportAck(WorldPacket& recvPacket);

    void HandleForceSpeedChangeAck(WorldPacket& recvData);

    void HandleSetCollisionHeightAck(WorldPacket& recvPacket);

    void HandleMovementForceAck(WorldPacket& recvPacket);

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

    void HandlePlayerLogoutOpcode(WorldPacket& recvPacket);

    void HandleLogoutCancelOpcode(WorldPacket& recvPacket);

    void HandleChangeCurrencyFlags(WorldPacket& recvPacket);


    // GM Ticket opcodes

    void HandleGMTicketCreateOpcode(WorldPacket& recvPacket);

    void HandleGMTicketUpdateOpcode(WorldPacket& recvPacket);

    void HandleGMTicketDeleteOpcode(WorldPacket& recvPacket);

    void HandleGMTicketGetTicketOpcode(WorldPacket& recvPacket);

    void HandleGMTicketSystemStatusOpcode(WorldPacket& recvPacket);

    void HandleGMTicketCaseStatusOpcode(WorldPacket& recvPacket);

    void HandleGMSurveySubmit(WorldPacket& recvPacket);

    void HandleReportLag(WorldPacket& recvPacket);

    void HandleGMResponseResolve(WorldPacket& recvPacket);


    // FeedBackSystem

    void HandleSubmitBugOpcode(WorldPacket& recvPacket);

    void HandleSubmitSuggestOpcode(WorldPacket& recvPacket);


    void HandleTogglePvP(WorldPacket& recvPacket);

    void HandleSetPvP(WorldPacket& recvPacket);


    void HandleZoneUpdateOpcode(WorldPacket& recvPacket);

    void HandleSetSelectionOpcode(WorldPacket& recvPacket);

    void HandleStandStateChangeOpcode(WorldPacket& recvPacket);

    void HandleEmoteOpcode(WorldPacket& recvPacket);

    void HandleContactListOpcode(WorldPacket& recvPacket);

    void HandleAddFriendOpcode(WorldPacket& recvPacket);

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

    void HandleDelFriendOpcode(WorldPacket& recvPacket);

    void HandleAddIgnoreOpcode(WorldPacket& recvPacket);

    void HandleAddIgnoreOpcodeCallBack(PreparedQueryResult result);

    void HandleDelIgnoreOpcode(WorldPacket& recvPacket);

    void HandleSetContactNotesOpcode(WorldPacket& recvPacket);

    void HandleBugOpcode(WorldPacket& recvPacket);


    void HandleAreaTriggerOpcode(WorldPacket& recvPacket);


    void HandleSetFactionAtWar(WorldPacket& recvData);

    void HandleSetFactionNotAtWar(WorldPacket& recvData);

    void HandleSetFactionCheat(WorldPacket& recvData);

    void HandleSetLfgBonusFactionID(WorldPacket& recvData);

    void HandleSetWatchedFactionOpcode(WorldPacket& recvData);

    void HandleSetFactionInactiveOpcode(WorldPacket& recvData);

    void HandleRequestForcedReactionsOpcode(WorldPacket& recvData);


    void HandleUpdateAccountData(WorldPacket& recvPacket);

    void HandleRequestAccountData(WorldPacket& recvPacket);

    void HandleSetActionButtonOpcode(WorldPacket& recvPacket);


    void HandleGameObjectUseOpcode(WorldPacket& recPacket);

    void HandleGameobjectReportUse(WorldPacket& recvPacket);


    void HandleQueryTimeOpcode(WorldPacket& recvPacket);


    void HandleCreatureQueryOpcode(WorldPacket& recvPacket);


    void HandleGameObjectQueryOpcode(WorldPacket& recvPacket);


    void HandleMoveWorldportAckOpcode(WorldPacket& recvPacket);

    void HandleMoveWorldportAckOpcode();                // for server-side calls


    void HandleMovementOpcodes(WorldPacket& recvPacket);

    void HandleSetActiveMoverOpcode(WorldPacket& recvData);

    void HandleMoveNotActiveMover(WorldPacket& recvData);

    void HandleDismissControlledVehicle(WorldPacket& recvData);

    void HandleRequestVehicleExit(WorldPacket& recvData);

    void HandleMoveSetVehicleRecAck(WorldPacket& recvData);

    void HandleChangeSeatsOnControlledVehicle(WorldPacket& recvData);

    void HandleMoveTimeSkippedOpcode(WorldPacket& recvData);


    void HandleRequestRaidInfoOpcode(WorldPacket& recvData);


    void HandleBattlefieldStatusOpcode(WorldPacket& recvData);


    void HandleGroupInviteOpcode(WorldPacket& recvPacket);

    void HandleGroupInviteResponseOpcode(WorldPacket& recvPacket);

    void HandleGroupUninviteGuidOpcode(WorldPacket& recvPacket);

    void HandleGroupSetLeaderOpcode(WorldPacket& recvPacket);

    void HandleGroupSetRolesOpcode(WorldPacket& recvData);

    void HandleGroupDisbandOpcode(WorldPacket& recvPacket);

    void HandleOptOutOfLootOpcode(WorldPacket& recvData);

    void HandleLootMethodOpcode(WorldPacket& recvPacket);

    void HandleLootRoll(WorldPacket& recvData);

    void HandleRequestPartyMemberStatsOpcode(WorldPacket& recvData);

    void HandleRaidTargetUpdateOpcode(WorldPacket& recvData);

    void HandleRaidReadyCheckOpcode(WorldPacket& recvData);

    void HandleRaidReadyCheckConfirmOpcode(WorldPacket& recvData);

    void HandleRaidReadyCheckFinishedOpcode(WorldPacket& recvData);

    void HandleGroupRaidConvertOpcode(WorldPacket& recvData);

    void HandleGroupChangeSubGroupOpcode(WorldPacket& recvData);

    void HandleGroupSwapSubGroupOpcode(WorldPacket& recvData);

    void HandleGroupAssistantLeaderOpcode(WorldPacket& recvData);

    void HandleGroupEveryoneIsAssistantOpcode(WorldPacket& recvData);

    void HandleSetPartyAssignmentOpcode(WorldPacket& recvData);

    void HandleGroupInitiatePollRole(WorldPacket& recvData);


    void HandlePetitionBuyOpcode(WorldPacket& recvData);

    void HandlePetitionShowSignOpcode(WorldPacket& recvData);

    void HandlePetitionRenameOpcode(WorldPacket& recvData);

    void HandlePetitionSignOpcode(WorldPacket& recvData);

    void HandlePetitionDeclineOpcode(WorldPacket& recvData);

    void HandleOfferPetitionOpcode(WorldPacket& recvData);

    void HandleTurnInPetitionOpcode(WorldPacket& recvData);

    void SendPetitionSignResults(ObjectGuid petitionGuid, ObjectGuid playerGuid, uint8 result);


    void HandleGuildQueryOpcode(WorldPacket& recvPacket);

    void HandleGuildInviteOpcode(WorldPacket& recvPacket);

    void HandleGuildRemoveOpcode(WorldPacket& recvPacket);

    void HandleGuildAcceptOpcode(WorldPacket& recvPacket);

    void HandleGuildDeclineOpcode(WorldPacket& recvPacket);

    void HandleGuildEventLogQueryOpcode(WorldPacket& recvPacket);

    void HandleGuildRosterOpcode(WorldPacket& recvPacket);

    void HandleGuildRewardsQueryOpcode(WorldPacket& recvPacket);

    void HandleGuildPromoteOpcode(WorldPacket& recvPacket);

    void HandleGuildDemoteOpcode(WorldPacket& recvPacket);

    void HandleGuildAssignRankOpcode(WorldPacket& recvPacket);

    void HandleGuildLeaveOpcode(WorldPacket& recvPacket);

    void HandleGuildDisbandOpcode(WorldPacket& recvPacket);

    void HandleGuildSetGuildMaster(WorldPacket& recvPacket);

    void HandleGuildReplaceGuildMaster(WorldPacket& recvPacket);

    void HandleGuildMOTDOpcode(WorldPacket& recvPacket);

    void HandleGuildNewsUpdateStickyOpcode(WorldPacket& recvPacket);

    void HandleGuildSetNoteOpcode(WorldPacket& recvPacket);

    void HandleGuildSetAchievementTracking(WorldPacket& recvPacket);

    void HandleGuildQueryRanksOpcode(WorldPacket& recvPacket);

    void HandleGuildQueryNewsOpcode(WorldPacket& recvPacket);

    void HandleGuildSetRankPermissionsOpcode(WorldPacket& recvPacket);

    void HandleGuildAddRankOpcode(WorldPacket& recvPacket);

    void HandleGuildDelRankOpcode(WorldPacket& recvPacket);

    void HandleGuildChangeInfoTextOpcode(WorldPacket& recvPacket);

    void HandleSaveGuildEmblemOpcode(WorldPacket& recvPacket);

    void HandleGuildRequestPartyState(WorldPacket& recvPacket);

    void HandleGuildRequestMaxDailyXP(WorldPacket& recvPacket);

    void HandleGuildRequestChallengeUpdate(WorldPacket& recvPacket);

    void HandleAutoDeclineGuildInvites(WorldPacket& recvPacket);


    void HandleGuildFinderAddApplication(WorldPacket& recvPacket);

    void HandleGuildFinderBrowse(WorldPacket& recvPacket);

    void HandleGuildFinderDeclineRecruit(WorldPacket& recvPacket);

    void HandleGuildFinderGetApplications(WorldPacket& recvPacket);

    void HandleGuildFinderGetRecruits(WorldPacket& recvPacket);

    void HandleGuildFinderPostRequest(WorldPacket& recvPacket);

    void HandleGuildFinderRemoveApplication(WorldPacket& recvPacket);

    void HandleGuildFinderSetGuildPost(WorldPacket& recvPacket);


    void HandleBuyBankSlotOpcode(WorldPacket& recvPacket);

    void HandleTrainerBuySpellOpcode(WorldPacket& recvPacket);

    void HandleGossipHelloOpcode(WorldPacket& recvPacket);

    void HandleGossipSelectOptionOpcode(WorldPacket& recvPacket);

    void HandleNpcTextQueryOpcode(WorldPacket& recvPacket);


    void SendTrainerBuyFailed(ObjectGuid guid, uint32 spellId, uint32 reason);


    void HandleDuelProposedOpcode(WorldPacket& recvPacket);

    void HandleDuelResponseOpcode(WorldPacket& recvPacket);

    bool HandlePendingPetBattlePvpDuelResponse(bool accepted);


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

    void HandleBuyItemInSlotOpcode(WorldPacket& recvPacket);

    void HandleBuyItemOpcode(WorldPacket& recvPacket);

    void HandleAutoStoreBagItemOpcode(WorldPacket& recvPacket);

    void HandleReadItem(WorldPacket& recvPacket);

    void HandleAutoEquipItemSlotOpcode(WorldPacket& recvPacket);

    void HandleSwapItem(WorldPacket& recvPacket);

    void HandleBuybackItem(WorldPacket& recvPacket);

    void HandleAutoBankItemOpcode(WorldPacket& recvPacket);

    void HandleAutoStoreBankItemOpcode(WorldPacket& recvPacket);

    void HandleWrapItemOpcode(WorldPacket& recvPacket);


    void HandleSetSheathedOpcode(WorldPacket& recvPacket);


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

    void HandleUnlearnSkillOpcode(WorldPacket& recvPacket);

    void HandleRequestResearchHistory(WorldPacket& recvPacket);


    void HandleQuestgiverStatusQueryOpcode(WorldPacket& recvPacket);

    void HandleQuestgiverStatusMultipleQuery(WorldPacket& recvPacket);

    void SendQuestgiverStatusMultiple();

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

    void HandleAddonRegisteredPrefixesOpcode(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 HandleChannelDeclineInvite(WorldPacket& recvPacket);

    void HandleChannelDisplayListQuery(WorldPacket& recvPacket);

    void HandleGetChannelMemberCount(WorldPacket& recvPacket);


    void HandleCompleteCinematic(WorldPacket& recvPacket);

    void HandleNextCinematicCamera(WorldPacket& recvPacket);


    void HandlePageTextQueryOpcode(WorldPacket& recvPacket);

    void SendPageText(ObjectGuid GameObjectGUID);


    void HandleSceneCompleted(WorldPacket& recvPacket);


    void HandleTutorialFlag(WorldPacket& recvData);

    void HandleTutorialClear(WorldPacket& recvData);

    void HandleTutorialReset(WorldPacket& recvData);


    //Pet

    void HandlePetAction(WorldPacket& recvData);

    void HandlePetActionHelper(Unit* pet, uint64 guid1, uint32 spellid, uint16 flag, uint64 guid2, float x, float y, float z);

    void HandlePetSetAction(WorldPacket& recvData);

    void HandlePetAbandon(WorldPacket& recvData);

    void HandlePetRename(WorldPacket& recvData);

    void HandlePetCancelAuraOpcode(WorldPacket& recvPacket);

    void HandlePetSpellAutocastOpcode(WorldPacket& recvPacket);

    void HandlePetCastSpellOpcode(WorldPacket& recvPacket);

    void HandlePetLearnTalent(WorldPacket& recvPacket);

    void HandleLearnPreviewTalentsPet(WorldPacket& recvPacket);


    void HandleSetActionBarToggles(WorldPacket& recvData);


    void HandleCharRenameOpcode(WorldPacket& recvData);

    void HandleChangePlayerNameOpcodeCallBack(PreparedQueryResult result, std::string const& newName);

    void HandleSetPlayerDeclinedNames(WorldPacket& recvData);

    void HandeSetTalentSpecialization(WorldPacket& recvData);

    void HandleSetPetSpecialization(WorldPacket& recvData);


    void HandleTotemDestroyed(WorldPacket& recvData);

    void HandleDismissCritter(WorldPacket& recvData);


    //Battleground

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

    void HandleRequestPvpReward(WorldPacket& recvData);

    void HandleRequestConquestFormulaConstants(WorldPacket& recvData);


    void HandleWardenDataOpcode(WorldPacket& recvData);

    void HandleWorldTeleportOpcode(WorldPacket& recvData);

    void HandleMinimapPingOpcode(WorldPacket& recvData);

    void HandleRandomRollOpcode(WorldPacket& recvData);

    void HandleFarSightOpcode(WorldPacket& recvData);

    void HandleSetDungeonDifficultyOpcode(WorldPacket& recvData);

    void HandleSetRaidDifficultyOpcode(WorldPacket& recvData);

    void HandleMoveSetCanFlyAckOpcode(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);


    // Battlefield

    void HandleBattlefieldRatedInfoRequest(WorldPacket& recvData);

    void SendBfInvitePlayerToWar(uint64 guid, uint32 zoneId, uint32 time);

    void SendBfInvitePlayerToQueue(uint64 guid);

    void SendBfQueueInviteResponse(uint64 guid, uint32 zoneId, bool canQueue = true, bool full = false);

    void SendBfEntered(uint64 guid);

    void SendBfLeaveMessage(uint64 guid, BFLeaveReason reason = BF_LEAVE_REASON_EXITED);

    void HandleBfQueueInviteResponse(WorldPacket& recvData);

    void HandleBfEntryInviteResponse(WorldPacket& recvData);

    void HandleBfExitRequest(WorldPacket& recvData);


    // Looking for Dungeon/Raid

    void HandleLfgSetCommentOpcode(WorldPacket& recvData);

    void HandleLFDGetLockInfoOpcode(WorldPacket& recvData);

    void SendLfgPlayerLockInfo();

    void SendLfgPartyLockInfo();

    void HandleLfgJoinOpcode(WorldPacket& recvData);

    void HandleLfgLeaveOpcode(WorldPacket& recvData);

    void HandleLfgSetRolesOpcode(WorldPacket& recvData);

    void HandleLfgProposalResultOpcode(WorldPacket& recvData);

    void HandleLFDSetBootVoteOpcode(WorldPacket& recvData);

    void HandleLFDTeleportOpcode(WorldPacket& recvData);

    void HandleLfrJoinOpcode(WorldPacket& recvData);

    void HandleLfrLeaveOpcode(WorldPacket& recvData);

    void HandleLfgGetStatus(WorldPacket& recvData);


    // Challenge Mode

    void HandleGetChallengeModeRewards(WorldPacket& recvData);

    void HandleChallengeModeRequestLeaders(WorldPacket& recvData);

    void HandleChallengeModeRequestMapStats(WorldPacket& recvData);


    void SendLfgUpdateStatus(lfg::LfgUpdateData const& updateData, bool party, uint64 queueGuidOverride = 0, uint8 queueIdOverride = 0);

    void SendLfgRoleChosen(uint64 guid, uint8 roles);

    void SendLfgRoleCheckUpdate(lfg::LfgRoleCheck const& pRoleCheck);

    void SendLfgClearStatus(uint64 lfgGroupGuid = 0, uint8 queueIdOverride = 0, bool groupLeave = false);

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

    void HandleAreaSpiritHealerQueueOpcode(WorldPacket& recvData);

    void HandleCancelMountAuraOpcode(WorldPacket& recvData);

    void HandleSelfResOpcode(WorldPacket& recvData);

    void HandleComplainOpcode(WorldPacket& recvData);

    void HandleRequestPetInfoOpcode(WorldPacket& recvData);


    // Socket gem

    void HandleSocketOpcode(WorldPacket& recvData);

    void SendUpdateSockets(ObjectGuid ItemGUID, Item* item);


    void HandleCancelTempEnchantmentOpcode(WorldPacket& recvData);


    void HandleItemRefundInfoRequest(WorldPacket& recvData);

    void HandleItemRefund(WorldPacket& recvData);

    void SendItemExpirePurchaseRefund(ObjectGuid itemGuid);

    void HandleSetLootSpecialization(WorldPacket& recvData);


    void HandleChannelVoiceOnOpcode(WorldPacket& recvData);

    void HandleVoiceSessionEnableOpcode(WorldPacket& recvData);

    void HandleSetActiveVoiceChannel(WorldPacket& recvData);

    void HandleSetTaxiBenchmarkOpcode(WorldPacket& recvData);


    // Guild Bank

    void HandleGuildPermissions(WorldPacket& recvData);

    void HandleGuildBankMoneyWithdrawn(WorldPacket& recvData);

    void HandleGuildBankerActivate(WorldPacket& recvData);

    void HandleGuildBankQueryTab(WorldPacket& recvData);

    void HandleGuildBankLogQuery(WorldPacket& recvData);

    void HandleGuildBankDepositMoney(WorldPacket& recvData);

    void HandleGuildBankWithdrawMoney(WorldPacket& recvData);

    void HandleGuildBankSwapItems(WorldPacket& recvData);

    void HandleGuildBankTabNote(WorldPacket& recvData);


    void HandleGuildBankUpdateTab(WorldPacket& recvData);

    void HandleGuildBankBuyTab(WorldPacket& recvData);

    void HandleQueryGuildBankTabText(WorldPacket& recvData);

    void HandleSetGuildBankTabText(WorldPacket& recvData);

    void HandleGuildQueryXPOpcode(WorldPacket& recvData);


    // Refer-a-Friend

    void HandleGrantLevel(WorldPacket& recvData);

    void HandleAcceptGrantLevel(WorldPacket& recvData);


    // Calendar

    void HandleCalendarGetCalendar(WorldPacket& recvData);

    void HandleCalendarGetEvent(WorldPacket& recvData);

    void HandleCalendarGuildFilter(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);

    void HandleSetSavedInstanceExtend(WorldPacket& recvData);


    // Void Storage

    void HandleVoidStorageUnlock(WorldPacket& recvData);

    void HandleVoidStorageQuery(WorldPacket& recvData);

    void HandleVoidStorageTransfer(WorldPacket& recvData);

    void HandleVoidSwapItem(WorldPacket& recvData);

    void SendVoidStorageTransferResult(VoidTransferError result);


    // Transmogrification

    void HandleTransmogrifyItems(WorldPacket& recvData);


    // Reforge

    void HandleReforgeItemOpcode(WorldPacket& recvData);

    void SendReforgeResult(bool success);


    // BlackMarket

    void HandleBlackMarketHelloOpcode(WorldPacket& recvData);

    void SendBlackMarketHello(ObjectGuid NpcGUID, bool Open);

    void HandleBlackMarketRequestItemOpcode(WorldPacket& recvData);

    void SendBlackMarketRequestItemsResult();


    void HandleBlackMarketBidOnItem(WorldPacket& recvData);

    void SendBlackMarketBidOnItemResult(uint32 ItemID);


    // Miscellaneous

    void HandleSpellClick(WorldPacket& recvData);

    void HandleMirrorImageDataRequest(WorldPacket& recvData);

    void HandleAlterAppearance(WorldPacket& recvData);

    void SendBarberShopResult(BarberShopResult result);


    void HandleCharCustomize(WorldPacket& recvData);

    void HandleQueryInspectAchievements(WorldPacket& recvData);

    void HandleGuildAchievementProgressQuery(WorldPacket& recvData);

    void HandleEquipmentSetSave(WorldPacket& recvData);

    void HandleEquipmentSetDelete(WorldPacket& recvData);

    void HandleEquipmentSetUse(WorldPacket& recvData);

    void HandleWorldStateUITimerUpdate(WorldPacket& recvData);

    void HandleReadyForAccountDataTimes(WorldPacket& recvData);

    void HandleQuestNPCQuery(WorldPacket& recvData);

    void HandleQueryQuestsCompleted(WorldPacket& recvData);

    void HandleQuestPOIQuery(WorldPacket& recvData);

    void HandleEjectPassenger(WorldPacket& data);

    void HandleRideVehicleInteract(WorldPacket& recvData);

    void HandleUpdateProjectilePosition(WorldPacket& recvPacket);

    void HandleRequestHotfix(WorldPacket& recvPacket);

    void HandleUpdateMissileTrajectory(WorldPacket& recvPacket);

    void HandleViolenceLevel(WorldPacket& recvPacket);

    void HandleObjectUpdateFailedOpcode(WorldPacket& recvPacket);

    void HandleSelectFactionOpcode(WorldPacket& recvPacket);

    void HandleDiscardedTimeSyncAcks(WorldPacket& recvData);

    void HandleRequestCategoryCooldowns(WorldPacket& recvPacket);

    void HandleRequestCemeteryList(WorldPacket& recvPacket);


    void SendBroadcastText(uint32 entry);


    int32 HandleEnableNagleAlgorithm();


    // Compact Unit Frames (4.x)

    void HandleSaveCUFProfiles(WorldPacket& recvPacket);

    void SendLoadCUFProfiles();


    // Battle Pets

    void HandlePetBattleStartPvpMatchmaking(WorldPacket& recvData);

    void HandlePetBattleStopPvpMatchmaking(WorldPacket& recvData);

    void HandlePetBattleQueueProposeMatchResult(WorldPacket& recvData);

    void HandlePetBattleRequestPvp(WorldPacket& recvData);

    void HandleBattlePetDelete(WorldPacket& recvData);

    void HandleBattlePetLearn(WorldPacket& recvData);

    void HandleBattlePetModifyName(WorldPacket& recvData);

    void HandleBattlePetQueryName(WorldPacket& recvData);

    void HandleBattlePetRequestJournal(WorldPacket& recvData);

    void HandleBattlePetSetBattleSlot(WorldPacket& recvData);

    void HandleBattlePetSetFlags(WorldPacket& recvData);

    void HandleBattlePetSummonCompanion(WorldPacket& recvData);

    void HandleBattlePetCage(WorldPacket& recvData);

    void HandleBattlePetInput(WorldPacket& recvData);

    void HandleBattlePetInputFirstPet(WorldPacket& recvData);

    void HandleBattlePetFinalNotify(WorldPacket& recvData);

    void HandleBattlePetQuitNotify(WorldPacket& recvData);

    void HandleBattlePetRequestUpdate(WorldPacket& recvData);

    void HandleBattlePetWildRequest(WorldPacket& recvData);

    void UpdatePetBattlePvpQueueState();

    void ClearPetBattlePvpQueueState();


    // Titles

    void HandleSetTitleOpcode(WorldPacket& recvData);

    void SendTitleEarned(uint32 TitleIndex);

    void SendTitleLost(uint32 TitleIndex);


    void SendPlayMusic(uint32 SoundKitID);


    void SendCrossedInebriationThreshold(ObjectGuid guid, uint32 ItemID, DrunkenState drunkenState);


private:

    void InitializeQueryCallbackParameters();

    void ProcessQueryCallbacks();


    PreparedQueryResultFuture _charEnumCallback;

    PreparedQueryResultFuture _addIgnoreCallback;

    PreparedQueryResultFuture _stablePetCallback;

    QueryCallback<PreparedQueryResult, std::string> _charRenameCallback;

    QueryCallback<PreparedQueryResult, std::string> _addFriendCallback;

    QueryCallback<PreparedQueryResult, uint32> _unstablePetCallback;

    QueryCallback<PreparedQueryResult, uint32> _stableSwapCallback;

    QueryCallback<PreparedQueryResult, uint64> _sendStabledPetCallback;

    QueryCallback<PreparedQueryResult, CharacterCreateInfo*, true> _charCreateCallback;

    QueryResultHolderFuture _charLoginCallback;


    friend class World;

protected:


    class DosProtection

    {

        friend class World;

    public:

        DosProtection(WorldSession* s) : Session(s), _policy((Policy)sWorld->getIntConfig(WorldIntConfigs::CONFIG_PACKET_SPOOF_POLICY)) { }

        bool EvaluateOpcode(WorldPacket& p) const;

        void AllowOpcode(uint16 opcode, bool allow) { _isOpcodeAllowed[opcode] = allow; }

    protected:


        enum Policy

        {

            POLICY_LOG,

            POLICY_KICK,

            POLICY_BAN,

        };


        bool IsOpcodeAllowed(uint16 opcode) const

        {

            OpcodeStatusMap::const_iterator itr = _isOpcodeAllowed.find(opcode);

            if (itr == _isOpcodeAllowed.end())

                return true;    // No presence in the map indicates this is the first time the opcode was sent this session, so allow


            return itr->second;

        }


        WorldSession* Session;


    private:

        typedef UNORDERED_MAP<uint16, bool> OpcodeStatusMap;

        OpcodeStatusMap _isOpcodeAllowed; // could be bool array, but wouldn't be practical for game versions with non-linear opcodes

        Policy _policy;


        DosProtection(DosProtection const& right) = delete;

        DosProtection& operator=(DosProtection const& right) = delete;

    } AntiDOS;


private:

    // private trade methods

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


    // logging helper

    void LogUnexpectedOpcode(WorldPacket* packet, const char* status, const char* reason) const;

    void LogUnprocessedTail(WorldPacket* packet) const;


    // EnumData helpers


    bool IsLegitCharacterForAccount(uint32 lowGUID)

    {

        return _legitCharacters.find(lowGUID) != _legitCharacters.end();

    }


    // this stores the GUIDs of the characters who can login

    // characters who failed on Player::BuildEnumData shouldn't login

    std::set<uint32> _legitCharacters;


    uint32 m_GUIDLow;                                   // set loggined or recently logout player (while m_playerRecentlyLogout set)

    Player* _player;

    WorldSocket* m_Socket;

    std::string m_Address;


    AccountTypes _security;

    uint32 _accountId;

    uint32 m_virtualRealmID;

    uint8 m_expansion;

    CharacterBooster* m_charBooster;


    typedef std::list<AddonInfo> AddonsList;


    // Warden

    Warden* _warden;                                    // Remains NULL if Warden system is not enabled by config


    time_t _logoutTime;

    bool m_inQueue;                                     // session wait in auth.queue

    bool m_playerLoading;                               // code processed in LoginPlayer

    bool m_playerLogout;                                // code processed in LogoutPlayer

    bool m_playerRecentlyLogout;

    bool m_playerSave;

    LocaleConstant m_sessionDbcLocale;

    LocaleConstant m_sessionDbLocaleIndex;

    uint32 m_latency;

    uint32 m_clientTimeDelay;

    AccountData m_accountData[uint8(AccountDataType::NUM_ACCOUNT_DATA_TYPES)];

    uint32 m_Tutorials[MAX_ACCOUNT_TUTORIAL_VALUES];

    bool   m_TutorialsChanged;

    AddonsList m_addonsList;

    std::vector<std::string> _registeredAddonPrefixes;

    bool _filterAddonMessages;

    uint32 recruiterId;

    bool isRecruiter;

    bool m_hasBoost;

    Skyfire::LockedQueue<WorldPacket*, Skyfire::Mutex> _recvQueue;

    time_t timeLastWhoCommand;

    z_stream_s* _compressionStream;

    rbac::RBACData* _RBACData;

    WorldSession(WorldSession const& right) = delete;

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

};


#endif

AccountMgr.h

AddonMgr.h

AuthDefines.h

SessionKey
std::array< uint8, SESSION_KEY_LENGTH > SessionKey
Definition AuthDefines.h:8

npc
npc
Definition BattlegroundSA.h:99

Common.h

LocaleConstant
LocaleConstant
Definition Common.h:138

AccountTypes
AccountTypes
Definition Common.h:129

MAX_ACCOUNT_TUTORIAL_VALUES
#define MAX_ACCOUNT_TUTORIAL_VALUES
Definition Common.h:157

DatabaseEnv.h

int32
std::int32_t int32
Definition Define.h:73

uint8
std::uint8_t uint8
Definition Define.h:79

uint32
std::uint32_t uint32
Definition Define.h:77

int8
std::int8_t int8
Definition Define.h:75

ATTR_PRINTF
#define ATTR_PRINTF(F, V)
Definition Define.h:55

uint64
std::uint64_t uint64
Definition Define.h:76

uint16
std::uint16_t uint16
Definition Define.h:78

Object.h

Opcodes.h

PreparedQueryResultFuture
Skyfire::Future< PreparedQueryResult > PreparedQueryResultFuture
Definition PreparedStatement.h:150

QueryResultHolderFuture
Skyfire::Future< SQLQueryHolder * > QueryResultHolderFuture
Definition QueryHolder.h:30

PreparedQueryResult
Skyfire::AutoPtr< PreparedResultSet, Skyfire::Mutex > PreparedQueryResult
Definition QueryResult.h:94

SharedDefines.h

ResponseCodes
ResponseCodes
Definition SharedDefines.h:3864

TradeStatus
TradeStatus
Definition SharedDefines.h:4090

VoidTransferError
VoidTransferError
Definition SharedDefines.h:4257

BattlegroundTypeId
BattlegroundTypeId
Definition SharedDefines.h:4003

BattlegroundTypeId::BATTLEGROUND_RB
@ BATTLEGROUND_RB
Definition SharedDefines.h:4017

ActivateTaxiReply
ActivateTaxiReply
5.4.8 18414
Definition SharedDefines.h:4138

DrunkenState
DrunkenState
Definition SharedDefines.h:4271

PartyResult
PartyResult
Definition SharedDefines.h:4343

SQLTransaction
Skyfire::AutoPtr< Transaction, Skyfire::Mutex > SQLTransaction
Definition Transaction.h:42

UNORDERED_MAP
#define UNORDERED_MAP
Definition UnorderedMap.h:58

World.h

WorldPacket.h

CharacterBooster
Definition CharacterBoost.h:572

CharacterCreateInfo
Definition WorldSession.h:225

CharacterCreateInfo::HairColor
uint8 HairColor
Definition WorldSession.h:243

CharacterCreateInfo::Skin
uint8 Skin
Definition WorldSession.h:240

CharacterCreateInfo::OutfitId
uint8 OutfitId
Definition WorldSession.h:245

CharacterCreateInfo::Class
uint8 Class
Definition WorldSession.h:238

CharacterCreateInfo::Data
WorldPacket Data
Definition WorldSession.h:246

CharacterCreateInfo::Name
std::string Name
User specified variables.
Definition WorldSession.h:236

CharacterCreateInfo::FacialHair
uint8 FacialHair
Definition WorldSession.h:244

CharacterCreateInfo::CharacterCreateInfo
CharacterCreateInfo(std::string const &name, uint8 race, uint8 cclass, uint8 gender, uint8 skin, uint8 face, uint8 hairStyle, uint8 hairColor, uint8 facialHair, uint8 outfitId, WorldPacket &data)
Definition WorldSession.h:230

CharacterCreateInfo::WorldSession
friend class WorldSession
Definition WorldSession.h:226

CharacterCreateInfo::Player
friend class Player
Definition WorldSession.h:227

CharacterCreateInfo::HairStyle
uint8 HairStyle
Definition WorldSession.h:242

CharacterCreateInfo::CharCount
uint8 CharCount
Server side data.
Definition WorldSession.h:249

CharacterCreateInfo::Face
uint8 Face
Definition WorldSession.h:241

CharacterCreateInfo::Gender
uint8 Gender
Definition WorldSession.h:239

CharacterCreateInfo::Race
uint8 Race
Definition WorldSession.h:237

Creature
Definition Creature.h:427

GameObject
Definition GameObject.h:629

InstanceSave
Definition InstanceSaveMgr.h:32

Item
Definition Item.h:202

LoginQueryHolder
Definition CharacterHandler.cpp:45

MapSessionFilter::ProcessLogout
virtual bool ProcessLogout() const
Definition WorldSession.h:208

MapSessionFilter::Process
virtual bool Process(WorldPacket *packet)
Definition WorldSession.cpp:45

MapSessionFilter::MapSessionFilter
MapSessionFilter(WorldSession *pSession)
Definition WorldSession.h:203

MapSessionFilter::~MapSessionFilter
~MapSessionFilter()
Definition WorldSession.h:204

Object
Definition Object.h:110

PacketFilter
Definition WorldSession.h:183

PacketFilter::Process
virtual bool Process(WorldPacket *)
Definition WorldSession.h:188

PacketFilter::operator=
PacketFilter & operator=(PacketFilter const &right)=delete

PacketFilter::ProcessLogout
virtual bool ProcessLogout() const
Definition WorldSession.h:189

PacketFilter::PacketFilter
PacketFilter(PacketFilter const &right)=delete

PacketFilter::DropHighBytes
static uint16 DropHighBytes(uint16 opcode)
Definition WorldSession.h:190

PacketFilter::PacketFilter
PacketFilter(WorldSession *pSession)
Definition WorldSession.h:185

PacketFilter::m_pSession
WorldSession *const m_pSession
Definition WorldSession.h:193

PacketFilter::~PacketFilter
virtual ~PacketFilter()
Definition WorldSession.h:186

Player
Definition Player.h:1289

QueryCallback
Definition Callback.h:23

Quest
Definition QuestDef.h:255

Skyfire::LockedQueue
Definition LockedQueue.h:20

SpellCastTargets
Definition Spell.h:144

Unit
Definition Unit.h:1367

Warden
Definition Warden.h:91

WorldPacket
Definition WorldPacket.h:16

WorldSession::DosProtection::EvaluateOpcode
bool EvaluateOpcode(WorldPacket &p) const
Definition WorldSession.cpp:1264

WorldSession::DosProtection::_policy
Policy _policy
Definition WorldSession.h:1163

WorldSession::DosProtection::Session
WorldSession * Session
Definition WorldSession.h:1158

WorldSession::DosProtection::IsOpcodeAllowed
bool IsOpcodeAllowed(uint16 opcode) const
Definition WorldSession.h:1149

WorldSession::DosProtection::AllowOpcode
void AllowOpcode(uint16 opcode, bool allow)
Definition WorldSession.h:1140

WorldSession::DosProtection::OpcodeStatusMap
UNORDERED_MAP< uint16, bool > OpcodeStatusMap
Definition WorldSession.h:1161

WorldSession::DosProtection::World
friend class World
Definition WorldSession.h:1136

WorldSession::DosProtection::DosProtection
DosProtection(DosProtection const &right)=delete

WorldSession::DosProtection::DosProtection
DosProtection(WorldSession *s)
Definition WorldSession.h:1138

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

WorldSession::DosProtection::Policy
Policy
Definition WorldSession.h:1143

WorldSession::DosProtection::POLICY_KICK
@ POLICY_KICK
Definition WorldSession.h:1145

WorldSession::DosProtection::POLICY_BAN
@ POLICY_BAN
Definition WorldSession.h:1146

WorldSession::DosProtection::POLICY_LOG
@ POLICY_LOG
Definition WorldSession.h:1144

WorldSession::DosProtection::_isOpcodeAllowed
OpcodeStatusMap _isOpcodeAllowed
Definition WorldSession.h:1162

WorldSessionFilter::~WorldSessionFilter
~WorldSessionFilter()
Definition WorldSession.h:217

WorldSessionFilter::WorldSessionFilter
WorldSessionFilter(WorldSession *pSession)
Definition WorldSession.h:216

WorldSessionFilter::Process
virtual bool Process(WorldPacket *packet)
Definition WorldSession.cpp:67

WorldSession
Player session in the World.
Definition WorldSession.h:254

WorldSession::SendLfgPartyLockInfo
void SendLfgPartyLockInfo()
Definition LFGHandler.cpp:461

WorldSession::HandleBattlePetInputFirstPet
void HandleBattlePetInputFirstPet(WorldPacket &recvData)
Definition BattlePetHandler.cpp:1544

WorldSession::SendAuctionHello
void SendAuctionHello(ObjectGuid guid, Creature *unit)
Definition AuctionHouseHandler.cpp:45

WorldSession::_charCreateCallback
QueryCallback< PreparedQueryResult, CharacterCreateInfo *, true > _charCreateCallback
Definition WorldSession.h:1129

WorldSession::HandleGuildRequestMaxDailyXP
void HandleGuildRequestMaxDailyXP(WorldPacket &recvPacket)
Definition GuildHandler.cpp:682

WorldSession::SendBroadcastText
void SendBroadcastText(uint32 entry)
Definition MiscHandler.cpp:2668

WorldSession::SetPlayer
void SetPlayer(Player *player)
Definition WorldSession.cpp:1100

WorldSession::HandleGMTicketCreateOpcode
void HandleGMTicketCreateOpcode(WorldPacket &recvPacket)
Definition TicketHandler.cpp:20

WorldSession::HandleGuildBankTabNote
void HandleGuildBankTabNote(WorldPacket &recvData)
Definition GuildHandler.cpp:802

WorldSession::HandleGossipSelectOptionOpcode
void HandleGossipSelectOptionOpcode(WorldPacket &recvPacket)
Definition MiscHandler.cpp:650

WorldSession::m_playerRecentlyLogout
bool m_playerRecentlyLogout
Definition WorldSession.h:1207

WorldSession::HandleAuctionListPendingSales
void HandleAuctionListPendingSales(WorldPacket &recvData)
Definition AuctionHouseHandler.cpp:875

WorldSession::Update
bool Update(uint32 diff, PacketFilter &updater)
Update the WorldSession (triggered by World update).
Definition WorldSession.cpp:299

WorldSession::HandleMountSpecialAnimOpcode
void HandleMountSpecialAnimOpcode(WorldPacket &recvdata)
Definition MovementHandler.cpp:743

WorldSession::SendBlackMarketBidOnItemResult
void SendBlackMarketBidOnItemResult(uint32 ItemID)
Definition BlackMarketHandler.cpp:111

WorldSession::HandleGetChannelMemberCount
void HandleGetChannelMemberCount(WorldPacket &recvPacket)
Definition ChannelHandler.cpp:311

WorldSession::HandleBattlegroundPlayerPositionsOpcode
void HandleBattlegroundPlayerPositionsOpcode(WorldPacket &recvData)
Definition BattleGroundHandler.cpp:246

WorldSession::SaveTutorialsData
void SaveTutorialsData(SQLTransaction &trans)
Definition WorldSession.cpp:843

WorldSession::HandleBattlePetInput
void HandleBattlePetInput(WorldPacket &recvData)
Definition BattlePetHandler.cpp:1424

WorldSession::HandleDestroyItemOpcode
void HandleDestroyItemOpcode(WorldPacket &recvPacket)
Definition ItemHandler.cpp:287

WorldSession::HandleLootMoneyOpcode
void HandleLootMoneyOpcode(WorldPacket &recvPacket)
Definition LootHandler.cpp:127

WorldSession::LogoutPlayer
void LogoutPlayer(bool save)
Log the player out
Definition WorldSession.cpp:470

WorldSession::HandleLfgJoinOpcode
void HandleLfgJoinOpcode(WorldPacket &recvData)
Definition LFGHandler.cpp:93

WorldSession::HandleCharCustomize
void HandleCharCustomize(WorldPacket &recvData)
Definition CharacterHandler.cpp:2145

WorldSession::KickPlayer
void KickPlayer()
Kick a player out of the World.
Definition WorldSession.cpp:620

WorldSession::HandleEquipmentSetUse
void HandleEquipmentSetUse(WorldPacket &recvData)
Definition CharacterHandler.cpp:2326

WorldSession::m_virtualRealmID
uint32 m_virtualRealmID
Definition WorldSession.h:1194

WorldSession::HandleAuctionListItems
void HandleAuctionListItems(WorldPacket &recvData)
Definition AuctionHouseHandler.cpp:801

WorldSession::HandleGuildFinderBrowse
void HandleGuildFinderBrowse(WorldPacket &recvPacket)
Definition GuildFinderHandler.cpp:50

WorldSession::HandleCalendarGetEvent
void HandleCalendarGetEvent(WorldPacket &recvData)
Definition CalendarHandler.cpp:207

WorldSession::GetAccountData
AccountData * GetAccountData(AccountDataType type)
Definition WorldSession.h:432

WorldSession::HandleMailCreateTextItem
void HandleMailCreateTextItem(WorldPacket &recvData)
Definition MailHandler.cpp:1040

WorldSession::HandleUnstablePetCallback
void HandleUnstablePetCallback(PreparedQueryResult result, uint32 petId)
Definition NPCHandler.cpp:675

WorldSession::SendLfgJoinResult
void SendLfgJoinResult(lfg::LfgJoinResultData const &joinData)
Definition LFGHandler.cpp:790

WorldSession::HandleBfExitRequest
void HandleBfExitRequest(WorldPacket &recvData)
Definition BattlefieldHandler.cpp:224

WorldSession::HandleGuildSetNoteOpcode
void HandleGuildSetNoteOpcode(WorldPacket &recvPacket)
Definition GuildHandler.cpp:196

WorldSession::HandleSetDungeonDifficultyOpcode
void HandleSetDungeonDifficultyOpcode(WorldPacket &recvData)
Definition MiscHandler.cpp:2134

WorldSession::SendBfLeaveMessage
void SendBfLeaveMessage(uint64 guid, BFLeaveReason reason=BF_LEAVE_REASON_EXITED)
Definition BattlefieldHandler.cpp:161

WorldSession::isRecruiter
bool isRecruiter
Definition WorldSession.h:1220

WorldSession::HandleLfgLeaveOpcode
void HandleLfgLeaveOpcode(WorldPacket &recvData)
Definition LFGHandler.cpp:144

WorldSession::HandleMoveSplineDoneOpcode
void HandleMoveSplineDoneOpcode(WorldPacket &recvPacket)
Definition TaxiHandler.cpp:226

WorldSession::HandleCalendarEventRsvp
void HandleCalendarEventRsvp(WorldPacket &recvData)
Definition CalendarHandler.cpp:586

WorldSession::HandleCorpseMapPositionQuery
void HandleCorpseMapPositionQuery(WorldPacket &recvPacket)
Definition QueryHandler.cpp:509

WorldSession::HandleSetSelectionOpcode
void HandleSetSelectionOpcode(WorldPacket &recvPacket)
Definition MiscHandler.cpp:1204

WorldSession::HandleSaveGuildEmblemOpcode
void HandleSaveGuildEmblemOpcode(WorldPacket &recvPacket)
Definition GuildHandler.cpp:294

WorldSession::HandleInspectOpcode
void HandleInspectOpcode(WorldPacket &recvPacket)
Definition MiscHandler.cpp:1866

WorldSession::SetBoosting
void SetBoosting(bool boost, bool saveToDB=true)
Definition BoostHandler.cpp:9

WorldSession::HandlePlayerLoginOpcode
void HandlePlayerLoginOpcode(WorldPacket &recvPacket)
Definition CharacterHandler.cpp:1393

WorldSession::HandleDismissControlledVehicle
void HandleDismissControlledVehicle(WorldPacket &recvData)
Definition VehicleHandler.cpp:15

WorldSession::HandleAuctionListOwnerItems
void HandleAuctionListOwnerItems(WorldPacket &recvData)
Definition AuctionHouseHandler.cpp:762

WorldSession::HandleTimeSyncResp
void HandleTimeSyncResp(WorldPacket &recvData)
Definition MiscHandler.cpp:2083

WorldSession::HandleChannelInvite
void HandleChannelInvite(WorldPacket &recvPacket)
Definition ChannelHandler.cpp:213

WorldSession::Expansion
uint8 Expansion() const
Definition WorldSession.h:303

WorldSession::HandleBattlemasterJoinOpcode
void HandleBattlemasterJoinOpcode(WorldPacket &recvData)
Definition BattleGroundHandler.cpp:60

WorldSession::HandleLfgSetCommentOpcode
void HandleLfgSetCommentOpcode(WorldPacket &recvData)
Definition LFGHandler.cpp:277

WorldSession::HandleGroupUninviteGuidOpcode
void HandleGroupUninviteGuidOpcode(WorldPacket &recvPacket)
Definition GroupHandler.cpp:326

WorldSession::HasBoost
bool HasBoost() const
Definition WorldSession.h:516

WorldSession::HandleDiscardedTimeSyncAcks
void HandleDiscardedTimeSyncAcks(WorldPacket &recvData)
Definition MiscHandler.cpp:2940

WorldSession::HandleBuyBankSlotOpcode
void HandleBuyBankSlotOpcode(WorldPacket &recvPacket)
Definition ItemHandler.cpp:886

WorldSession::HandleMoveTeleportAck
void HandleMoveTeleportAck(WorldPacket &recvPacket)
Definition MovementHandler.cpp:435

WorldSession::m_Address
std::string m_Address
Definition WorldSession.h:1190

WorldSession::HandleActivateTaxiOpcode
void HandleActivateTaxiOpcode(WorldPacket &recvPacket)
Definition TaxiHandler.cpp:301

WorldSession::HandleMailReturnToSender
void HandleMailReturnToSender(WorldPacket &recvData)
Definition MailHandler.cpp:707

WorldSession::GetSkyFireString
const char * GetSkyFireString(int32 entry) const
Definition WorldSession.cpp:667

WorldSession::HandleQuestNPCQuery
void HandleQuestNPCQuery(WorldPacket &recvData)
Definition QueryHandler.cpp:525

WorldSession::HandleAlterAppearance
void HandleAlterAppearance(WorldPacket &recvData)
Definition CharacterHandler.cpp:2077

WorldSession::HandleCancelGrowthAuraOpcode
void HandleCancelGrowthAuraOpcode(WorldPacket &recvPacket)
Definition SpellHandler.cpp:1671

WorldSession::HandleGMTicketGetTicketOpcode
void HandleGMTicketGetTicketOpcode(WorldPacket &recvPacket)
Definition TicketHandler.cpp:153

WorldSession::HandleCompleteCinematic
void HandleCompleteCinematic(WorldPacket &recvPacket)
Definition MiscHandler.cpp:1752

WorldSession::HandleChatIgnoredOpcode
void HandleChatIgnoredOpcode(WorldPacket &recvPacket)
Definition ChatHandler.cpp:802

WorldSession::SendPlayerNotFoundNotice
void SendPlayerNotFoundNotice(std::string const &name)
Definition ChatHandler.cpp:828

WorldSession::HandleSceneCompleted
void HandleSceneCompleted(WorldPacket &recvPacket)
Definition MiscHandler.cpp:2979

WorldSession::_recvQueue
Skyfire::LockedQueue< WorldPacket *, Skyfire::Mutex > _recvQueue
Definition WorldSession.h:1222

WorldSession::SendLfgQueueStatus
void SendLfgQueueStatus(lfg::LfgQueueStatusData const &queueData)
Definition LFGHandler.cpp:842

WorldSession::_stablePetCallback
PreparedQueryResultFuture _stablePetCallback
Definition WorldSession.h:1123

WorldSession::HandleNextCinematicCamera
void HandleNextCinematicCamera(WorldPacket &recvPacket)
Definition MiscHandler.cpp:1759

WorldSession::HandleViolenceLevel
void HandleViolenceLevel(WorldPacket &recvPacket)
Definition MiscHandler.cpp:2744

WorldSession::moveItems
void moveItems(Item *myItems[], Item *hisItems[])
Definition TradeHandler.cpp:183

WorldSession::m_playerSave
bool m_playerSave
Definition WorldSession.h:1208

WorldSession::HandleGuildRequestChallengeUpdate
void HandleGuildRequestChallengeUpdate(WorldPacket &recvPacket)
Definition GuildHandler.cpp:782

WorldSession::HandleShowingHelmOpcode
void HandleShowingHelmOpcode(WorldPacket &recvData)
Definition CharacterHandler.cpp:1867

WorldSession::HandleLootMasterGiveOpcode
void HandleLootMasterGiveOpcode(WorldPacket &recvPacket)
Definition LootHandler.cpp:493

WorldSession::LogoutRequest
void LogoutRequest(time_t requestTime)
Engage the logout process for the user.
Definition WorldSession.h:314

WorldSession::HandleMinimapPingOpcode
void HandleMinimapPingOpcode(WorldPacket &recvData)
Definition GroupHandler.cpp:567

WorldSession::m_addonsList
AddonsList m_addonsList
Definition WorldSession.h:1216

WorldSession::HandleGuildQueryRanksOpcode
void HandleGuildQueryRanksOpcode(WorldPacket &recvPacket)
Definition GuildHandler.cpp:243

WorldSession::SendClientCacheVersion
void SendClientCacheVersion(uint32 version)
Definition AuthHandler.cpp:126

WorldSession::HandleSetFactionAtWar
void HandleSetFactionAtWar(WorldPacket &recvData)
Definition CharacterHandler.cpp:1787

WorldSession::HandleUnstablePet
void HandleUnstablePet(WorldPacket &recvPacket)
Definition NPCHandler.cpp:646

WorldSession::SendTrainerList
void SendTrainerList(uint64 guid)
Definition NPCHandler.cpp:94

WorldSession::HandleBattlePetDelete
void HandleBattlePetDelete(WorldPacket &recvData)
Definition BattlePetHandler.cpp:1024

WorldSession::HandleQueryQuestsCompleted
void HandleQueryQuestsCompleted(WorldPacket &recvData)
Definition QuestHandler.cpp:924

WorldSession::HandleAddFriendOpcodeCallBack
void HandleAddFriendOpcodeCallBack(PreparedQueryResult result, std::string const &friendNote)
Definition MiscHandler.cpp:1246

WorldSession::HandleGroupAssistantLeaderOpcode
void HandleGroupAssistantLeaderOpcode(WorldPacket &recvData)
Definition GroupHandler.cpp:736

WorldSession::HandlePlayedTime
void HandlePlayedTime(WorldPacket &recvPacket)
Definition MiscHandler.cpp:1855

WorldSession::HandleRandomRollOpcode
void HandleRandomRollOpcode(WorldPacket &recvData)
Definition GroupHandler.cpp:597

WorldSession::HandleIgnoreTradeOpcode
void HandleIgnoreTradeOpcode(WorldPacket &recvPacket)
Definition TradeHandler.cpp:62

WorldSession::HandleSendMail
void HandleSendMail(WorldPacket &recvData)
Definition MailHandler.cpp:470

WorldSession::HandleGuildRewardsQueryOpcode
void HandleGuildRewardsQueryOpcode(WorldPacket &recvPacket)
Definition GuildHandler.cpp:705

WorldSession::SendLfgRoleChosen
void SendLfgRoleChosen(uint64 guid, uint8 roles)
Definition LFGHandler.cpp:700

WorldSession::HandleChangeSeatsOnControlledVehicle
void HandleChangeSeatsOnControlledVehicle(WorldPacket &recvData)
Definition VehicleHandler.cpp:35

WorldSession::HandleLogoutRequestOpcode
void HandleLogoutRequestOpcode(WorldPacket &recvPacket)
Definition MiscHandler.cpp:1034

WorldSession::HandleDismissCritter
void HandleDismissCritter(WorldPacket &recvData)
Definition PetHandler.cpp:748

WorldSession::HandleSocketOpcode
void HandleSocketOpcode(WorldPacket &recvData)
Definition ItemHandler.cpp:1224

WorldSession::HandleMovementForceAck
void HandleMovementForceAck(WorldPacket &recvPacket)
Definition MovementHandler.cpp:825

WorldSession::HandleGroupEveryoneIsAssistantOpcode
void HandleGroupEveryoneIsAssistantOpcode(WorldPacket &recvData)
Definition GroupHandler.cpp:763

WorldSession::HandleTrainerBuySpellOpcode
void HandleTrainerBuySpellOpcode(WorldPacket &recvPacket)
Definition NPCHandler.cpp:211

WorldSession::InitializeQueryCallbackParameters
void InitializeQueryCallbackParameters()
Definition WorldSession.cpp:1113

WorldSession::ReadAddonsInfo
void ReadAddonsInfo(WorldPacket &data)
Definition WorldSession.cpp:861

WorldSession::HandleCalendarGetCalendar
void HandleCalendarGetCalendar(WorldPacket &recvData)
Definition CalendarHandler.cpp:37

WorldSession::HandleGMSurveySubmit
void HandleGMSurveySubmit(WorldPacket &recvPacket)
Definition TicketHandler.cpp:188

WorldSession::HandleCharEnumOpcode
void HandleCharEnumOpcode(WorldPacket &recvPacket)
Definition CharacterHandler.cpp:881

WorldSession::HandlePetCancelAuraOpcode
void HandlePetCancelAuraOpcode(WorldPacket &recvPacket)
Definition SpellHandler.cpp:1658

WorldSession::HandleMoveHoverAck
void HandleMoveHoverAck(WorldPacket &recvData)
Definition MovementHandler.cpp:771

WorldSession::isLogingOut
bool isLogingOut() const
Is the user engaged in a log out process?
Definition WorldSession.h:311

WorldSession::HandleBattlePetModifyName
void HandleBattlePetModifyName(WorldPacket &recvData)
Definition BattlePetHandler.cpp:1063

WorldSession::HandleSetPartyAssignmentOpcode
void HandleSetPartyAssignmentOpcode(WorldPacket &recvData)
Definition GroupHandler.cpp:781

WorldSession::m_sessionDbLocaleIndex
LocaleConstant m_sessionDbLocaleIndex
Definition WorldSession.h:1210

WorldSession::HandleEjectPassenger
void HandleEjectPassenger(WorldPacket &data)
Definition VehicleHandler.cpp:147

WorldSession::HandleGuildFinderDeclineRecruit
void HandleGuildFinderDeclineRecruit(WorldPacket &recvPacket)
Definition GuildFinderHandler.cpp:137

WorldSession::HandleResetInstancesOpcode
void HandleResetInstancesOpcode(WorldPacket &recvData)
Definition MiscHandler.cpp:2121

WorldSession::HandleSetLfgBonusFactionID
void HandleSetLfgBonusFactionID(WorldPacket &recvData)
Definition CharacterHandler.cpp:1779

WorldSession::HandleAddonRegisteredPrefixesOpcode
void HandleAddonRegisteredPrefixesOpcode(WorldPacket &recvPacket)
Definition WorldSession.cpp:1068

WorldSession::HandleGroupSetRolesOpcode
void HandleGroupSetRolesOpcode(WorldPacket &recvData)
Definition GroupHandler.cpp:419

WorldSession::HandleWardenDataOpcode
void HandleWardenDataOpcode(WorldPacket &recvData)
Definition Warden.cpp:205

WorldSession::SendNotification
void SendNotification(const char *format,...) ATTR_PRINTF(2
Definition WorldSession.cpp:626

WorldSession::m_TutorialsChanged
bool m_TutorialsChanged
Definition WorldSession.h:1215

WorldSession::HandleAutoDeclineGuildInvites
void HandleAutoDeclineGuildInvites(WorldPacket &recvPacket)
Definition GuildHandler.cpp:699

WorldSession::HandlePetRename
void HandlePetRename(WorldPacket &recvData)
Definition PetHandler.cpp:1200

WorldSession::HandleGuildRosterOpcode
void HandleGuildRosterOpcode(WorldPacket &recvPacket)
Definition GuildHandler.cpp:116

WorldSession::HandlePetCastSpellOpcode
void HandlePetCastSpellOpcode(WorldPacket &recvPacket)
Definition PetHandler.cpp:1288

WorldSession::HandleCalendarEventInvite
void HandleCalendarEventInvite(WorldPacket &recvData)
Definition CalendarHandler.cpp:454

WorldSession::HandleVoiceSessionEnableOpcode
void HandleVoiceSessionEnableOpcode(WorldPacket &recvData)
Definition VoiceChatHandler.cpp:12

WorldSession::HandleOpenItemOpcode
void HandleOpenItemOpcode(WorldPacket &recvPacket)
Definition SpellHandler.cpp:1339

WorldSession::HandleWorldStateUITimerUpdate
void HandleWorldStateUITimerUpdate(WorldPacket &recvData)
Definition MiscHandler.cpp:2335

WorldSession::HandleSellItemOpcode
void HandleSellItemOpcode(WorldPacket &recvPacket)
Definition ItemHandler.cpp:362

WorldSession::_logoutTime
time_t _logoutTime
Definition WorldSession.h:1203

WorldSession::HandleGameObjectUseOpcode
void HandleGameObjectUseOpcode(WorldPacket &recPacket)
Definition SpellHandler.cpp:1433

WorldSession::GetGuidLow
uint32 GetGuidLow() const
Get player guid if available. Use for logging purposes only.
Definition WorldSession.cpp:190

WorldSession::HandleMoveRootAck
void HandleMoveRootAck(WorldPacket &recvPacket)
Definition MiscHandler.cpp:1811

WorldSession::HandleRequestAccountData
void HandleRequestAccountData(WorldPacket &recvPacket)
Definition MiscHandler.cpp:1680

WorldSession::HandleGroupRaidConvertOpcode
void HandleGroupRaidConvertOpcode(WorldPacket &recvData)
Definition GroupHandler.cpp:663

WorldSession::m_clientTimeDelay
uint32 m_clientTimeDelay
Definition WorldSession.h:1212

WorldSession::SendLfgClearStatus
void SendLfgClearStatus(uint64 lfgGroupGuid=0, uint8 queueIdOverride=0, bool groupLeave=false)
Definition LFGHandler.cpp:1048

WorldSession::HandleGuildSetRankPermissionsOpcode
void HandleGuildSetRankPermissionsOpcode(WorldPacket &recvPacket)
Definition GuildHandler.cpp:627

WorldSession::CheckStableMaster
bool CheckStableMaster(uint64 guid)
Definition PetHandler.cpp:1130

WorldSession::SendPetNameInvalid
void SendPetNameInvalid(uint32 error, std::string const &name, DeclinedName *declinedName, uint32 petNumber)
Definition PetHandler.cpp:1356

WorldSession::HandleGMTicketUpdateOpcode
void HandleGMTicketUpdateOpcode(WorldPacket &recvPacket)
Definition TicketHandler.cpp:114

WorldSession::HandleCalendarEventSignup
void HandleCalendarEventSignup(WorldPacket &recvData)
Definition CalendarHandler.cpp:558

WorldSession::HandleCalendarEventModeratorStatus
void HandleCalendarEventModeratorStatus(WorldPacket &recvData)
Definition CalendarHandler.cpp:692

WorldSession::SendStablePet
void SendStablePet(uint64 guid)
Definition NPCHandler.cpp:502

WorldSession::HandleWhoisOpcode
void HandleWhoisOpcode(WorldPacket &recvData)
Definition MiscHandler.cpp:1930

WorldSession::GetSecurity
AccountTypes GetSecurity() const
Definition WorldSession.h:293

WorldSession::GetSessionDbLocaleIndex
LocaleConstant GetSessionDbLocaleIndex() const
Definition WorldSession.h:492

WorldSession::SendLearnNewTaxiNode
bool SendLearnNewTaxiNode(Creature *unit)
Definition TaxiHandler.cpp:153

WorldSession::HandleRespecWipeConfirmOpcode
void HandleRespecWipeConfirmOpcode(WorldPacket &recvPacket)
Definition SkillHandler.cpp:67

WorldSession::HandleCharFactionOrRaceChange
void HandleCharFactionOrRaceChange(WorldPacket &recvData)
Definition CharacterHandler.cpp:2382

WorldSession::HandleAddIgnoreOpcodeCallBack
void HandleAddIgnoreOpcodeCallBack(PreparedQueryResult result)
Definition MiscHandler.cpp:1332

WorldSession::HandleQuestConfirmAccept
void HandleQuestConfirmAccept(WorldPacket &recvData)
Definition QuestHandler.cpp:526

WorldSession::HandleBfQueueInviteResponse
void HandleBfQueueInviteResponse(WorldPacket &recvData)
Definition BattlefieldHandler.cpp:178

WorldSession::HandleCalendarUpdateEvent
void HandleCalendarUpdateEvent(WorldPacket &recvData)
Definition CalendarHandler.cpp:335

WorldSession::PlayerDisconnected
bool PlayerDisconnected() const
Definition WorldSession.h:263

WorldSession::LoadPermissions
void LoadPermissions()
Definition WorldSession.cpp:1225

WorldSession::SendNameQueryOpcode
void SendNameQueryOpcode(ObjectGuid guid)
Definition QueryHandler.cpp:22

WorldSession::HandleQuestLogRemoveQuest
void HandleQuestLogRemoveQuest(WorldPacket &recvData)
Definition QuestHandler.cpp:487

WorldSession::HandleBattlePetRequestJournal
void HandleBattlePetRequestJournal(WorldPacket &recvData)
Definition BattlePetHandler.cpp:1215

WorldSession::SendQuestgiverStatusMultiple
void SendQuestgiverStatusMultiple()
Definition QuestHandler.cpp:828

WorldSession::HandleSetWatchedFactionOpcode
void HandleSetWatchedFactionOpcode(WorldPacket &recvData)
Definition CharacterHandler.cpp:1842

WorldSession::HandleBattlefieldLeaveOpcode
void HandleBattlefieldLeaveOpcode(WorldPacket &recvData)
Definition BattleGroundHandler.cpp:555

WorldSession::SendTaxiMenu
void SendTaxiMenu(Creature *unit)
Definition TaxiHandler.cpp:106

WorldSession::HandleSwapItem
void HandleSwapItem(WorldPacket &recvPacket)
Definition ItemHandler.cpp:142

WorldSession::HandleSetActionButtonOpcode
void HandleSetActionButtonOpcode(WorldPacket &recvPacket)
Definition MiscHandler.cpp:1736

WorldSession::HandleBlackMarketRequestItemOpcode
void HandleBlackMarketRequestItemOpcode(WorldPacket &recvData)
Definition BlackMarketHandler.cpp:36

WorldSession::SendAuctionBidderNotification
void SendAuctionBidderNotification(uint32 location, uint32 auctionId, uint64 bidder, uint32 bidSum, uint32 diff, uint32 item_template)
Definition AuctionHouseHandler.cpp:140

WorldSession::HandleNameQueryOpcode
void HandleNameQueryOpcode(WorldPacket &recvPacket)
Definition QueryHandler.cpp:107

WorldSession::HandleSetFactionNotAtWar
void HandleSetFactionNotAtWar(WorldPacket &recvData)
Definition CharacterHandler.cpp:1797

WorldSession::HandleDuelProposedOpcode
void HandleDuelProposedOpcode(WorldPacket &recvPacket)
Definition DuelHandler.cpp:18

WorldSession::HandleStableRevivePet
void HandleStableRevivePet(WorldPacket &recvPacket)
Definition NPCHandler.cpp:760

WorldSession::SendAuctionRemovedNotification
void SendAuctionRemovedNotification(uint32 auctionId, uint32 itemEntry, int32 randomPropertyId)
Definition AuctionHouseHandler.cpp:177

WorldSession::HandleGMTicketCaseStatusOpcode
void HandleGMTicketCaseStatusOpcode(WorldPacket &recvPacket)
Definition TicketHandler.cpp:177

WorldSession::SendLfgTeleportError
void SendLfgTeleportError(uint8 err)
Definition LFGHandler.cpp:1075

WorldSession::HandleGuildPromoteOpcode
void HandleGuildPromoteOpcode(WorldPacket &recvPacket)
Definition GuildHandler.cpp:127

WorldSession::HandleRaidTargetUpdateOpcode
void HandleRaidTargetUpdateOpcode(WorldPacket &recvData)
Definition GroupHandler.cpp:632

WorldSession::HandleSetFactionInactiveOpcode
void HandleSetFactionInactiveOpcode(WorldPacket &recvData)
Definition CharacterHandler.cpp:1850

WorldSession::HandleTextEmoteOpcode
void HandleTextEmoteOpcode(WorldPacket &recvPacket)
Definition ChatHandler.cpp:738

WorldSession::HandleSetCollisionHeightAck
void HandleSetCollisionHeightAck(WorldPacket &recvPacket)
Definition MovementHandler.cpp:818

WorldSession::HandleQuestgiverQuestAutoLaunch
void HandleQuestgiverQuestAutoLaunch(WorldPacket &recvPacket)
Definition QuestHandler.cpp:619

WorldSession::HandleComplainOpcode
void HandleComplainOpcode(WorldPacket &recvData)
Definition MiscHandler.cpp:1993

WorldSession::HandleBattlePetFinalNotify
void HandleBattlePetFinalNotify(WorldPacket &recvData)
Definition BattlePetHandler.cpp:1577

WorldSession::HandleLFDSetBootVoteOpcode
void HandleLFDSetBootVoteOpcode(WorldPacket &recvData)
Definition LFGHandler.cpp:288

WorldSession::m_playerLoading
bool m_playerLoading
Definition WorldSession.h:1205

WorldSession::HandleBattlePetCage
void HandleBattlePetCage(WorldPacket &recvData)
Definition BattlePetHandler.cpp:1797

WorldSession::HandleGuildMOTDOpcode
void HandleGuildMOTDOpcode(WorldPacket &recvPacket)
Definition GuildHandler.cpp:186

WorldSession::HandleChannelList
void HandleChannelList(WorldPacket &recvPacket)
Definition ChannelHandler.cpp:74

WorldSession::HandleBinderActivateOpcode
void HandleBinderActivateOpcode(WorldPacket &recvPacket)
Definition NPCHandler.cpp:442

WorldSession::HandleDelIgnoreOpcode
void HandleDelIgnoreOpcode(WorldPacket &recvPacket)
Definition MiscHandler.cpp:1369

WorldSession::HandleClearTradeItemOpcode
void HandleClearTradeItemOpcode(WorldPacket &recvPacket)
Definition TradeHandler.cpp:797

WorldSession::AddonsList
std::list< AddonInfo > AddonsList
Definition WorldSession.h:1198

WorldSession::HandleWhoOpcode
void HandleWhoOpcode(WorldPacket &recvPacket)
Definition MiscHandler.cpp:727

WorldSession::HandleAutoStoreBagItemOpcode
void HandleAutoStoreBagItemOpcode(WorldPacket &recvPacket)
Definition ItemHandler.cpp:833

WorldSession::HandleAuctionSellItem
void HandleAuctionSellItem(WorldPacket &recvData)
Definition AuctionHouseHandler.cpp:187

WorldSession::HandleGuildReplaceGuildMaster
void HandleGuildReplaceGuildMaster(WorldPacket &recvPacket)
Definition GuildHandler.cpp:776

WorldSession::HandlePlayerLogin
void HandlePlayerLogin(LoginQueryHolder *holder)
Definition CharacterHandler.cpp:1440

WorldSession::HandleSummonResponseOpcode
void HandleSummonResponseOpcode(WorldPacket &recvData)
Definition MovementHandler.cpp:797

WorldSession::QueuePacket
void QueuePacket(WorldPacket *new_packet)
Add an incoming packet to the queue.
Definition WorldSession.cpp:274

WorldSession::HandleChannelPassword
void HandleChannelPassword(WorldPacket &recvPacket)
Definition ChannelHandler.cpp:88

WorldSession::HandleSetPetSpecialization
void HandleSetPetSpecialization(WorldPacket &recvData)
Definition PetHandler.cpp:1390

WorldSession::HandleSetTradeItemOpcode
void HandleSetTradeItemOpcode(WorldPacket &recvPacket)
Definition TradeHandler.cpp:743

WorldSession::AntiDOS
class WorldSession::DosProtection AntiDOS

WorldSession::SendCalendarRaidLockoutUpdated
void SendCalendarRaidLockoutUpdated(InstanceSave const *save)
Definition CalendarHandler.cpp:844

WorldSession::HandleUnacceptTradeOpcode
void HandleUnacceptTradeOpcode(WorldPacket &recvPacket)
Definition TradeHandler.cpp:577

WorldSession::LoadAccountData
void LoadAccountData(PreparedQueryResult result, uint32 mask)
Definition WorldSession.cpp:742

WorldSession::PlayerRecentlyLoggedOut
bool PlayerRecentlyLoggedOut() const
Definition WorldSession.h:262

WorldSession::HandleChannelVoiceOnOpcode
void HandleChannelVoiceOnOpcode(WorldPacket &recvData)
Definition VoiceChatHandler.cpp:20

WorldSession::HandleWrapItemOpcode
void HandleWrapItemOpcode(WorldPacket &recvPacket)
Definition ItemHandler.cpp:1113

WorldSession::HandleAutoStoreBankItemOpcode
void HandleAutoStoreBankItemOpcode(WorldPacket &recvPacket)
Definition ItemHandler.cpp:974

WorldSession::SendLoadCUFProfiles
void SendLoadCUFProfiles()
Definition MiscHandler.cpp:2840

WorldSession::HandleMoveTimeSkippedOpcode
void HandleMoveTimeSkippedOpcode(WorldPacket &recvData)
Definition MiscHandler.cpp:1764

WorldSession::m_timeOutTime
std::atomic< time_t > m_timeOutTime
Definition WorldSession.h:500

WorldSession::GetCompressionStream
z_stream_s * GetCompressionStream()
Definition WorldSession.h:519

WorldSession::PlayerLogout
bool PlayerLogout() const
Definition WorldSession.h:260

WorldSession::HandleRepopRequestOpcode
void HandleRepopRequestOpcode(WorldPacket &recvPacket)
Definition MiscHandler.cpp:620

WorldSession::SendLfgLfrList
void SendLfgLfrList(bool update)
Definition LFGHandler.cpp:1039

WorldSession::HandleCharCreateCallback
void HandleCharCreateCallback(PreparedQueryResult result, CharacterCreateInfo *createInfo)
Definition CharacterHandler.cpp:1053

WorldSession::HandleLoadScreenOpcode
void HandleLoadScreenOpcode(WorldPacket &recvPacket)
Definition CharacterHandler.cpp:1431

WorldSession::_addFriendCallback
QueryCallback< PreparedQueryResult, std::string > _addFriendCallback
Definition WorldSession.h:1125

WorldSession::HandleCancelMountAuraOpcode
void HandleCancelMountAuraOpcode(WorldPacket &recvData)
Definition MiscHandler.cpp:2269

WorldSession::HandleStablePet
void HandleStablePet(WorldPacket &recvPacket)
Definition NPCHandler.cpp:573

WorldSession::HandleSetTradeGoldOpcode
void HandleSetTradeGoldOpcode(WorldPacket &recvPacket)
Definition TradeHandler.cpp:722

WorldSession::HandleMovementOpcodes
void HandleMovementOpcodes(WorldPacket &recvPacket)
Definition MovementHandler.cpp:486

WorldSession::HandleBattlefieldStatusOpcode
void HandleBattlefieldStatusOpcode(WorldPacket &recvData)
Definition BattleGroundHandler.cpp:568

WorldSession::HandleResurrectResponseOpcode
void HandleResurrectResponseOpcode(WorldPacket &recvPacket)
Definition MiscHandler.cpp:1445

WorldSession::HandleRandomizeCharNameOpcode
void HandleRandomizeCharNameOpcode(WorldPacket &recvData)
Definition CharacterHandler.cpp:2938

WorldSession::HandleUpdateProjectilePosition
void HandleUpdateProjectilePosition(WorldPacket &recvPacket)
Definition SpellHandler.cpp:1868

WorldSession::HandlePetBattleRequestPvp
void HandlePetBattleRequestPvp(WorldPacket &recvData)
Definition BattlePetHandler.cpp:967

WorldSession::UpdateTimeOutTime
void UpdateTimeOutTime(uint32 diff)
Definition WorldSession.h:501

WorldSession::GetSessionDbcLocale
LocaleConstant GetSessionDbcLocale() const
Definition WorldSession.h:491

WorldSession::HandleRaidReadyCheckConfirmOpcode
void HandleRaidReadyCheckConfirmOpcode(WorldPacket &recvData)
Definition GroupHandler.cpp:889

WorldSession::HandlePetitionShowListOpcode
void HandlePetitionShowListOpcode(WorldPacket &recvPacket)
Definition PetitionsHandler.cpp:719

WorldSession::HandleTutorialFlag
void HandleTutorialFlag(WorldPacket &recvData)
Definition CharacterHandler.cpp:1814

WorldSession::GetPlayerInfo
std::string GetPlayerInfo() const
Definition WorldSession.cpp:178

WorldSession::HandleVoidSwapItem
void HandleVoidSwapItem(WorldPacket &recvData)
Definition VoidStorageHandler.cpp:355

WorldSession::HandleQuestQueryOpcode
void HandleQuestQueryOpcode(WorldPacket &recvPacket)
Definition QuestHandler.cpp:314

WorldSession::HandleLootMethodOpcode
void HandleLootMethodOpcode(WorldPacket &recvPacket)
Definition GroupHandler.cpp:506

WorldSession::HandleSelectFactionOpcode
void HandleSelectFactionOpcode(WorldPacket &recvPacket)
Definition MiscHandler.cpp:2904

WorldSession::HandleGuildBankDepositMoney
void HandleGuildBankDepositMoney(WorldPacket &recvData)
Definition GuildHandler.cpp:396

WorldSession::HandleItemRefund
void HandleItemRefund(WorldPacket &recvData)
Definition ItemHandler.cpp:1525

WorldSession::HandleSaveCUFProfiles
void HandleSaveCUFProfiles(WorldPacket &recvPacket)
Definition MiscHandler.cpp:2772

WorldSession::HandleSetFactionCheat
void HandleSetFactionCheat(WorldPacket &recvData)
Definition CharacterHandler.cpp:1808

WorldSession::GetRecruiterId
uint32 GetRecruiterId() const
Definition WorldSession.h:512

WorldSession::HandleTurnInPetitionOpcode
void HandleTurnInPetitionOpcode(WorldPacket &recvData)
Definition PetitionsHandler.cpp:585

WorldSession::SendPetitionSignResults
void SendPetitionSignResults(ObjectGuid petitionGuid, ObjectGuid playerGuid, uint8 result)
Definition PetitionsHandler.cpp:760

WorldSession::m_accountData
AccountData m_accountData[uint8(AccountDataType::NUM_ACCOUNT_DATA_TYPES)]
Definition WorldSession.h:1213

WorldSession::SendLfgPlayerReward
void SendLfgPlayerReward(lfg::LfgPlayerRewardData const &lfgPlayerRewardData)
Definition LFGHandler.cpp:875

WorldSession::HandleCalendarComplain
void HandleCalendarComplain(WorldPacket &recvData)
Definition CalendarHandler.cpp:731

WorldSession::m_GUIDLow
uint32 m_GUIDLow
Definition WorldSession.h:1187

WorldSession::SendAuctionOwnerNotification
void SendAuctionOwnerNotification(AuctionEntry *auction)
Definition AuctionHouseHandler.cpp:161

WorldSession::SendCrossedInebriationThreshold
void SendCrossedInebriationThreshold(ObjectGuid guid, uint32 ItemID, DrunkenState drunkenState)
Definition MiscHandler.cpp:2986

WorldSession::HandleGuildAchievementProgressQuery
void HandleGuildAchievementProgressQuery(WorldPacket &recvData)
Definition MiscHandler.cpp:2327

WorldSession::HandleQuestgiverAcceptQuestOpcode
void HandleQuestgiverAcceptQuestOpcode(WorldPacket &recvPacket)
Definition QuestHandler.cpp:105

WorldSession::HandleGuildBankBuyTab
void HandleGuildBankBuyTab(WorldPacket &recvData)
Definition GuildHandler.cpp:520

WorldSession::HandlePetitionShowSignOpcode
void HandlePetitionShowSignOpcode(WorldPacket &recvData)
Definition PetitionsHandler.cpp:143

WorldSession::SendAuthWaitQue
void SendAuthWaitQue(uint32 position)
Handle the authentication waiting queue (to be completed).
Definition WorldSession.cpp:711

WorldSession::GetPlayer
Player * GetPlayer() const
Definition WorldSession.h:295

WorldSession::_RBACData
rbac::RBACData * _RBACData
Definition WorldSession.h:1225

WorldSession::HandleAutoEquipItemSlotOpcode
void HandleAutoEquipItemSlotOpcode(WorldPacket &recvPacket)
Definition ItemHandler.cpp:88

WorldSession::HandleItemRefundInfoRequest
void HandleItemRefundInfoRequest(WorldPacket &recvData)
Definition ItemHandler.cpp:1506

WorldSession::HandleBusyTradeOpcode
void HandleBusyTradeOpcode(WorldPacket &recvPacket)
Definition TradeHandler.cpp:68

WorldSession::PlayerLogoutWithSave
bool PlayerLogoutWithSave() const
Definition WorldSession.h:261

WorldSession::PlayerLoading
bool PlayerLoading() const
Definition WorldSession.h:259

WorldSession::HandleSwapInvItemOpcode
void HandleSwapInvItemOpcode(WorldPacket &recvPacket)
Definition ItemHandler.cpp:58

WorldSession::HandleLootOpcode
void HandleLootOpcode(WorldPacket &recvPacket)
Definition LootHandler.cpp:293

WorldSession::Handle_NULL
void Handle_NULL(WorldPacket &recvPacket)
Definition WorldSession.cpp:672

WorldSession::_charEnumCallback
PreparedQueryResultFuture _charEnumCallback
Definition WorldSession.h:1121

WorldSession::HandleCancelCastOpcode
void HandleCancelCastOpcode(WorldPacket &recvPacket)
Definition SpellHandler.cpp:1631

WorldSession::HandleQuestgiverStatusQueryOpcode
void HandleQuestgiverStatusQueryOpcode(WorldPacket &recvPacket)
Definition QuestHandler.cpp:22

WorldSession::SendTrainerBuyFailed
void SendTrainerBuyFailed(ObjectGuid guid, uint32 spellId, uint32 reason)
Definition NPCHandler.cpp:279

WorldSession::HandlePVPLogDataOpcode
void HandlePVPLogDataOpcode(WorldPacket &recvData)
Definition BattleGroundHandler.cpp:337

WorldSession::HandleBattlePetQuitNotify
void HandleBattlePetQuitNotify(WorldPacket &recvData)
Definition BattlePetHandler.cpp:1592

WorldSession::LogUnexpectedOpcode
void LogUnexpectedOpcode(WorldPacket *packet, const char *status, const char *reason) const
Logging helper for unexpected opcodes.
Definition WorldSession.cpp:281

WorldSession::SetVirtualRealmID
void SetVirtualRealmID(uint32 VRealmID)
Definition WorldSession.h:290

WorldSession::SendBindPoint
void SendBindPoint(Creature *npc)
Definition NPCHandler.cpp:466

WorldSession::HandleCalendarAddEvent
void HandleCalendarAddEvent(WorldPacket &recvData)
Definition CalendarHandler.cpp:248

WorldSession::IsARecruiter
bool IsARecruiter() const
Definition WorldSession.h:513

WorldSession::HandleDelFriendOpcode
void HandleDelFriendOpcode(WorldPacket &recvPacket)
Definition MiscHandler.cpp:1300

WorldSession::HandleQuestgiverCompleteQuest
void HandleQuestgiverCompleteQuest(WorldPacket &recvData)
Definition QuestHandler.cpp:559

WorldSession::HandlePetSetAction
void HandlePetSetAction(WorldPacket &recvData)
Definition PetHandler.cpp:1153

WorldSession::HandleMailTakeItem
void HandleMailTakeItem(WorldPacket &recvData)
Definition MailHandler.cpp:759

WorldSession::~WorldSession
~WorldSession()
WorldSession destructor.
Definition WorldSession.cpp:140

WorldSession::HandleGMResponseResolve
void HandleGMResponseResolve(WorldPacket &recvPacket)
Definition TicketHandler.cpp:267

WorldSession::HandleMailTakeMoney
void HandleMailTakeMoney(WorldPacket &recvData)
Definition MailHandler.cpp:847

WorldSession::SendAuctionCommandResult
void SendAuctionCommandResult(AuctionEntry *auction, uint32 Action, uint32 ErrorCode, uint32 bidError=0)
Definition AuctionHouseHandler.cpp:83

WorldSession::HandleGroupInviteOpcode
void HandleGroupInviteOpcode(WorldPacket &recvPacket)
Definition GroupHandler.cpp:96

WorldSession::HandleChangePlayerNameOpcodeCallBack
void HandleChangePlayerNameOpcodeCallBack(PreparedQueryResult result, std::string const &newName)
Definition CharacterHandler.cpp:1932

WorldSession::HandleGetMailList
void HandleGetMailList(WorldPacket &recvData)
Definition MailHandler.cpp:883

WorldSession::HandleRequestPvpReward
void HandleRequestPvpReward(WorldPacket &recvData)
Definition BattleGroundHandler.cpp:774

WorldSession::HandleGuildEventLogQueryOpcode
void HandleGuildEventLogQueryOpcode(WorldPacket &recvPacket)
Definition GuildHandler.cpp:321

WorldSession::HandleSelfResOpcode
void HandleSelfResOpcode(WorldPacket &recvData)
Definition SpellHandler.cpp:1712

WorldSession::HandleEquipmentSetDelete
void HandleEquipmentSetDelete(WorldPacket &recvData)
Definition CharacterHandler.cpp:2316

WorldSession::HandleBugOpcode
void HandleBugOpcode(WorldPacket &recvPacket)
Definition MiscHandler.cpp:1389

WorldSession::HandleTrainerListOpcode
void HandleTrainerListOpcode(WorldPacket &recvPacket)
Definition NPCHandler.cpp:84

WorldSession::HandleGuildSetAchievementTracking
void HandleGuildSetAchievementTracking(WorldPacket &recvPacket)
Definition GuildHandler.cpp:217

WorldSession::HandleContactListOpcode
void HandleContactListOpcode(WorldPacket &recvPacket)
Definition MiscHandler.cpp:1218

WorldSession::SendSpiritResurrect
void SendSpiritResurrect()
Definition NPCHandler.cpp:409

WorldSession::HandleBfEntryInviteResponse
void HandleBfEntryInviteResponse(WorldPacket &recvData)
Definition BattlefieldHandler.cpp:200

WorldSession::HandleCastSpellOpcode
void HandleCastSpellOpcode(WorldPacket &recvPacket)
Definition SpellHandler.cpp:1479

WorldSession::HandleLfgGetStatus
void HandleLfgGetStatus(WorldPacket &recvData)
Definition LFGHandler.cpp:543

WorldSession::Handle_EarlyProccess
void Handle_EarlyProccess(WorldPacket &recvPacket)
Definition WorldSession.cpp:685

WorldSession::HandleAutoEquipItemOpcode
void HandleAutoEquipItemOpcode(WorldPacket &recvPacket)
Definition ItemHandler.cpp:192

WorldSession::HandleLootRoll
void HandleLootRoll(WorldPacket &recvData)
Definition GroupHandler.cpp:536

WorldSession::HandleLearnPreviewTalentsPet
void HandleLearnPreviewTalentsPet(WorldPacket &recvPacket)
Definition PetHandler.cpp:1385

WorldSession::HandleCreatureQueryOpcode
void HandleCreatureQueryOpcode(WorldPacket &recvPacket)
Only static data is sent in this packet !!!
Definition QueryHandler.cpp:182

WorldSession::HandleOpeningCinematic
void HandleOpeningCinematic(WorldPacket &recvData)
Definition CharacterHandler.cpp:2983

WorldSession::_charRenameCallback
QueryCallback< PreparedQueryResult, std::string > _charRenameCallback
Definition WorldSession.h:1124

WorldSession::HandleMirrorImageDataRequest
void HandleMirrorImageDataRequest(WorldPacket &recvData)
Definition SpellHandler.cpp:1751

WorldSession::ClearPetBattlePvpQueueState
void ClearPetBattlePvpQueueState()
Definition BattlePetHandler.cpp:858

WorldSession::Handle_EarlyProccessContinued
void Handle_EarlyProccessContinued(WorldPacket &recvPacket)
Definition WorldSession.cpp:691

WorldSession::HandleShowingCloakOpcode
void HandleShowingCloakOpcode(WorldPacket &recvData)
Definition CharacterHandler.cpp:1874

WorldSession::SendItemEnchantTimeUpdate
void SendItemEnchantTimeUpdate(ObjectGuid Playerguid, ObjectGuid Itemguid, uint32 slot, uint32 Duration)
Definition ItemHandler.cpp:1068

WorldSession::HandleTotemDestroyed
void HandleTotemDestroyed(WorldPacket &recvData)
Definition SpellHandler.cpp:1692

WorldSession::HandleReforgeItemOpcode
void HandleReforgeItemOpcode(WorldPacket &recvData)
Definition ItemHandler.cpp:1785

WorldSession::HandlePlayerLogoutOpcode
void HandlePlayerLogoutOpcode(WorldPacket &recvPacket)
Definition MiscHandler.cpp:1085

WorldSession::SendLfgUpdateStatus
void SendLfgUpdateStatus(lfg::LfgUpdateData const &updateData, bool party, uint64 queueGuidOverride=0, uint8 queueIdOverride=0)
Definition LFGHandler.cpp:593

WorldSession::HandleReadItem
void HandleReadItem(WorldPacket &recvPacket)
Definition ItemHandler.cpp:332

WorldSession::LoadTutorialsData
void LoadTutorialsData()
Definition WorldSession.cpp:822

WorldSession::SendBarberShopResult
void SendBarberShopResult(BarberShopResult result)
Definition CharacterHandler.cpp:2138

WorldSession::_addIgnoreCallback
PreparedQueryResultFuture _addIgnoreCallback
Definition WorldSession.h:1122

WorldSession::SendCancelTrade
void SendCancelTrade(TradeStatus status)
Definition TradeHandler.cpp:596

WorldSession::HandleGroupDisbandOpcode
void HandleGroupDisbandOpcode(WorldPacket &recvPacket)
Definition GroupHandler.cpp:473

WorldSession::SendPageText
void SendPageText(ObjectGuid GameObjectGUID)
Definition MiscHandler.cpp:2971

WorldSession::HandleJoinChannel
void HandleJoinChannel(WorldPacket &recvPacket)
Definition ChannelHandler.cpp:11

WorldSession::World
friend class World
Definition WorldSession.h:1132

WorldSession::HandleBuyStableSlot
void HandleBuyStableSlot(WorldPacket &recvPacket)
Definition NPCHandler.cpp:727

WorldSession::HandleGameobjectReportUse
void HandleGameobjectReportUse(WorldPacket &recvPacket)
Definition SpellHandler.cpp:1451

WorldSession::HandlePetSpellAutocastOpcode
void HandlePetSpellAutocastOpcode(WorldPacket &recvPacket)
Definition PetHandler.cpp:1268

WorldSession::HandleTransmogrifyItems
void HandleTransmogrifyItems(WorldPacket &recvData)
Definition ItemHandler.cpp:1570

WorldSession::SendTabardVendorActivate
void SendTabardVendorActivate(uint64 guid)
Definition NPCHandler.cpp:40

WorldSession::HandleStableSwapPetCallback
void HandleStableSwapPetCallback(PreparedQueryResult result, uint32 petId)
Definition NPCHandler.cpp:802

WorldSession::HandleReturnToGraveyard
void HandleReturnToGraveyard(WorldPacket &recvPacket)
Definition MiscHandler.cpp:1161

WorldSession::HandleSetRaidDifficultyOpcode
void HandleSetRaidDifficultyOpcode(WorldPacket &recvData)
Definition MiscHandler.cpp:2203

WorldSession::HandleCalendarEventRemoveInvite
void HandleCalendarEventRemoveInvite(WorldPacket &recvData)
Definition CalendarHandler.cpp:624

WorldSession::SendBfEntered
void SendBfEntered(uint64 guid)
Definition BattlefieldHandler.cpp:130

WorldSession::HandleGuildFinderRemoveApplication
void HandleGuildFinderRemoveApplication(WorldPacket &recvPacket)
Definition GuildFinderHandler.cpp:312

WorldSession::HandleBeginTradeOpcode
void HandleBeginTradeOpcode(WorldPacket &recvPacket)
Definition TradeHandler.cpp:586

WorldSession::HandleRequestVehicleExit
void HandleRequestVehicleExit(WorldPacket &recvData)
Definition VehicleHandler.cpp:213

WorldSession::HandleAutostoreLootItemOpcode
void HandleAutostoreLootItemOpcode(WorldPacket &recvPacket)
Definition LootHandler.cpp:26

WorldSession::HandleTaxiNodeStatusQueryOpcode
void HandleTaxiNodeStatusQueryOpcode(WorldPacket &recvPacket)
Definition TaxiHandler.cpp:19

WorldSession::HandleAuctionHelloOpcode
void HandleAuctionHelloOpcode(WorldPacket &recvPacket)
Definition AuctionHouseHandler.cpp:21

WorldSession::HandleQueryGuildBankTabText
void HandleQueryGuildBankTabText(WorldPacket &recvData)
Definition GuildHandler.cpp:586

WorldSession::GetVirtualRealmID
uint32 GetVirtualRealmID() const
Definition WorldSession.h:291

WorldSession::HandleCancelTradeOpcode
void HandleCancelTradeOpcode(WorldPacket &recvPacket)
Definition TradeHandler.cpp:604

WorldSession::SendAddonsInfo
void SendAddonsInfo()
Definition WorldSession.cpp:935

WorldSession::HandleSubmitBugOpcode
void HandleSubmitBugOpcode(WorldPacket &recvPacket)
Definition TicketHandler.cpp:289

WorldSession::HandleBankerActivateOpcode
void HandleBankerActivateOpcode(WorldPacket &recvPacket)
Definition NPCHandler.cpp:51

WorldSession::HandleRequestCategoryCooldowns
void HandleRequestCategoryCooldowns(WorldPacket &recvPacket)
Definition SpellHandler.cpp:1895

WorldSession::HandleForceSpeedChangeAck
void HandleForceSpeedChangeAck(WorldPacket &recvData)
Definition MovementHandler.cpp:652

WorldSession::recruiterId
uint32 recruiterId
Definition WorldSession.h:1219

WorldSession::_unstablePetCallback
QueryCallback< PreparedQueryResult, uint32 > _unstablePetCallback
Definition WorldSession.h:1126

WorldSession::HandleOptOutOfLootOpcode
void HandleOptOutOfLootOpcode(WorldPacket &recvData)
Definition GroupHandler.cpp:1276

WorldSession::SendPlayerAmbiguousNotice
void SendPlayerAmbiguousNotice(std::string const &name)
Definition ChatHandler.cpp:837

WorldSession::_charLoginCallback
QueryResultHolderFuture _charLoginCallback
Definition WorldSession.h:1130

WorldSession::HandleGuildSetGuildMaster
void HandleGuildSetGuildMaster(WorldPacket &recvPacket)
Definition GuildHandler.cpp:765

WorldSession::HandleGossipHelloOpcode
void HandleGossipHelloOpcode(WorldPacket &recvPacket)
Definition NPCHandler.cpp:291

WorldSession::HandleGroupChangeSubGroupOpcode
void HandleGroupChangeSubGroupOpcode(WorldPacket &recvData)
Definition GroupHandler.cpp:692

WorldSession::SendBlackMarketRequestItemsResult
void SendBlackMarketRequestItemsResult()
Definition BlackMarketHandler.cpp:46

WorldSession::HandleStandStateChangeOpcode
void HandleStandStateChangeOpcode(WorldPacket &recvPacket)
Definition MiscHandler.cpp:1210

WorldSession::HandleGroupInitiatePollRole
void HandleGroupInitiatePollRole(WorldPacket &recvData)
Definition GroupHandler.cpp:1293

WorldSession::m_playerLogout
bool m_playerLogout
Definition WorldSession.h:1206

WorldSession::HandlePetAction
void HandlePetAction(WorldPacket &recvData)
Definition PetHandler.cpp:770

WorldSession::HandleRideVehicleInteract
void HandleRideVehicleInteract(WorldPacket &recvData)
Definition VehicleHandler.cpp:128

WorldSession::HandleGameObjectQueryOpcode
void HandleGameObjectQueryOpcode(WorldPacket &recvPacket)
Only static data is sent in this packet !!!
Definition QueryHandler.cpp:265

WorldSession::HandleGuildBankLogQuery
void HandleGuildBankLogQuery(WorldPacket &recvData)
Definition GuildHandler.cpp:575

WorldSession::HandleReadyForAccountDataTimes
void HandleReadyForAccountDataTimes(WorldPacket &recvData)
Definition MiscHandler.cpp:2345

WorldSession::HandleChallengeModeRequestLeaders
void HandleChallengeModeRequestLeaders(WorldPacket &recvData)
Definition ChallengeModeHandler.cpp:25

WorldSession::UpdatePetBattlePvpQueueState
void UpdatePetBattlePvpQueueState()
Definition BattlePetHandler.cpp:848

WorldSession::BuildPartyMemberStatsChangedPacket
void BuildPartyMemberStatsChangedPacket(Player *player, WorldPacket *data)
Definition GroupHandler.cpp:977

WorldSession::HandleQuestgiverHelloOpcode
void HandleQuestgiverHelloOpcode(WorldPacket &recvPacket)
Definition QuestHandler.cpp:74

WorldSession::SendActivateTaxiReply
void SendActivateTaxiReply(ActivateTaxiReply reply)
Definition TaxiHandler.cpp:324

WorldSession::HandleBuyItemOpcode
void HandleBuyItemOpcode(WorldPacket &recvPacket)
Definition ItemHandler.cpp:578

WorldSession::HandleCharDeleteOpcode
void HandleCharDeleteOpcode(WorldPacket &recvPacket)
Definition CharacterHandler.cpp:1334

WorldSession::_accountId
uint32 _accountId
Definition WorldSession.h:1193

WorldSession::HandleVoidStorageQuery
void HandleVoidStorageQuery(WorldPacket &recvData)
Definition VoidStorageHandler.cpp:53

WorldSession::HandleReorderCharacters
void HandleReorderCharacters(WorldPacket &recvData)
Definition CharacterHandler.cpp:2965

WorldSession::HandleDuelResponseOpcode
void HandleDuelResponseOpcode(WorldPacket &recvPacket)
Definition DuelHandler.cpp:34

WorldSession::HandleMoveWorldportAckOpcode
void HandleMoveWorldportAckOpcode()
Definition MovementHandler.cpp:279

WorldSession::HandleGuildAcceptOpcode
void HandleGuildAcceptOpcode(WorldPacket &recvPacket)
Definition GuildHandler.cpp:91

WorldSession::HandleCorpseQueryOpcode
void HandleCorpseQueryOpcode(WorldPacket &recvPacket)
Definition QueryHandler.cpp:337

WorldSession::HandleCharEnum
void HandleCharEnum(PreparedQueryResult result)
Definition CharacterHandler.cpp:817

WorldSession::HandleMoveSetCanTurnWhileFallingAck
void HandleMoveSetCanTurnWhileFallingAck(WorldPacket &recvData)
Definition MovementHandler.cpp:832

WorldSession::SendTitleEarned
void SendTitleEarned(uint32 TitleIndex)
Definition MiscHandler.cpp:2069

WorldSession::HandlePetitionBuyOpcode
void HandlePetitionBuyOpcode(WorldPacket &recvData)
Definition PetitionsHandler.cpp:27

WorldSession::HandleNpcTextQueryOpcode
void HandleNpcTextQueryOpcode(WorldPacket &recvPacket)
Definition QueryHandler.cpp:400

WorldSession::SetInQueue
void SetInQueue(bool state)
Session in auth.queue currently.
Definition WorldSession.h:308

WorldSession::HandleQuestgiverRequestRewardOpcode
void HandleQuestgiverRequestRewardOpcode(WorldPacket &recvPacket)
Definition QuestHandler.cpp:437

WorldSession::HandleChannelUnban
void HandleChannelUnban(WorldPacket &recvPacket)
Definition ChannelHandler.cpp:273

WorldSession::HandleBattlemasterHelloOpcode
void HandleBattlemasterHelloOpcode(WorldPacket &recvData)
Definition BattleGroundHandler.cpp:25

WorldSession::m_latency
uint32 m_latency
Definition WorldSession.h:1211

WorldSession::HandleUpdateMissileTrajectory
void HandleUpdateMissileTrajectory(WorldPacket &recvPacket)
Definition MiscHandler.cpp:2710

WorldSession::HandleLearnPreviewTalents
void HandleLearnPreviewTalents(WorldPacket &recvPacket)
Definition SkillHandler.cpp:62

WorldSession::HandleMoveWaterWalkAck
void HandleMoveWaterWalkAck(WorldPacket &recvPacket)
Definition MovementHandler.cpp:778

WorldSession::getDialogStatus
uint32 getDialogStatus(Player *player, Object *questgiver, uint32 defstatus)
Definition QuestHandler.cpp:720

WorldSession::HandleBattleCharBoost
void HandleBattleCharBoost(WorldPacket &recvPacket)
Definition BoostHandler.cpp:90

WorldSession::HandleLogoutCancelOpcode
void HandleLogoutCancelOpcode(WorldPacket &recvPacket)
Definition MiscHandler.cpp:1090

WorldSession::HandleGuildAssignRankOpcode
void HandleGuildAssignRankOpcode(WorldPacket &recvPacket)
Definition GuildHandler.cpp:153

WorldSession::HandleAcceptGrantLevel
void HandleAcceptGrantLevel(WorldPacket &recvData)
Definition ReferAFriendHandler.cpp:60

WorldSession::HandleMailMarkAsRead
void HandleMailMarkAsRead(WorldPacket &recvData)
Definition MailHandler.cpp:667

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

WorldSession::SendLfgOfferContinue
void SendLfgOfferContinue(uint32 dungeonEntry)
Definition LFGHandler.cpp:1066

WorldSession::HandleReportLag
void HandleReportLag(WorldPacket &recvPacket)
Definition TicketHandler.cpp:243

WorldSession::HandleChannelMute
void HandleChannelMute(WorldPacket &recvPacket)
Definition ChannelHandler.cpp:175

WorldSession::HandleGuildInviteOpcode
void HandleGuildInviteOpcode(WorldPacket &recvPacket)
Definition GuildHandler.cpp:67

WorldSession::HandlePetBattleStopPvpMatchmaking
void HandlePetBattleStopPvpMatchmaking(WorldPacket &recvData)
Definition BattlePetHandler.cpp:881

WorldSession::HandleEmoteOpcode
void HandleEmoteOpcode(WorldPacket &recvPacket)
Definition ChatHandler.cpp:664

WorldSession::_legitCharacters
std::set< uint32 > _legitCharacters
Definition WorldSession.h:1185

WorldSession::HandleMoveUnRootAck
void HandleMoveUnRootAck(WorldPacket &recvPacket)
Definition MiscHandler.cpp:1785

WorldSession::HandleGuildDisbandOpcode
void HandleGuildDisbandOpcode(WorldPacket &recvPacket)
Definition GuildHandler.cpp:178

WorldSession::HasPermission
bool HasPermission(uint32 permissionId)
Definition WorldSession.cpp:1244

WorldSession::HandleAreaTriggerOpcode
void HandleAreaTriggerOpcode(WorldPacket &recvPacket)
Definition MiscHandler.cpp:1466

WorldSession::HandleChannelUnmute
void HandleChannelUnmute(WorldPacket &recvPacket)
Definition ChannelHandler.cpp:194

WorldSession::HandleQueryNextMailTime
void HandleQueryNextMailTime(WorldPacket &recvData)
Definition MailHandler.cpp:1101

WorldSession::SendTimezoneInformation
void SendTimezoneInformation()
Definition WorldSession.cpp:1030

WorldSession::HandleAuctionListBidderItems
void HandleAuctionListBidderItems(WorldPacket &recvData)
Definition AuctionHouseHandler.cpp:696

WorldSession::SendPacket
void SendPacket(WorldPacket const *packet, bool forced=false)
Send a packet to the client.
Definition WorldSession.cpp:196

WorldSession::HandleMoveSetVehicleRecAck
void HandleMoveSetVehicleRecAck(WorldPacket &recvData)
Definition VehicleHandler.cpp:230

WorldSession::SendBfQueueInviteResponse
void SendBfQueueInviteResponse(uint64 guid, uint32 zoneId, bool canQueue=true, bool full=false)
Definition BattlefieldHandler.cpp:84

WorldSession::HandleAcceptTradeOpcode
void HandleAcceptTradeOpcode(WorldPacket &recvPacket)
Definition TradeHandler.cpp:309

WorldSession::HandleAreaSpiritHealerQueryOpcode
void HandleAreaSpiritHealerQueryOpcode(WorldPacket &recvData)
Definition MiscHandler.cpp:2390

WorldSession::SendWrongFactionNotice
void SendWrongFactionNotice()
Definition ChatHandler.cpp:846

WorldSession::HandleChannelBan
void HandleChannelBan(WorldPacket &recvPacket)
Definition ChannelHandler.cpp:251

WorldSession::timeLastWhoCommand
time_t timeLastWhoCommand
Definition WorldSession.h:1223

WorldSession::HandleGroupSwapSubGroupOpcode
void HandleGroupSwapSubGroupOpcode(WorldPacket &recvData)
Definition GroupHandler.cpp:726

WorldSession::HandleGroupSetLeaderOpcode
void HandleGroupSetLeaderOpcode(WorldPacket &recvPacket)
Definition GroupHandler.cpp:394

WorldSession::HandleChannelUnmoderator
void HandleChannelUnmoderator(WorldPacket &recvPacket)
Definition ChannelHandler.cpp:156

WorldSession::HandleLfrLeaveOpcode
void HandleLfrLeaveOpcode(WorldPacket &recvData)
Definition LFGHandler.cpp:523

WorldSession::GetAccountId
uint32 GetAccountId() const
Definition WorldSession.h:294

WorldSession::HandlePetitionQueryOpcode
void HandlePetitionQueryOpcode(WorldPacket &recvData)
Definition PetitionsHandler.cpp:221

WorldSession::HandleCancelChanneling
void HandleCancelChanneling(WorldPacket &recvData)
Definition SpellHandler.cpp:1680

WorldSession::HandleObjectUpdateFailedOpcode
void HandleObjectUpdateFailedOpcode(WorldPacket &recvPacket)
Definition MiscHandler.cpp:2751

WorldSession::HandleUpdateAccountData
void HandleUpdateAccountData(WorldPacket &recvPacket)
Definition MiscHandler.cpp:1619

WorldSession::HandleTogglePvP
void HandleTogglePvP(WorldPacket &recvPacket)
Definition MiscHandler.cpp:1128

WorldSession::HandleGuildBankWithdrawMoney
void HandleGuildBankWithdrawMoney(WorldPacket &recvData)
Definition GuildHandler.cpp:414

WorldSession::_compressionStream
z_stream_s * _compressionStream
Definition WorldSession.h:1224

WorldSession::HandleQuestLogSwapQuest
void HandleQuestLogSwapQuest(WorldPacket &recvData)
Definition QuestHandler.cpp:474

WorldSession::HandleRequestHotfix
void HandleRequestHotfix(WorldPacket &recvPacket)
Definition MiscHandler.cpp:2586

WorldSession::HandleRequestPartyMemberStatsOpcode
void HandleRequestPartyMemberStatsOpcode(WorldPacket &recvData)
Definition GroupHandler.cpp:1252

WorldSession::HandleInstanceLockResponse
void HandleInstanceLockResponse(WorldPacket &recvPacket)
Definition MiscHandler.cpp:2454

WorldSession::HandlePetAbandon
void HandlePetAbandon(WorldPacket &recvData)
Definition PetHandler.cpp:1251

WorldSession::SendLfgRoleCheckUpdate
void SendLfgRoleCheckUpdate(lfg::LfgRoleCheck const &pRoleCheck)
Definition LFGHandler.cpp:718

WorldSession::SendAuthResponse
void SendAuthResponse(ResponseCodes code, bool queued, uint32 queuePos=0)
Definition AuthHandler.cpp:48

WorldSession::HandleRealmNameQueryOpcode
void HandleRealmNameQueryOpcode(WorldPacket &recvPacket)
Definition QueryHandler.cpp:161

WorldSession::HandlePetLearnTalent
void HandlePetLearnTalent(WorldPacket &recvPacket)
Definition PetHandler.cpp:1380

WorldSession::SendCalendarRaidLockout
void SendCalendarRaidLockout(InstanceSave const *save, bool add)
Definition CalendarHandler.cpp:781

WorldSession::HandleGuildAddRankOpcode
void HandleGuildAddRankOpcode(WorldPacket &recvPacket)
Definition GuildHandler.cpp:258

WorldSession::HandleSetContactNotesOpcode
void HandleSetContactNotesOpcode(WorldPacket &recvPacket)
Definition MiscHandler.cpp:1382

WorldSession::SendChatRestrictedNotice
void SendChatRestrictedNotice(ChatRestrictionType restriction)
Definition ChatHandler.cpp:852

WorldSession::SendGroupInviteNotification
void SendGroupInviteNotification(const std::string &inviterName, const std::string &realmName, bool inGroup)
Definition GroupHandler.cpp:49

WorldSession::SendVoidStorageTransferResult
void SendVoidStorageTransferResult(VoidTransferError result)
Definition VoidStorageHandler.cpp:19

WorldSession::HandleSplitItemOpcode
void HandleSplitItemOpcode(WorldPacket &recvPacket)
Definition ItemHandler.cpp:21

WorldSession::HandleFarSightOpcode
void HandleFarSightOpcode(WorldPacket &recvData)
Definition MiscHandler.cpp:2028

WorldSession::HandleGroupInviteResponseOpcode
void HandleGroupInviteResponseOpcode(WorldPacket &recvPacket)
Definition GroupHandler.cpp:249

WorldSession::HandleTaxiQueryAvailableNodes
void HandleTaxiQueryAvailableNodes(WorldPacket &recvPacket)
Definition TaxiHandler.cpp:77

WorldSession::HandleQuestPushResult
void HandleQuestPushResult(WorldPacket &recvPacket)
Definition QuestHandler.cpp:700

WorldSession::HandleBattlefieldRatedInfoRequest
void HandleBattlefieldRatedInfoRequest(WorldPacket &recvData)
Definition BattlefieldHandler.cpp:237

WorldSession::HandleRepairItemOpcode
void HandleRepairItemOpcode(WorldPacket &recvPacket)
Definition NPCHandler.cpp:859

WorldSession::HandleBattlePetRequestUpdate
void HandleBattlePetRequestUpdate(WorldPacket &recvData)
Definition BattlePetHandler.cpp:1618

WorldSession::HandleBattlePetQueryName
void HandleBattlePetQueryName(WorldPacket &recvData)
Definition BattlePetHandler.cpp:1134

WorldSession::SendTutorialsData
void SendTutorialsData()
Definition WorldSession.cpp:835

WorldSession::SendLfgDisabled
void SendLfgDisabled()
Definition LFGHandler.cpp:1059

WorldSession::HandleAddonMessagechatOpcode
void HandleAddonMessagechatOpcode(WorldPacket &recvPacket)
Definition ChatHandler.cpp:524

WorldSession::HandleRequestStabledPetsOpcode
void HandleRequestStabledPetsOpcode(WorldPacket &recvPacket)
Definition NPCHandler.cpp:480

WorldSession::HandleGuildQueryXPOpcode
void HandleGuildQueryXPOpcode(WorldPacket &recvData)
Definition GuildHandler.cpp:611

WorldSession::HandleChannelModerator
void HandleChannelModerator(WorldPacket &recvPacket)
Definition ChannelHandler.cpp:137

WorldSession::_player
Player * _player
Definition WorldSession.h:1188

WorldSession::LogUnprocessedTail
void LogUnprocessedTail(WorldPacket *packet) const
Logging helper for unexpected opcodes.
Definition WorldSession.cpp:288

WorldSession::SendBfInvitePlayerToWar
void SendBfInvitePlayerToWar(uint64 guid, uint32 zoneId, uint32 time)
Definition BattlefieldHandler.cpp:22

WorldSession::HandleReportPvPAFK
void HandleReportPvPAFK(WorldPacket &recvData)
Definition BattleGroundHandler.cpp:737

WorldSession::HandleLFDTeleportOpcode
void HandleLFDTeleportOpcode(WorldPacket &recvData)
Definition LFGHandler.cpp:299

WorldSession::SendShowBank
void SendShowBank(ObjectGuid guid)
Definition NPCHandler.cpp:74

WorldSession::HandleRequestForcedReactionsOpcode
void HandleRequestForcedReactionsOpcode(WorldPacket &recvData)
Definition CharacterHandler.cpp:1860

WorldSession::HandleLfgSetRolesOpcode
void HandleLfgSetRolesOpcode(WorldPacket &recvData)
Definition LFGHandler.cpp:259

WorldSession::SendUpdateSockets
void SendUpdateSockets(ObjectGuid ItemGUID, Item *item)
Definition ItemHandler.cpp:1467

WorldSession::GetTutorialInt
uint32 GetTutorialInt(uint8 index) const
Definition WorldSession.h:441

WorldSession::HandleQuestgiverQueryQuestOpcode
void HandleQuestgiverQueryQuestOpcode(WorldPacket &recvPacket)
Definition QuestHandler.cpp:257

WorldSession::HandleGuildBankSwapItems
void HandleGuildBankSwapItems(WorldPacket &recvData)
Definition GuildHandler.cpp:431

WorldSession::HandleGuildBankMoneyWithdrawn
void HandleGuildBankMoneyWithdrawn(WorldPacket &recvData)
Definition GuildHandler.cpp:329

WorldSession::HandleEnableNagleAlgorithm
int32 HandleEnableNagleAlgorithm()
Definition MiscHandler.cpp:1729

WorldSession::HandleAttackSwingOpcode
void HandleAttackSwingOpcode(WorldPacket &recvPacket)
Definition CombatHandler.cpp:18

WorldSession::HandleChangeCurrencyFlags
void HandleChangeCurrencyFlags(WorldPacket &recvPacket)
Definition LootHandler.cpp:576

WorldSession::HandleBattlePetSummonCompanion
void HandleBattlePetSummonCompanion(WorldPacket &recvData)
Definition BattlePetHandler.cpp:1385

WorldSession::HandlePetBattleQueueProposeMatchResult
void HandlePetBattleQueueProposeMatchResult(WorldPacket &recvData)
Definition BattlePetHandler.cpp:889

WorldSession::m_Socket
WorldSocket * m_Socket
Definition WorldSession.h:1189

WorldSession::HandleLeaveChannel
void HandleLeaveChannel(WorldPacket &recvPacket)
Definition ChannelHandler.cpp:52

WorldSession::SendPetitionShowList
void SendPetitionShowList(uint64 guid)
Definition PetitionsHandler.cpp:738

WorldSession::SendItemExpirePurchaseRefund
void SendItemExpirePurchaseRefund(ObjectGuid itemGuid)
Definition ItemHandler.cpp:1867

WorldSession::SendBfInvitePlayerToQueue
void SendBfInvitePlayerToQueue(uint64 guid)
Definition BattlefieldHandler.cpp:41

WorldSession::HandleGuildQueryOpcode
void HandleGuildQueryOpcode(WorldPacket &recvPacket)
Definition GuildHandler.cpp:20

WorldSession::HandleSetPvP
void HandleSetPvP(WorldPacket &recvPacket)
Definition MiscHandler.cpp:1119

WorldSession::ResetTimeOutTime
void ResetTimeOutTime()
Definition WorldSession.h:508

WorldSession::_security
AccountTypes _security
Definition WorldSession.h:1192

WorldSession::LogPacketMarker
void LogPacketMarker(std::string const &marker)
Definition WorldSession.cpp:267

WorldSession::m_charBooster
CharacterBooster * m_charBooster
Definition WorldSession.h:1196

WorldSession::HandleLfgProposalResultOpcode
void HandleLfgProposalResultOpcode(WorldPacket &recvData)
Definition LFGHandler.cpp:221

WorldSession::HandleGuildDeclineOpcode
void HandleGuildDeclineOpcode(WorldPacket &recvPacket)
Definition GuildHandler.cpp:100

WorldSession::GetLatency
uint32 GetLatency() const
Definition WorldSession.h:495

WorldSession::ProcessQueryCallbacks
void ProcessQueryCallbacks()
Definition WorldSession.cpp:1120

WorldSession::HandleRequestConquestFormulaConstants
void HandleRequestConquestFormulaConstants(WorldPacket &recvData)
Definition BattleGroundHandler.cpp:781

WorldSession::HandleCharCreateOpcode
void HandleCharCreateOpcode(WorldPacket &recvPacket)
Definition CharacterHandler.cpp:900

WorldSession::HandlePageTextQueryOpcode
void HandlePageTextQueryOpcode(WorldPacket &recvPacket)
Only static data is sent in this packet !!!
Definition QueryHandler.cpp:456

WorldSession::HandleGuildBankerActivate
void HandleGuildBankerActivate(WorldPacket &recvData)
Definition GuildHandler.cpp:347

WorldSession::GetRemoteAddress
std::string const & GetRemoteAddress()
Definition WorldSession.h:301

WorldSession::HandleSetActionBarToggles
void HandleSetActionBarToggles(WorldPacket &recvData)
Definition MiscHandler.cpp:1841

WorldSession::HandleCancelAutoRepeatSpellOpcode
void HandleCancelAutoRepeatSpellOpcode(WorldPacket &recvPacket)
Definition SpellHandler.cpp:1673

WorldSession::HandleSetTitleOpcode
void HandleSetTitleOpcode(WorldPacket &recvData)
Definition MiscHandler.cpp:2050

WorldSession::HandleLFDGetLockInfoOpcode
void HandleLFDGetLockInfoOpcode(WorldPacket &recvData)
Definition LFGHandler.cpp:309

WorldSession::HandleAuctionRemoveItem
void HandleAuctionRemoveItem(WorldPacket &recvData)
Definition AuctionHouseHandler.cpp:618

WorldSession::HandleChannelSetOwner
void HandleChannelSetOwner(WorldPacket &recvPacket)
Definition ChannelHandler.cpp:104

WorldSession::SendPartyResult
void SendPartyResult(PartyOperation operation, std::string const &member, PartyResult res, uint32 val=0)
Definition GroupHandler.cpp:37

WorldSession::HandlePetNameQuery
void HandlePetNameQuery(WorldPacket &recvData)
Definition PetHandler.cpp:1080

WorldSession::HandleCalendarCopyEvent
void HandleCalendarCopyEvent(WorldPacket &recvData)
Definition CalendarHandler.cpp:427

WorldSession::HandleRequestPvpOptions
void HandleRequestPvpOptions(WorldPacket &recvData)
Definition BattleGroundHandler.cpp:757

WorldSession::HandleGuildRequestPartyState
void HandleGuildRequestPartyState(WorldPacket &recvPacket)
Definition GuildHandler.cpp:669

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

WorldSession::HandleReclaimCorpseOpcode
void HandleReclaimCorpseOpcode(WorldPacket &recvPacket)
Definition MiscHandler.cpp:1409

WorldSession::HandleWorldTeleportOpcode
void HandleWorldTeleportOpcode(WorldPacket &recvData)
Definition MiscHandler.cpp:1908

WorldSession::HandleBlackMarketBidOnItem
void HandleBlackMarketBidOnItem(WorldPacket &recvData)
Definition BlackMarketHandler.cpp:55

WorldSession::HandleAddIgnoreOpcode
void HandleAddIgnoreOpcode(WorldPacket &recvPacket)
Definition MiscHandler.cpp:1313

WorldSession::SendTradeStatus
void SendTradeStatus(TradeStatus status)
Definition TradeHandler.cpp:20

WorldSession::HandleEquipmentSetSave
void HandleEquipmentSetSave(WorldPacket &recvData)
Definition CharacterHandler.cpp:2271

WorldSession::_registeredAddonPrefixes
std::vector< std::string > _registeredAddonPrefixes
Definition WorldSession.h:1217

WorldSession::HandleAutoBankItemOpcode
void HandleAutoBankItemOpcode(WorldPacket &recvPacket)
Definition ItemHandler.cpp:941

WorldSession::HandleInitiateTradeOpcode
void HandleInitiateTradeOpcode(WorldPacket &recvPacket)
Definition TradeHandler.cpp:611

WorldSession::HandleQueryTimeOpcode
void HandleQueryTimeOpcode(WorldPacket &recvPacket)
Definition QueryHandler.cpp:168

WorldSession::SendAttackStop
void SendAttackStop(Unit const *enemy)
Definition CombatHandler.cpp:87

WorldSession::HandlePetitionRenameOpcode
void HandlePetitionRenameOpcode(WorldPacket &recvData)
Definition PetitionsHandler.cpp:303

WorldSession::HandleRaidReadyCheckOpcode
void HandleRaidReadyCheckOpcode(WorldPacket &recvData)
Definition GroupHandler.cpp:819

WorldSession::HandleBattlefieldListOpcode
void HandleBattlefieldListOpcode(WorldPacket &recvData)
Definition BattleGroundHandler.cpp:356

WorldSession::HandlePetActionHelper
void HandlePetActionHelper(Unit *pet, uint64 guid1, uint32 spellid, uint16 flag, uint64 guid2, float x, float y, float z)
Definition PetHandler.cpp:811

WorldSession::HandleBattlePetLearn
void HandleBattlePetLearn(WorldPacket &recvData)
Definition BattlePetHandler.cpp:1223

WorldSession::HandleBlackMarketHelloOpcode
void HandleBlackMarketHelloOpcode(WorldPacket &recvData)
Definition BlackMarketHandler.cpp:15

WorldSession::SendPetitionQueryOpcode
void SendPetitionQueryOpcode(uint64 petitionguid)
Definition PetitionsHandler.cpp:238

WorldSession::HandleGuildLeaveOpcode
void HandleGuildLeaveOpcode(WorldPacket &recvPacket)
Definition GuildHandler.cpp:170

WorldSession::HandleAddFriendOpcode
void HandleAddFriendOpcode(WorldPacket &recvPacket)
Definition MiscHandler.cpp:1225

WorldSession::SendSetPhaseShift
void SendSetPhaseShift(std::set< uint32 > const &phaseIds, std::set< uint32 > const &terrainswaps, std::set< uint32 > const &worldAreas)
Definition MiscHandler.cpp:2353

WorldSession::HandleGuildChangeInfoTextOpcode
void HandleGuildChangeInfoTextOpcode(WorldPacket &recvPacket)
Definition GuildHandler.cpp:283

WorldSession::HandleSetSavedInstanceExtend
void HandleSetSavedInstanceExtend(WorldPacket &recvData)
Definition CalendarHandler.cpp:761

WorldSession::HandleUnregisterAddonPrefixesOpcode
void HandleUnregisterAddonPrefixesOpcode(WorldPacket &recvPacket)
Definition WorldSession.cpp:1061

WorldSession::SendPlayMusic
void SendPlayMusic(uint32 SoundKitID)
Definition MiscHandler.cpp:2964

WorldSession::m_inQueue
bool m_inQueue
Definition WorldSession.h:1204

WorldSession::HandleSpiritHealerActivateOpcode
void HandleSpiritHealerActivateOpcode(WorldPacket &recvPacket)
Definition NPCHandler.cpp:386

WorldSession::HandleSetSheathedOpcode
void HandleSetSheathedOpcode(WorldPacket &recvPacket)
Definition CombatHandler.cpp:65

WorldSession::Handle_Deprecated
void Handle_Deprecated(WorldPacket &recvPacket) const
Definition WorldSession.cpp:705

WorldSession::HandleSetPlayerDeclinedNames
void HandleSetPlayerDeclinedNames(WorldPacket &recvData)
Definition CharacterHandler.cpp:1976

WorldSession::DoLootRelease
void DoLootRelease(uint64 lguid)
Definition LootHandler.cpp:341

WorldSession::HandleQueryInspectAchievements
void HandleQueryInspectAchievements(WorldPacket &recvData)
Definition MiscHandler.cpp:2313

WorldSession::SendLfgBootProposalUpdate
void SendLfgBootProposalUpdate(lfg::LfgPlayerBoot const &boot)
Definition LFGHandler.cpp:892

WorldSession::HandleSetGuildBankTabText
void HandleSetGuildBankTabText(WorldPacket &recvData)
Definition GuildHandler.cpp:597

WorldSession::HandleMoveSetCanFlyAckOpcode
void HandleMoveSetCanFlyAckOpcode(WorldPacket &recvData)
Definition MovementHandler.cpp:808

WorldSession::HandleSetTaxiBenchmarkOpcode
void HandleSetTaxiBenchmarkOpcode(WorldPacket &recvData)
Definition MiscHandler.cpp:2302

WorldSession::HandleHearthAndResurrect
void HandleHearthAndResurrect(WorldPacket &recvData)
Definition MiscHandler.cpp:2434

WorldSession::HandleBuyItemInSlotOpcode
void HandleBuyItemInSlotOpcode(WorldPacket &recvPacket)
Definition ItemHandler.cpp:545

WorldSession::SendQueryTimeResponse
void SendQueryTimeResponse()
Definition QueryHandler.cpp:173

WorldSession::HandleSetActiveVoiceChannel
void HandleSetActiveVoiceChannel(WorldPacket &recvData)
Definition VoiceChatHandler.cpp:28

WorldSession::HandleAuctionPlaceBid
void HandleAuctionPlaceBid(WorldPacket &recvData)
Definition AuctionHouseHandler.cpp:486

WorldSession::HandleQuestPOIQuery
void HandleQuestPOIQuery(WorldPacket &recvData)
Definition QueryHandler.cpp:567

WorldSession::SendAccountDataTimes
void SendAccountDataTimes(uint32 mask)
Definition WorldSession.cpp:805

WorldSession::m_sessionDbcLocale
LocaleConstant m_sessionDbcLocale
Definition WorldSession.h:1209

WorldSession::HandleCancelTempEnchantmentOpcode
void HandleCancelTempEnchantmentOpcode(WorldPacket &recvData)
Definition ItemHandler.cpp:1482

WorldSession::HandleMoveGravityAck
void HandleMoveGravityAck(WorldPacket &recvData)
Definition MiscHandler.cpp:1835

WorldSession::HandleRequestCemeteryList
void HandleRequestCemeteryList(WorldPacket &recvPacket)
Definition MiscHandler.cpp:1169

WorldSession::SendPetNameQuery
void SendPetNameQuery(ObjectGuid guid, uint64 petNumber)
Definition PetHandler.cpp:1088

WorldSession::HandleBattlePetWildRequest
void HandleBattlePetWildRequest(WorldPacket &recvData)
Definition BattlePetHandler.cpp:1662

WorldSession::HandlePetStopAttack
void HandlePetStopAttack(WorldPacket &recvData)
Definition PetHandler.cpp:798

WorldSession::SendBlackMarketHello
void SendBlackMarketHello(ObjectGuid NpcGUID, bool Open)
Definition BlackMarketHandler.cpp:27

WorldSession::HandleItemTextQuery
void HandleItemTextQuery(WorldPacket &recvData)
Definition ItemHandler.cpp:1547

WorldSession::HandleMoveNotActiveMover
void HandleMoveNotActiveMover(WorldPacket &recvData)
Definition MovementHandler.cpp:735

WorldSession::HandleGuildFinderSetGuildPost
void HandleGuildFinderSetGuildPost(WorldPacket &recvPacket)
Definition GuildFinderHandler.cpp:328

WorldSession::HandleTutorialReset
void HandleTutorialReset(WorldPacket &recvData)
Definition CharacterHandler.cpp:1836

WorldSession::IsLegitCharacterForAccount
bool IsLegitCharacterForAccount(uint32 lowGUID)
Definition WorldSession.h:1178

WorldSession::WorldSession
WorldSession(uint32 id, WorldSocket *sock, AccountTypes sec, uint8 expansion, time_t mute_time, LocaleConstant locale, uint32 recruiter, bool isARecruiter, bool hasBoost)
WorldSession constructor.
Definition WorldSession.cpp:88

WorldSession::HandleAreaSpiritHealerQueueOpcode
void HandleAreaSpiritHealerQueueOpcode(WorldPacket &recvData)
Definition MiscHandler.cpp:2412

WorldSession::HandleBattlePetSetBattleSlot
void HandleBattlePetSetBattleSlot(WorldPacket &recvData)
Definition BattlePetHandler.cpp:1256

WorldSession::SendStableResult
void SendStableResult(uint8 guid)
Definition NPCHandler.cpp:566

WorldSession::HandleChannelOwner
void HandleChannelOwner(WorldPacket &recvPacket)
Definition ChannelHandler.cpp:124

WorldSession::HandleQuestgiverChooseRewardOpcode
void HandleQuestgiverChooseRewardOpcode(WorldPacket &recvPacket)
Definition QuestHandler.cpp:333

WorldSession::_stableSwapCallback
QueryCallback< PreparedQueryResult, uint32 > _stableSwapCallback
Definition WorldSession.h:1127

WorldSession::SendTitleLost
void SendTitleLost(uint32 TitleIndex)
Definition MiscHandler.cpp:2076

WorldSession::SendUpdateTrade
void SendUpdateTrade(bool trader_data=true)
Definition TradeHandler.cpp:74

WorldSession::InitWarden
void InitWarden(SessionKey const &, std::string const &os)
Definition WorldSession.cpp:1210

WorldSession::HandlePushQuestToParty
void HandlePushQuestToParty(WorldPacket &recvPacket)
Definition QuestHandler.cpp:624

WorldSession::SendListInventory
void SendListInventory(uint64 guid)
Definition ItemHandler.cpp:663

WorldSession::SendReforgeResult
void SendReforgeResult(bool success)
Definition ItemHandler.cpp:1858

WorldSession::SendModifyCooldown
void SendModifyCooldown(ObjectGuid UnitGUID, int32 DeltaTime, int32 SpellID)
Definition SpellHandler.cpp:1933

WorldSession::HandleGuildQueryNewsOpcode
void HandleGuildQueryNewsOpcode(WorldPacket &recvPacket)
Definition GuildHandler.cpp:738

WorldSession::GetPlayerName
std::string const & GetPlayerName() const
Definition WorldSession.cpp:173

WorldSession::HandleBattleFieldPortOpcode
void HandleBattleFieldPortOpcode(WorldPacket &recvData)
Definition BattleGroundHandler.cpp:379

WorldSession::SendDiscoverNewTaxiNode
void SendDiscoverNewTaxiNode(uint32 nodeid)
Definition TaxiHandler.cpp:182

WorldSession::m_muteTime
time_t m_muteTime
Definition WorldSession.h:488

WorldSession::HandleOfferPetitionOpcode
void HandleOfferPetitionOpcode(WorldPacket &recvData)
Definition PetitionsHandler.cpp:474

WorldSession::HandleLfrJoinOpcode
void HandleLfrJoinOpcode(WorldPacket &recvData)
Definition LFGHandler.cpp:493

WorldSession::SendRealmNameQueryOpcode
void SendRealmNameQueryOpcode(uint32 realmId)
Definition QueryHandler.cpp:136

WorldSession::SendLfgPlayerLockInfo
void SendLfgPlayerLockInfo()
Definition LFGHandler.cpp:322

WorldSession::SendBattleGroundList
void SendBattleGroundList(uint64 guid, BattlegroundTypeId bgTypeId=BattlegroundTypeId::BATTLEGROUND_RB)
Definition BattleGroundHandler.cpp:53

WorldSession::SendRolePollInform
void SendRolePollInform(ObjectGuid guid, uint8 Index)
Definition GroupHandler.cpp:1301

WorldSession::HandleZoneUpdateOpcode
void HandleZoneUpdateOpcode(WorldPacket &recvPacket)
Definition MiscHandler.cpp:1148

WorldSession::SendStablePetCallback
void SendStablePetCallback(PreparedQueryResult result, uint64 guid)
Definition NPCHandler.cpp:514

WorldSession::HandlePetitionDeclineOpcode
void HandlePetitionDeclineOpcode(WorldPacket &recvData)
Definition PetitionsHandler.cpp:445

WorldSession::HandleBattlePetSetFlags
void HandleBattlePetSetFlags(WorldPacket &recvData)
Definition BattlePetHandler.cpp:1313

WorldSession::HandleBuybackItem
void HandleBuybackItem(WorldPacket &recvPacket)
Definition ItemHandler.cpp:494

WorldSession::HandleMailDelete
void HandleMailDelete(WorldPacket &recvData)
Definition MailHandler.cpp:689

WorldSession::HandleGuildNewsUpdateStickyOpcode
void HandleGuildNewsUpdateStickyOpcode(WorldPacket &recvPacket)
Definition GuildHandler.cpp:747

WorldSession::HandleQuestgiverCancel
void HandleQuestgiverCancel(WorldPacket &recvData)
Definition QuestHandler.cpp:467

WorldSession::HandleListInventoryOpcode
void HandleListInventoryOpcode(WorldPacket &recvPacket)
Definition ItemHandler.cpp:648

WorldSession::SendBattlePayDistributionUpdate
void SendBattlePayDistributionUpdate(uint64 playerGuid, int8 bonusId, int32 bonusFlag, int32 textId, std::string const &bonusText, std::string const &bonusText2)
Definition BoostHandler.cpp:22

WorldSession::InvalidateRBACData
void InvalidateRBACData()
Definition WorldSession.cpp:1256

WorldSession::HandleUseItemOpcode
void HandleUseItemOpcode(WorldPacket &recvPacket)
Definition SpellHandler.cpp:1295

WorldSession::HandleBattlemasterJoinArena
void HandleBattlemasterJoinArena(WorldPacket &recvData)
Definition BattleGroundHandler.cpp:633

WorldSession::HandleChallengeModeRequestMapStats
void HandleChallengeModeRequestMapStats(WorldPacket &recvData)
Definition ChallengeModeHandler.cpp:44

WorldSession::HandleStablePetCallback
void HandleStablePetCallback(PreparedQueryResult result)
Definition NPCHandler.cpp:614

WorldSession::HandleActivateTaxiExpressOpcode
void HandleActivateTaxiExpressOpcode(WorldPacket &recvPacket)
Definition TaxiHandler.cpp:191

WorldSession::HandleRequestPetInfoOpcode
void HandleRequestPetInfoOpcode(WorldPacket &recvData)
Definition MiscHandler.cpp:2289

WorldSession::SendEnchantmentLog
void SendEnchantmentLog(uint64 target, uint64 caster, uint64 itemGuid, uint32 itemId, uint32 enchantId, uint32 enchantmentSlot)
Definition ItemHandler.cpp:1015

WorldSession::HandleClientCastFlags
void HandleClientCastFlags(WorldPacket &recvPacket, uint8 castFlags, SpellCastTargets &targets)
Definition SpellHandler.cpp:1254

WorldSession::HandleGuildRemoveOpcode
void HandleGuildRemoveOpcode(WorldPacket &recvPacket)
Definition GuildHandler.cpp:78

WorldSession::HandleSpellClick
void HandleSpellClick(WorldPacket &recvData)
Definition SpellHandler.cpp:1729

WorldSession::HandleGuildFinderPostRequest
void HandleGuildFinderPostRequest(WorldPacket &recvPacket)
Definition GuildFinderHandler.cpp:276

WorldSession::HandleCalendarGuildFilter
void HandleCalendarGuildFilter(WorldPacket &recvData)
Definition CalendarHandler.cpp:221

WorldSession::HandleLootReleaseOpcode
void HandleLootReleaseOpcode(WorldPacket &recvPacket)
Definition LootHandler.cpp:326

WorldSession::HandleQuestgiverStatusMultipleQuery
void HandleQuestgiverStatusMultipleQuery(WorldPacket &recvPacket)
Definition QuestHandler.cpp:818

WorldSession::SetSecurity
void SetSecurity(AccountTypes security)
Definition WorldSession.h:300

WorldSession::HandleCharRenameOpcode
void HandleCharRenameOpcode(WorldPacket &recvData)
Definition CharacterHandler.cpp:1881

WorldSession::HandleGrantLevel
void HandleGrantLevel(WorldPacket &recvData)
Definition ReferAFriendHandler.cpp:12

WorldSession::HandleGuildFinderAddApplication
void HandleGuildFinderAddApplication(WorldPacket &recvPacket)
Definition GuildFinderHandler.cpp:13

WorldSession::SetLatency
void SetLatency(uint32 latency)
Definition WorldSession.h:496

WorldSession::HandleMessagechatOpcode
void HandleMessagechatOpcode(WorldPacket &recvPacket)
Definition ChatHandler.cpp:30

WorldSession::IsAddonRegistered
bool IsAddonRegistered(const std::string &prefix) const
Definition WorldSession.cpp:1049

WorldSession::HandleGuildFinderGetApplications
void HandleGuildFinderGetApplications(WorldPacket &recvPacket)
Definition GuildFinderHandler.cpp:152

WorldSession::HandleGMTicketDeleteOpcode
void HandleGMTicketDeleteOpcode(WorldPacket &recvPacket)
Definition TicketHandler.cpp:140

WorldSession::HandleChannelDeclineInvite
void HandleChannelDeclineInvite(WorldPacket &recvPacket)
Definition ChatHandler.cpp:823

WorldSession::HandleStableSwapPet
void HandleStableSwapPet(WorldPacket &recvPacket)
Definition NPCHandler.cpp:765

WorldSession::HandleGuildBankUpdateTab
void HandleGuildBankUpdateTab(WorldPacket &recvData)
Definition GuildHandler.cpp:536

WorldSession::SendFeatureSystemStatusGlueScreen
void SendFeatureSystemStatusGlueScreen()
Definition AuthHandler.cpp:133

WorldSession::HandleGuildPermissions
void HandleGuildPermissions(WorldPacket &recvData)
Definition GuildHandler.cpp:337

WorldSession::HandleChannelAnnouncements
void HandleChannelAnnouncements(WorldPacket &recvPacket)
Definition ChannelHandler.cpp:292

WorldSession::SendTaxiStatus
void SendTaxiStatus(uint64 guid)
Definition TaxiHandler.cpp:31

WorldSession::m_Tutorials
uint32 m_Tutorials[MAX_ACCOUNT_TUTORIAL_VALUES]
Definition WorldSession.h:1214

WorldSession::SetTutorialInt
void SetTutorialInt(uint8 index, uint32 value)
Definition WorldSession.h:442

WorldSession::HandleGuildFinderGetRecruits
void HandleGuildFinderGetRecruits(WorldPacket &recvPacket)
Definition GuildFinderHandler.cpp:207

WorldSession::HandleGuildDemoteOpcode
void HandleGuildDemoteOpcode(WorldPacket &recvPacket)
Definition GuildHandler.cpp:140

WorldSession::SendTotemCreated
void SendTotemCreated(ObjectGuid TotemGUID, uint32 Duration, uint32 SpellID, uint8 Slot)
Definition SpellHandler.cpp:1921

WorldSession::HandleGMTicketSystemStatusOpcode
void HandleGMTicketSystemStatusOpcode(WorldPacket &recvPacket)
Definition TicketHandler.cpp:168

WorldSession::ShouldLogOut
bool ShouldLogOut(time_t currTime) const
Is logout cooldown expired?
Definition WorldSession.h:320

WorldSession::HandleUnlearnSkillOpcode
void HandleUnlearnSkillOpcode(WorldPacket &recvPacket)
Definition SkillHandler.cpp:101

WorldSession::HandleChannelKick
void HandleChannelKick(WorldPacket &recvPacket)
Definition ChannelHandler.cpp:232

WorldSession::_sendStabledPetCallback
QueryCallback< PreparedQueryResult, uint64 > _sendStabledPetCallback
Definition WorldSession.h:1128

WorldSession::HandleVoidStorageTransfer
void HandleVoidStorageTransfer(WorldPacket &recvData)
Definition VoidStorageHandler.cpp:139

WorldSession::HandleAttackStopOpcode
void HandleAttackStopOpcode(WorldPacket &recvPacket)
Definition CombatHandler.cpp:60

WorldSession::GetRBACData
rbac::RBACData * GetRBACData()
Definition WorldSession.cpp:1239

WorldSession::HandleRealmSplitOpcode
void HandleRealmSplitOpcode(WorldPacket &recvData)
Definition MiscHandler.cpp:2011

WorldSession::HandlePetitionSignOpcode
void HandlePetitionSignOpcode(WorldPacket &recvData)
Definition PetitionsHandler.cpp:351

WorldSession::SetAccountData
void SetAccountData(AccountDataType type, time_t tm, std::string const &data)
Definition WorldSession.cpp:775

WorldSession::HandleChannelDisplayListQuery
void HandleChannelDisplayListQuery(WorldPacket &recvPacket)
Definition ChannelHandler.cpp:305

WorldSession::LoadGlobalAccountData
void LoadGlobalAccountData()
Definition WorldSession.cpp:735

WorldSession::HandlePetBattleStartPvpMatchmaking
void HandlePetBattleStartPvpMatchmaking(WorldPacket &recvData)
Definition BattlePetHandler.cpp:870

WorldSession::HandleSetActiveMoverOpcode
void HandleSetActiveMoverOpcode(WorldPacket &recvData)
Definition MovementHandler.cpp:725

WorldSession::_warden
Warden * _warden
Definition WorldSession.h:1201

WorldSession::HandleCalendarRemoveEvent
void HandleCalendarRemoveEvent(WorldPacket &recvData)
Definition CalendarHandler.cpp:415

WorldSession::HandleGuildDelRankOpcode
void HandleGuildDelRankOpcode(WorldPacket &recvPacket)
Definition GuildHandler.cpp:272

WorldSession::m_expansion
uint8 m_expansion
Definition WorldSession.h:1195

WorldSession::HandleMoveKnockBackAck
void HandleMoveKnockBackAck(WorldPacket &recvPacket)
Definition MovementHandler.cpp:755

WorldSession::IsConnectionIdle
bool IsConnectionIdle() const
Definition WorldSession.h:509

WorldSession::HandleVoidStorageUnlock
void HandleVoidStorageUnlock(WorldPacket &recvData)
Definition VoidStorageHandler.cpp:26

WorldSession::HandleCancelAuraOpcode
void HandleCancelAuraOpcode(WorldPacket &recvPacket)
Definition SpellHandler.cpp:1639

WorldSession::HandleGuildBankQueryTab
void HandleGuildBankQueryTab(WorldPacket &recvData)
Definition GuildHandler.cpp:375

WorldSession::HandleRaidReadyCheckFinishedOpcode
void HandleRaidReadyCheckFinishedOpcode(WorldPacket &recvData)
Definition GroupHandler.cpp:965

WorldSession::SendCharacterLoginFailed
void SendCharacterLoginFailed(ResponseCodes reason)
Definition WorldSession.cpp:678

WorldSession::HandleInspectHonorStatsOpcode
void HandleInspectHonorStatsOpcode(WorldPacket &recvPacket)
Definition MiscHandler.cpp:1882

WorldSession::_filterAddonMessages
bool _filterAddonMessages
Definition WorldSession.h:1218

WorldSession::HandleCalendarGetNumPending
void HandleCalendarGetNumPending(WorldPacket &recvData)
Definition CalendarHandler.cpp:748

WorldSession::HandleLearnTalentOpcode
void HandleLearnTalentOpcode(WorldPacket &recvPacket)
Definition SkillHandler.cpp:45

WorldSession::HandlePendingPetBattlePvpDuelResponse
bool HandlePendingPetBattlePvpDuelResponse(bool accepted)
Definition BattlePetHandler.cpp:1015

WorldSession::SendDoFlight
void SendDoFlight(uint32 mountDisplayId, uint32 path, uint32 pathNode=0)
Definition TaxiHandler.cpp:138

WorldSession::HandleSubmitSuggestOpcode
void HandleSubmitSuggestOpcode(WorldPacket &recvPacket)
Definition TicketHandler.cpp:304

WorldSession::SendLfgUpdateProposal
void SendLfgUpdateProposal(lfg::LfgProposal const &proposal)
Definition LFGHandler.cpp:950

WorldSession::HandleRequestRaidInfoOpcode
void HandleRequestRaidInfoOpcode(WorldPacket &recvData)
Definition GroupHandler.cpp:1270

WorldSession::m_hasBoost
bool m_hasBoost
Definition WorldSession.h:1221

WorldSession::HandleFeatherFallAck
void HandleFeatherFallAck(WorldPacket &recvData)
Definition MiscHandler.cpp:1777

WorldSession::HandleSetLootSpecialization
void HandleSetLootSpecialization(WorldPacket &recvData)
Definition ItemHandler.cpp:1877

WorldSession::HandleRequestResearchHistory
void HandleRequestResearchHistory(WorldPacket &recvPacket)
Definition SkillHandler.cpp:112

WorldSession::HandeSetTalentSpecialization
void HandeSetTalentSpecialization(WorldPacket &recvData)
Definition SkillHandler.cpp:17

WorldSession::HandleCalendarEventStatus
void HandleCalendarEventStatus(WorldPacket &recvData)
Definition CalendarHandler.cpp:656

WorldSession::ResetClientTimeDelay
void ResetClientTimeDelay()
Definition WorldSession.h:497

WorldSession::HandleGetChallengeModeRewards
void HandleGetChallengeModeRewards(WorldPacket &recvData)
Definition ChallengeModeHandler.cpp:13

WorldSession::HandleTutorialClear
void HandleTutorialClear(WorldPacket &recvData)
Definition CharacterHandler.cpp:1830

WorldSocket
Handler that can communicate over stream sockets.
Definition WorldSocket.h:51

rbac::RBACData
Definition RBAC.h:763

ChatRestrictionType
ChatRestrictionType
Definition WorldSession.h:106

BarberShopResult
BarberShopResult
Definition WorldSession.h:114

PartyOperation
PartyOperation
Definition WorldSession.h:89

AccountDataType
AccountDataType
Definition WorldSession.h:62

NUM_OPCODE_HANDLERS
#define NUM_OPCODE_HANDLERS
Definition Opcodes.h:16

BFLeaveReason
BFLeaveReason
Definition WorldSession.h:97

ERR_CHAT_THROTTLED
@ ERR_CHAT_THROTTLED
Definition WorldSession.h:108

ERR_YELL_RESTRICTED
@ ERR_YELL_RESTRICTED
Definition WorldSession.h:110

ERR_CHAT_RESTRICTED
@ ERR_CHAT_RESTRICTED
Definition WorldSession.h:107

ERR_USER_SQUELCHED
@ ERR_USER_SQUELCHED
Definition WorldSession.h:109

BarberShopResult::BARBER_SHOP_NOT_ENOUGH_MONEY
@ BARBER_SHOP_NOT_ENOUGH_MONEY
Definition WorldSession.h:116

BarberShopResult::BARBER_SHOP_SUCCESS
@ BARBER_SHOP_SUCCESS
Definition WorldSession.h:115

BarberShopResult::BARBER_SHOP_NOT_SITTING
@ BARBER_SHOP_NOT_SITTING
Definition WorldSession.h:117

PartyOperation::PARTY_OP_INVITE
@ PARTY_OP_INVITE
Definition WorldSession.h:90

PartyOperation::PARTY_OP_SWAP
@ PARTY_OP_SWAP
Definition WorldSession.h:93

PartyOperation::PARTY_OP_LEAVE
@ PARTY_OP_LEAVE
Definition WorldSession.h:92

PartyOperation::PARTY_OP_UNINVITE
@ PARTY_OP_UNINVITE
Definition WorldSession.h:91

AccountDataType::PER_CHARACTER_MACROS_CACHE
@ PER_CHARACTER_MACROS_CACHE
Definition WorldSession.h:68

AccountDataType::PER_CHARACTER_BINDINGS_CACHE
@ PER_CHARACTER_BINDINGS_CACHE
Definition WorldSession.h:66

AccountDataType::NUM_ACCOUNT_DATA_TYPES
@ NUM_ACCOUNT_DATA_TYPES
Definition WorldSession.h:71

AccountDataType::GLOBAL_BINDINGS_CACHE
@ GLOBAL_BINDINGS_CACHE
Definition WorldSession.h:65

AccountDataType::GLOBAL_MACROS_CACHE
@ GLOBAL_MACROS_CACHE
Definition WorldSession.h:67

AccountDataType::PER_CHARACTER_LAYOUT_CACHE
@ PER_CHARACTER_LAYOUT_CACHE
Definition WorldSession.h:69

AccountDataType::PER_CHARACTER_CONFIG_CACHE
@ PER_CHARACTER_CONFIG_CACHE
Definition WorldSession.h:64

AccountDataType::PER_CHARACTER_CHAT_CACHE
@ PER_CHARACTER_CHAT_CACHE
Definition WorldSession.h:70

AccountDataType::GLOBAL_CONFIG_CACHE
@ GLOBAL_CONFIG_CACHE
Definition WorldSession.h:63

BF_LEAVE_REASON_LOW_LEVEL
@ BF_LEAVE_REASON_LOW_LEVEL
Definition WorldSession.h:102

BF_LEAVE_REASON_CLOSE
@ BF_LEAVE_REASON_CLOSE
Definition WorldSession.h:98

BF_LEAVE_REASON_EXITED
@ BF_LEAVE_REASON_EXITED
Definition WorldSession.h:101

sWorld
#define sWorld
Definition World.h:910

WorldIntConfigs
WorldIntConfigs
Definition World.h:198

WorldIntConfigs::CONFIG_PACKET_SPOOF_POLICY
@ CONFIG_PACKET_SPOOF_POLICY
Definition World.h:350

WorldIntConfigs::CONFIG_SOCKET_TIMEOUTTIME
@ CONFIG_SOCKET_TIMEOUTTIME
Definition World.h:206

lfg
Definition LFG.cpp:11

rbac
Definition AccountMgr.h:35

AccountData
Definition WorldSession.h:81

AccountData::Time
time_t Time
Definition WorldSession.h:84

AccountData::AccountData
AccountData()
Definition WorldSession.h:82

AccountData::Data
std::string Data
Definition WorldSession.h:85

AreaTableEntry
Definition DBCStructure.h:650

AuctionEntry
Definition AuctionHouseMgr.h:54

DeclinedName
Definition Unit.h:1101

ItemTemplate
Definition ItemPrototype.h:628

MovementInfo
Definition Object.h:447

ObjectGuid
Definition ByteBuffer.h:66

lfg::LfgJoinResultData
Definition LFGMgr.h:150

lfg::LfgPlayerBoot
Stores information of a current vote to kick someone from a group.
Definition LFGMgr.h:258

lfg::LfgPlayerRewardData
Definition LFGMgr.h:196

lfg::LfgProposal
Stores group data related to proposal to join.
Definition LFGMgr.h:227

lfg::LfgQueueStatusData
Definition LFGMgr.h:175

lfg::LfgRoleCheck
Stores all rolecheck info of a group that wants to join.
Definition LFGMgr.h:247

lfg::LfgUpdateData
Definition LFGMgr.h:160