ClientHandle.h

Go to the documentation of this file.

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