dc/de4/a00677_source.html

// cClientHandle.h


// Interfaces to the cClientHandle class representing a client connected to this server. The client need not be a player yet


#pragma once


#include "OSSupport/Network.h"

#include "Defines.h"

#include "Scoreboard.h"

#include "UI/SlotArea.h"

#include "json/json.h"

#include "ChunkSender.h"

#include "EffectID.h"

#include "Protocol/ForgeHandshake.h"

#include "Protocol/ProtocolRecognizer.h"

#include "UUID.h"


// fwd:

class cChunkDataSerializer;

class cMonster;

class cExpOrb;

class cPainting;

class cPickup;

class cPlayer;

class cProtocol;

class cWindow;

class cFallingBlock;

class cCompositeChat;

class cMap;

class cClientHandle;


struct StatisticsManager;


typedef std::shared_ptr<cClientHandle> cClientHandlePtr;


class cClientHandle  // tolua_export

    : public cTCPLink::cCallbacks, public std::enable_shared_from_this<cClientHandle>

{  // tolua_export

public:  // tolua_export


    #if defined(ANDROID)

        static const int DEFAULT_VIEW_DISTANCE = 4;  // The default ViewDistance (used when no value is set in Settings.ini)

    #else

        static const int DEFAULT_VIEW_DISTANCE = 10;

    #endif

    static const int MAX_VIEW_DISTANCE = 32;

    static const int MIN_VIEW_DISTANCE = 1;


    static float FASTBREAK_PERCENTAGE;


    cClientHandle(const AString & a_IPString, int a_ViewDistance);


    virtual ~cClientHandle() override;


    const AString & GetIPString(void) const { return m_IPString; }  // tolua_export


    void SetIPString(const AString & a_IPString) { m_IPString = a_IPString; }


    cPlayer * GetPlayer(void) { return m_Player; }  // tolua_export


    const cUUID & GetUUID(void) const { return m_UUID; }  // Exported in ManualBindings.cpp


    void SetUUID(const cUUID & a_UUID) { ASSERT(!a_UUID.IsNil()); m_UUID = a_UUID; }


    const Json::Value & GetProperties(void) const { return m_Properties; }


    void SetProperties(const Json::Value & a_Properties) { m_Properties = a_Properties; }


    static cUUID GenerateOfflineUUID(const AString & a_Username);  // Exported in ManualBindings.cpp


    static bool IsUUIDOnline(const cUUID & a_UUID);  // Exported in ManualBindings.cpp


    void ProxyInit(const AString & a_IPString, const cUUID & a_UUID);

    void ProxyInit(const AString & a_IPString, const cUUID & a_UUID, const Json::Value & a_Properties);


    void ProcessProtocolIn(void);


    void ProcessProtocolOut();


    static AString FormatMessageType(bool ShouldAppendChatPrefixes, eMessageType a_ChatPrefix, const AString & a_AdditionalData);


    static AString FormatChatPrefix(

        bool ShouldAppendChatPrefixes, const AString & a_ChatPrefixS,

        const AString & m_Color1, const AString & m_Color2

    );


    void Kick(const AString & a_Reason);  // tolua_export


    bool BungeeAuthenticate();


    void Authenticate(AString && a_Name, const cUUID & a_UUID, Json::Value && a_Properties);


    void StreamNextChunks();


    void UnloadOutOfRangeChunks(void);


    inline bool IsLoggedIn(void) const { return (m_State >= csAuthenticating); }


    void Tick(std::chrono::milliseconds a_Dt);


    void ServerTick(float a_Dt);


    void Destroy(void);


    bool IsPlaying   (void) const { return (m_State == csPlaying); }

    bool IsDestroyed (void) const { return (m_State == csDestroyed); }


    // The following functions send the various packets:

    // (Please keep these alpha-sorted)

    void SendAttachEntity               (const cEntity & a_Entity, const cEntity & a_Vehicle);

    void SendBlockAction                (Vector3i a_BlockPos, char a_Byte1, char a_Byte2, BLOCKTYPE a_BlockType);

    void SendBlockBreakAnim             (UInt32 a_EntityID, Vector3i a_BlockPos, char a_Stage);  // tolua_export

    void SendBlockChange                (Vector3i a_BlockPos, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta);  // tolua_export

    void SendBlockChanges               (int a_ChunkX, int a_ChunkZ, const sSetBlockVector & a_Changes);

    void SendBossBarAdd                 (UInt32 a_UniqueID, const cCompositeChat & a_Title, float a_FractionFilled, BossBarColor a_Color, BossBarDivisionType a_DivisionType, bool a_DarkenSky, bool a_PlayEndMusic, bool a_CreateFog);  // tolua_export

    void SendBossBarUpdateFlags         (UInt32 a_UniqueID, bool a_DarkenSky, bool a_PlayEndMusic, bool a_CreateFog);  // tolua_export

    void SendBossBarUpdateStyle         (UInt32 a_UniqueID, BossBarColor a_Color, BossBarDivisionType a_DivisionType);  // tolua_export

    void SendBossBarUpdateTitle         (UInt32 a_UniqueID, const cCompositeChat & a_Title);  // tolua_export

    void SendBossBarRemove              (UInt32 a_UniqueID);  // tolua_export

    void SendBossBarUpdateHealth        (UInt32 a_UniqueID, float a_FractionFilled);  // tolua_export

    void SendCameraSetTo                (const cEntity & a_Entity);

    void SendChat                       (const AString & a_Message, eMessageType a_ChatPrefix, const AString & a_AdditionalData = "");

    void SendChat                       (const cCompositeChat & a_Message);

    void SendChatRaw                    (const AString & a_MessageRaw, eChatType a_Type);

    void SendChatAboveActionBar         (const AString & a_Message, eMessageType a_ChatPrefix, const AString & a_AdditionalData = "");

    void SendChatAboveActionBar         (const cCompositeChat & a_Message);

    void SendChatSystem                 (const AString & a_Message, eMessageType a_ChatPrefix, const AString & a_AdditionalData = "");

    void SendChatSystem                 (const cCompositeChat & a_Message);

    void SendChunkData                  (int a_ChunkX, int a_ChunkZ, ContiguousByteBufferView a_ChunkData);

    void SendCollectEntity              (const cEntity & a_Collected, const cEntity & a_Collector, unsigned a_Count);   // tolua_export

    void SendDestroyEntity              (const cEntity & a_Entity);   // tolua_export

    void SendDetachEntity               (const cEntity & a_Entity, const cEntity & a_PreviousVehicle);   // tolua_export

    void SendDisconnect                 (const AString & a_Reason);

    void SendDisplayObjective           (const AString & a_Objective, cScoreboard::eDisplaySlot a_Display);

    void SendEditSign                   (Vector3i a_BlockPos);  // tolua_export

    void SendEntityAnimation            (const cEntity & a_Entity, EntityAnimation a_Animation);  // tolua_export

    void SendEntityEffect               (const cEntity & a_Entity, int a_EffectID, int a_Amplifier, int a_Duration);

    void SendEntityEquipment            (const cEntity & a_Entity, short a_SlotNum, const cItem & a_Item);

    void SendEntityHeadLook             (const cEntity & a_Entity);

    void SendEntityLook                 (const cEntity & a_Entity);

    void SendEntityMetadata             (const cEntity & a_Entity);

    void SendEntityPosition             (const cEntity & a_Entity);

    void SendEntityProperties           (const cEntity & a_Entity);

    void SendEntityVelocity             (const cEntity & a_Entity);

    void SendExperience                 (void);

    void SendExperienceOrb              (const cExpOrb & a_ExpOrb);

    void SendExplosion                  (Vector3f a_Position, float a_Power);

    void SendGameMode                   (eGameMode a_GameMode);

    void SendHealth                     (void);

    void SendHeldItemChange             (int a_ItemIndex);

    void SendHideTitle                  (void);   // tolua_export

    void SendInventorySlot              (char a_WindowID, short a_SlotNum, const cItem & a_Item);

    void SendLeashEntity                (const cEntity & a_Entity, const cEntity & a_EntityLeashedTo);  // tolua_export

    void SendMapData                    (const cMap & a_Map, int a_DataStartX, int a_DataStartY);

    void SendPaintingSpawn              (const cPainting & a_Painting);

    void SendParticleEffect             (const AString & a_ParticleName, Vector3f a_Source, Vector3f a_Offset, float a_ParticleData, int a_ParticleAmount);

    void SendParticleEffect             (const AString & a_ParticleName, const Vector3f a_Src, const Vector3f a_Offset, float a_ParticleData, int a_ParticleAmount, std::array<int, 2> a_Data);

    void SendPlayerAbilities            (void);

    void SendPlayerListAddPlayer        (const cPlayer & a_Player);

    void SendPlayerListHeaderFooter     (const cCompositeChat & a_Header, const cCompositeChat & a_Footer);  // tolua_export

    void SendPlayerListRemovePlayer     (const cPlayer & a_Player);

    void SendPlayerListUpdateDisplayName(const cPlayer & a_Player, const AString & a_CustomName);

    void SendPlayerListUpdateGameMode   (const cPlayer & a_Player);

    void SendPlayerListUpdatePing       ();

    void SendPlayerMoveLook             (Vector3d a_Pos, float a_Yaw, float a_Pitch, bool a_IsRelative);

    void SendPlayerMoveLook             (void);

    void SendPlayerPermissionLevel      (void);

    void SendPlayerPosition             (void);

    void SendPlayerSpawn                (const cPlayer & a_Player);

    void SendPluginMessage              (const AString & a_Channel, std::string_view a_Message);  // Exported in ManualBindings.cpp

    void SendPluginMessage              (const AString & a_Channel, ContiguousByteBufferView a_Message);

    void SendRemoveEntityEffect         (const cEntity & a_Entity, int a_EffectID);

    void SendResourcePack               (const AString & a_ResourcePackUrl);  // tolua_export

    void SendResetTitle                 (void);  // tolua_export

    void SendRespawn                    (eDimension a_Dimension, bool a_IsRespawningFromDeath);

    void SendScoreUpdate                (const AString & a_Objective, const AString & a_Player, cObjective::Score a_Score, Byte a_Mode);

    void SendScoreboardObjective        (const AString & a_Name, const AString & a_DisplayName, Byte a_Mode);

    void SendSetSubTitle                (const cCompositeChat & a_SubTitle);  // tolua_export

    void SendSetRawSubTitle             (const AString & a_SubTitle);  // tolua_export

    void SendSetTitle                   (const cCompositeChat & a_Title);  // tolua_export

    void SendSetRawTitle                (const AString & a_Title);  // tolua_export

    void SendSoundEffect                (const AString & a_SoundName, double a_X, double a_Y, double a_Z, float a_Volume, float a_Pitch);  // tolua_export

    void SendSoundEffect                (const AString & a_SoundName, Vector3d a_Position, float a_Volume, float a_Pitch);  // tolua_export

    void SendSoundParticleEffect        (const EffectID a_EffectID, Vector3i a_Source, int a_Data);

    void SendSpawnEntity                (const cEntity & a_Entity);

    void SendSpawnMob                   (const cMonster & a_Mob);

    void SendStatistics                 (const StatisticsManager & a_Manager);

    void SendTabCompletionResults       (const AStringVector & a_Results);

    void SendThunderbolt                (Vector3i a_BlockPos);  // tolua_export

    void SendTitleTimes                 (int a_FadeInTicks, int a_DisplayTicks, int a_FadeOutTicks);  // tolua_export

    void SendTimeUpdate                 (cTickTimeLong a_WorldAge, cTickTimeLong a_WorldDate, bool a_DoDaylightCycle);

    void SendUnleashEntity              (const cEntity & a_Entity);  // tolua_export

    void SendUnloadChunk                (int a_ChunkX, int a_ChunkZ);

    void SendUpdateBlockEntity          (cBlockEntity & a_BlockEntity);

    void SendUpdateSign                 (Vector3i a_BlockPos, const AString & a_Line1, const AString & a_Line2, const AString & a_Line3, const AString & a_Line4);


    void SendUnlockRecipe               (UInt32 a_RecipeId);


    void SendInitRecipes                (UInt32 a_RecipeId);


    void SendWeather                    (eWeather a_Weather);

    void SendWholeInventory             (const cWindow & a_Window);

    void SendWindowClose                (const cWindow & a_Window);

    void SendWindowOpen                 (const cWindow & a_Window);

    void SendWindowProperty             (const cWindow & a_Window, size_t a_Property, short a_Value);


    const AString & GetUsername(void) const;  // tolua_export

    void SetUsername(AString && a_Username);


    // tolua_begin


    inline short GetPing(void) const { return static_cast<short>(std::chrono::duration_cast<std::chrono::milliseconds>(m_Ping).count()); }


    void SetViewDistance(int a_ViewDistance);


    int GetViewDistance(void) const { return m_CurrentViewDistance; }


    int GetRequestedViewDistance(void) const { return m_RequestedViewDistance; }


    void SetLocale(const AString & a_Locale) { m_Locale = a_Locale; }

    AString GetLocale(void) const { return m_Locale; }


    int GetUniqueID(void) const { return m_UniqueID; }


    bool HasPluginChannel(const AString & a_PluginChannel);


    void SetClientBrand(const AString & a_ClientBrand) { m_ClientBrand = a_ClientBrand; }


    const AString & GetClientBrand(void) const { return m_ClientBrand; }


    const AStringMap & GetForgeMods(void) const { return m_ForgeMods; }


    bool IsForgeClient(void) const { return m_ForgeHandshake.IsForgeClient; }


    // tolua_end


    void ForgeAugmentServerListPing(Json::Value & a_Response)

    {

        m_ForgeHandshake.AugmentServerListPing(*this, a_Response);

    }


    void SetIsForgeClient()

    {

        m_ForgeHandshake.IsForgeClient = true;

    }


    bool WantsSendChunk(int a_ChunkX, int a_ChunkZ);


    void AddWantedChunk(int a_ChunkX, int a_ChunkZ);


    // Calls that cProtocol descendants use to report state:

    void PacketBufferFull(void);

    void PacketUnknown(UInt32 a_PacketType);

    void PacketError(UInt32 a_PacketType);


    void HandleAnimation(bool a_SwingMainHand);


    void HandleAnvilItemName(const AString & a_ItemName);


    void HandleBeaconSelection(unsigned a_PrimaryEffect, unsigned a_SecondaryEffect);


    void HandleChat(const AString & a_Message);


    void HandleCommandBlockBlockChange(Vector3i a_BlockPos, const AString & a_NewCommand);


    void HandleCommandBlockEntityChange(UInt32 a_EntityID, const AString & a_NewCommand);


    void HandleCreativeInventory(Int16 a_SlotNum, const cItem & a_HeldItem, eClickAction a_ClickAction);


    void HandleCrouch(bool a_IsCrouching);


    void HandleEnchantItem(UInt8 a_WindowID, UInt8 a_Enchantment);


    bool CheckMultiLogin(const AString & a_Username);


    bool HandleHandshake        (const AString & a_Username);


    void HandleLeaveBed();


    void HandleKeepAlive        (UInt32 a_KeepAliveID);

    void HandleLeftClick        (Vector3i a_BlockPos, eBlockFace a_BlockFace, UInt8 a_Status);


    void HandleNPCTrade(int a_SlotNum);


    void HandleOpenHorseInventory();


    void HandlePing             (void);

    void HandlePlayerAbilities  (bool a_IsFlying, float FlyingSpeed, float WalkingSpeed);

    void HandlePlayerLook       (float a_Rotation, float a_Pitch, bool a_IsOnGround);


    void HandlePlayerMove(Vector3d a_Pos, bool a_IsOnGround);


    void HandlePlayerMoveLook(Vector3d a_Pos, float a_Rotation, float a_Pitch, bool a_IsOnGround);


    void HandlePluginMessage    (const AString & a_Channel, ContiguousByteBufferView a_Message);

    void HandleResourcePack     (UInt8 a_Status);

    void HandleRespawn          (void);

    void HandleRightClick       (Vector3i a_BlockPos, eBlockFace a_BlockFace, Vector3i a_Cursor, bool a_UsedMainHand);

    void HandleSlotSelected     (Int16 a_SlotNum);

    void HandleSpectate         (const cUUID & a_PlayerUUID);


    void HandleSprint(bool a_IsSprinting);


    void HandleStartElytraFlight();


    void HandleSteerVehicle     (float Forward, float Sideways);

    void HandleTabCompletion    (const AString & a_Text);

    void HandleUpdateSign       (

        Vector3i a_BlockPos,

        const AString & a_Line1, const AString & a_Line2,

        const AString & a_Line3, const AString & a_Line4

    );

    void HandleUnmount          (void);

    void HandleUseEntity        (UInt32 a_TargetEntityID, bool a_IsLeftClick);

    void HandleUseItem          (bool a_UsedMainHand);

    void HandleWindowClick      (UInt8 a_WindowID, Int16 a_SlotNum, eClickAction a_ClickAction, const cItem & a_HeldItem);

    void HandleWindowClose      (UInt8 a_WindowID);


    void HandleCraftRecipe      (UInt32 a_RecipeId);


    bool HandleLogin();


    void SendData(ContiguousByteBufferView a_Data);


    void RemoveFromWorld(void);


    void SetProtocolVersion(UInt32 a_ProtocolVersion) { m_ProtocolVersion = a_ProtocolVersion; }


    UInt32 GetProtocolVersion(void) const { return m_ProtocolVersion; }  // tolua_export


    bool IsPlayerChunkSent();


private:


    friend class cForgeHandshake;   // Needs access to FinishAuthenticate()


    typedef std::set<AString> cChannels;


    cForgeHandshake m_ForgeHandshake;


    AStringMap m_ForgeMods;


    int m_CurrentViewDistance;


    int m_RequestedViewDistance;


    AString m_IPString;


    AString m_Username;

    AString m_Password;

    Json::Value m_Properties;


    cCriticalSection                                   m_CSChunkLists;

    std::unordered_set<cChunkCoords, cChunkCoordsHash> m_LoadedChunks;  // Chunks that the player belongs to

    std::unordered_set<cChunkCoords, cChunkCoordsHash> m_ChunksToSend;  // Chunks that need to be sent to the player (queued because they weren't generated yet or there's not enough time to send them)

    cChunkCoordsList                                   m_SentChunks;    // Chunks that are currently sent to the client


    cMultiVersionProtocol m_Protocol;


    cCriticalSection m_CSIncomingData;


    ContiguousByteBuffer m_IncomingData;


    cCriticalSection m_CSOutgoingData;


    ContiguousByteBuffer m_OutgoingData;


    cPlayer * m_Player;


    cChunkCoords m_CachedSentChunk;


    bool m_ProxyConnection;


    bool m_HasSentDC;


    // Chunk position when the last StreamChunks() was called; used to avoid re-streaming while in the same chunk

    int m_LastStreamedChunkX;

    int m_LastStreamedChunkZ;


    std::atomic<int> m_TicksSinceLastPacket;


    std::chrono::milliseconds m_TimeSinceLastUnloadCheck;


    std::chrono::steady_clock::duration m_Ping;


    UInt32 m_PingID;


    std::chrono::steady_clock::time_point m_PingStartTime;


    // Values required for block dig animation

    int m_BlockDigAnimStage;  // Current stage of the animation; -1 if not digging

    int m_BlockDigAnimSpeed;  // Current speed of the animation (units ???)

    Vector3i m_BlockDigAnimPos;


    // To avoid dig / aim bug in the client, store the last position given in a DIG_START packet and compare to that when processing the DIG_FINISH packet:

    bool m_HasStartedDigging;

    Vector3i m_LastDigBlockPos;


    enum eState

    {

        csConnected,

        csAuthenticating,

        csDownloadingWorld,

        csPlaying,

        csDestroyed,

    } ;


    /* Mutex protecting m_State from concurrent writes. */

    cCriticalSection m_CSState;


    std::atomic<eState> m_State;


    int m_NumExplosionsThisTick;


    int m_NumBlockChangeInteractionsThisTick;


    static int s_ClientCount;


    static Vector3i s_IllegalPosition;


    int m_UniqueID;


    cUUID m_UUID;


    bool m_HasSentPlayerChunk;


    AString m_Locale;


    Vector3i m_LastPlacedSign;


    cChannels m_PluginChannels;


    AString m_ClientBrand;


    UInt32 m_ProtocolVersion;


    cTCPLinkPtr m_Link;


    float m_BreakProgress;


    void FinishAuthenticate();


    bool CheckBlockInteractionsRate(void);


    bool IsWithinReach(Vector3i a_Position) const;


    void StreamChunk(int a_ChunkX, int a_ChunkZ, cChunkSender::Priority a_Priority);


    void HandleBlockDigStarted (Vector3i a_BlockPos, eBlockFace a_BlockFace);


    void HandleBlockDigFinished(Vector3i a_BlockPos, eBlockFace a_BlockFace);


    void FinishDigAnimation();


    AStringVector BreakApartPluginChannels(ContiguousByteBufferView a_PluginChannels);


    void RegisterPluginChannels(const AStringVector & a_ChannelList);


    void UnregisterPluginChannels(const AStringVector & a_ChannelList);


    void SocketClosed(void);


    bool SetState(eState a_NewState);


    // cTCPLink::cCallbacks overrides:

    virtual void OnLinkCreated(cTCPLinkPtr a_Link) override;

    virtual void OnReceivedData(const char * a_Data, size_t a_Length) override;

    virtual void OnRemoteClosed(void) override;

    virtual void OnError(int a_ErrorCode, const AString & a_ErrorMsg) override;

};  // tolua_export