Player.h

Go to the documentation of this file.

 
#pragma once
 
#include "Pawn.h"
#include "../Inventory.h"
#include "../Defines.h"
#include "../World.h"
#include "../Items/ItemHandler.h"
 
#include "../StatisticsManager.h"
 
#include "../UUID.h"
 
 
 
 
 
class cWindow;
class cClientHandle;
class cTeam;
 
 
 
 
 
// tolua_begin
class cPlayer:
    public cPawn
{
    // tolua_end
 
    using Super = cPawn;
 
    struct BodyStanceCrouching
    {
        BodyStanceCrouching(cPlayer & a_Player);
    };
 
    struct BodyStanceSleeping
    {
        BodyStanceSleeping(cPlayer & a_Player);
    };
 
    struct BodyStanceSprinting
    {
    };
 
    struct BodyStanceStanding
    {
        BodyStanceStanding(cPlayer & a_Player);
    };
 
    struct BodyStanceGliding
    {
        BodyStanceGliding(cPlayer & a_Player);
 
        cTickTime TicksElytraFlying;
    };
 
    /*
    struct HandStanceNeutral
    {
    };
 
    struct HandStandChargingBow
    {
        int m_BowCharge;
    };
 
    struct HandStanceEating
    {
    };
    */
 
    // tolua_begin
 
public:
 
    static const int MAX_HEALTH;
 
    static const int MAX_FOOD_LEVEL;
 
    // tolua_end
 
    CLASS_PROTODEF(cPlayer)
 
    cPlayer(const std::shared_ptr<cClientHandle> & a_Client);
    virtual ~cPlayer() override;
 
    void OnLoseSpectated();
 
    // tolua_begin
 
    bool SetCurrentExperience(int a_XpTotal);
 
    /* changes Xp by Xp_delta, you "shouldn't" inc more than MAX_EXPERIENCE_ORB_SIZE
    Wont't allow xp to go negative
    Returns the new current experience, -1 on error
    */
    int DeltaExperience(int a_Xp_delta);
 
    inline int GetXpLifetimeTotal(void) { return m_LifetimeTotalXp; }
 
    inline int GetCurrentXp(void) { return m_CurrentXp; }
 
    int GetXpLevel(void) const;
 
    float GetXpPercentage(void) const;
 
    static int XpForLevel(int a_Level);
 
    static int CalcLevelFromXp(int a_CurrentXp);
 
    // tolua_end
 
    const std::set<UInt32> & GetKnownRecipes() const;
 
    void StartChargingBow(void);
 
    int FinishChargingBow(void);
 
    void CancelChargingBow(void);
 
    bool IsChargingBow(void) const { return m_IsChargingBow; }
 
    void SetTouchGround(bool a_bTouchGround);
    double GetEyeHeight(void) const;  // tolua_export
    Vector3d GetEyePosition(void) const;  // tolua_export
    inline cInventory &       GetInventory(void)       { return m_Inventory; }  // tolua_export
    inline const cInventory & GetInventory(void) const { return m_Inventory; }
 
    cItemGrid & GetEnderChestContents(void) { return m_EnderChestContents; }
 
    inline const cItem & GetEquippedItem(void) const { return GetInventory().GetEquippedItem(); }  // tolua_export
 
    bool IsClimbing(void) const;
 
    virtual void TeleportToCoords(double a_PosX, double a_PosY, double a_PosZ) override;
 
    void UpdateCapabilities();
 
    // tolua_begin
 
    void Freeze(const Vector3d & a_Location);
 
    bool IsFrozen();
 
    void Unfreeze();
 
    void SendRotation(double a_YawDegrees, double a_PitchDegrees);
 
    void SpectateEntity(cEntity * a_Target);
 
    Vector3d GetThrowStartPos(void) const;
 
    Vector3d GetThrowSpeed(double a_SpeedCoeff) const;
 
    eGameMode GetGameMode(void) const { return m_GameMode; }
 
    eGameMode GetEffectiveGameMode(void) const;
 
    void SetGameMode(eGameMode a_GameMode);
 
    bool IsGameModeCreative(void) const;
 
    bool IsGameModeSurvival(void) const;
 
    bool IsGameModeAdventure(void) const;
 
    bool IsGameModeSpectator(void) const;
 
    virtual bool IsFireproof() const override
    {
        return (m_IsFireproof || IsGameModeCreative() || IsGameModeSpectator());
 
    }
 
    bool CanMobsTarget(void) const;
 
    AString GetIP(void) const;  // tolua_export
 
    StatisticsManager & GetStatistics() { return m_Stats; }
 
    cTeam * GetTeam(void) { return m_Team; }  // tolua_export
 
    const cTeam * GetTeam(void) const { return m_Team; }
 
    void SetTeam(cTeam * a_Team);
 
    // tolua_end
 
    cTeam * UpdateTeam(void);
 
    void AwardAchievement(CustomStatistic a_Ach);
 
    void ForceSetSpeed(const Vector3d & a_Speed);  // tolua_export
 
    cWindow * GetWindow(void) { return m_CurrentWindow; }  // tolua_export
    const cWindow * GetWindow(void) const { return m_CurrentWindow; }
 
    // tolua_begin
 
    void OpenWindow(cWindow & a_Window);
 
    void CloseWindow(bool a_CanRefuse = true);
 
    void CloseWindowIfID(char a_WindowID, bool a_CanRefuse = true);
 
    cClientHandle * GetClientHandle(void) const { return m_ClientHandle.get(); }
 
    // tolua_end
 
    MTRand GetEnchantmentRandomProvider();
 
    void PermuteEnchantmentSeed();
 
    // tolua_begin
 
    void SendMessage              (const AString & a_Message);
    void SendMessageInfo          (const AString & a_Message);
    void SendMessageFailure       (const AString & a_Message);
    void SendMessageSuccess       (const AString & a_Message);
    void SendMessageWarning       (const AString & a_Message);
    void SendMessageFatal         (const AString & a_Message);
    void SendMessagePrivateMsg    (const AString & a_Message, const AString & a_Sender);
    void SendMessage              (const cCompositeChat & a_Message);
    void SendMessageRaw           (const AString & a_MessageRaw, eChatType a_Type = eChatType::ctChatBox);
    void SendSystemMessage        (const AString & a_Message);
    void SendAboveActionBarMessage(const AString & a_Message);
    void SendSystemMessage        (const cCompositeChat & a_Message);
    void SendAboveActionBarMessage(const cCompositeChat & a_Message);
 
    const AString & GetName(void) const;
 
    // tolua_end
 
    bool HasPermission(const AString & a_Permission) const;  // tolua_export
 
    static bool PermissionMatches(const AStringVector & a_Permission, const AStringVector & a_Template);  // Exported in ManualBindings with AString params
 
    const AStringVector & GetPermissions(void) const { return m_Permissions; }  // Exported in ManualBindings.cpp
 
    const AStringVector & GetRestrictions(void) const { return m_Restrictions; }  // Exported in ManualBindings.cpp
 
    // tolua_begin
 
    AString GetColor(void) const;
 
    AString GetPrefix(void) const;
 
    AString GetSuffix(void) const;
 
    AString GetPlayerListName(void) const;
 
    void TossEquippedItem(char a_Amount = 1);
 
    void ReplaceOneEquippedItemTossRest(const cItem &);
 
    void TossHeldItem(char a_Amount = 1);
 
    void TossPickup(const cItem & a_Item);
 
    virtual void Heal(int a_Health) override;
 
    int    GetFoodLevel                 (void) const { return m_FoodLevel; }
    double GetFoodSaturationLevel       (void) const { return m_FoodSaturationLevel; }
    int    GetFoodTickTimer             (void) const { return m_FoodTickTimer; }
    double GetFoodExhaustionLevel       (void) const { return m_FoodExhaustionLevel; }
 
    bool IsSatiated(void) const { return (m_FoodLevel >= MAX_FOOD_LEVEL); }
 
    void SetFoodLevel                 (int a_FoodLevel);
    void SetFoodSaturationLevel       (double a_FoodSaturationLevel);
    void SetFoodTickTimer             (int a_FoodTickTimer);
    void SetFoodExhaustionLevel       (double a_FoodExhaustionLevel);
 
    bool Feed(int a_Food, double a_Saturation);
 
    void AddFoodExhaustion(double a_Exhaustion);
 
    bool IsEating(void) const { return m_EatingFinishTick >= 0_tick; }
 
    bool IsFlying(void) const { return m_IsFlying; }
 
    bool IsInBed(void) const;
 
    bool IsLeftHanded() const;
 
    bool IsFishing(void) const { return m_IsFishing; }
 
    void SetIsFishing(bool a_IsFishing, UInt32 a_FloaterID = cEntity::INVALID_ID) { m_IsFishing = a_IsFishing; m_FloaterID = a_FloaterID; }
 
    UInt32 GetFloaterID(void) const { return m_FloaterID; }
 
    // tolua_end
 
    bool IsStanding() const;
 
    void TossItems(const cItems & a_Items);
 
    void SetIsInBed(bool a_IsInBed);
 
    void StartEating(void);
 
    void FinishEating(void);
 
    void AbortEating(void);
 
    virtual void KilledBy(TakeDamageInfo & a_TDI) override;
 
    virtual void Killed(const cEntity & a_Victim, eDamageType a_DamageType) override;
 
    void Respawn(void);  // tolua_export
 
    void SetVisible( bool a_bVisible);  // tolua_export
 
    void SaveToDisk(void);
 
    void LoadFromDisk();
 
    const AString & GetLoadedWorldName() const { return m_CurrentWorldName; }
 
    void OpenHorseInventory();
 
    void UseEquippedItem(short a_Damage = 1);
 
    void UseEquippedItem(cItemHandler::eDurabilityLostAction a_Action);
 
    void UseItem(int a_SlotNumber, short a_Damage = 1);
 
    cItem & GetDraggingItem(void) {return m_DraggingItem; }  // tolua_export
 
    void SetDraggingItem(const cItem & a_Item);  // tolua_export
 
    // In UI windows, when inventory-painting:
    void ClearInventoryPaintSlots(void);
 
    void AddInventoryPaintSlot(int a_SlotNum);
 
    const cSlotNums & GetInventoryPaintSlots(void) const;
 
    // tolua_begin
 
    double GetMaxSpeed(void) const;
 
    double GetNormalMaxSpeed(void) const { return m_NormalMaxSpeed; }
 
    double GetSprintingMaxSpeed(void) const { return m_SprintingMaxSpeed; }
 
    double GetFlyingMaxSpeed(void) const { return m_FlyingMaxSpeed; }
 
    void SetNormalMaxSpeed(double a_Speed);
 
    void SetSprintingMaxSpeed(double a_Speed);
 
    void SetFlyingMaxSpeed(double a_Speed);
 
    void SetCrouch(bool a_ShouldCrouch);
 
    void SetElytraFlight(bool a_ShouldElytraFly);
 
    void SetFlying(bool a_ShouldFly);
 
    void SetLeftHanded(bool a_IsLeftHanded);
 
    void SetSprint(bool a_ShouldSprint);
 
    void SetCanFly(bool a_CanFly);
 
    bool HasCustomName(void) const { return !m_CustomName.empty(); }
 
    const AString & GetCustomName(void) const { return m_CustomName; }
 
    void SetCustomName(const AString & a_CustomName);
 
    Vector3i GetLastBedPos(void) const { return m_RespawnPosition; }
 
    bool IsRespawnPointForced(void) const { return m_IsRespawnPointForced; }
 
    void SetBedPos(Vector3i a_Position);
 
    void SetBedPos(Vector3i a_Position, const cWorld & a_World);
 
    void SetRespawnPosition(Vector3i a_Position, const cWorld & a_World);
 
    // tolua_end
 
    // TODO lua export GetRespawnWorld
    cWorld * GetRespawnWorld();
 
    void UpdateMovementStats(const Vector3d & a_DeltaPos, bool a_PreviousIsOnGround);
 
    bool DoesPlacingBlocksIntersectEntity(std::initializer_list<sSetBlock> a_Blocks) const;
 
    const cUUID & GetUUID(void) const;  // Exported in ManualBindings.cpp
 
    // tolua_begin
 
    virtual bool CanFly(void) const { return m_IsFlightCapable; }
 
    void LoadRank(void);
 
    void SendBlocksAround(Vector3i a_BlockPos, int a_Range = 1);
 
    bool HasSkinPart(eSkinPart a_Part) const { return (m_SkinParts & a_Part) != 0; }
    int GetSkinParts(void) const { return m_SkinParts; }
    void SetSkinParts(int a_Parts);
 
    // tolua_end
 
    bool PlaceBlock(Vector3i a_Position, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta);
 
    bool PlaceBlocks(std::initializer_list<sSetBlock> a_Blocks);
 
    void NotifyNearbyWolves(cPawn * a_Opponent, bool a_IsPlayerInvolved);
 
    float GetMiningProgressPerTick(BLOCKTYPE a_Block);
 
    bool CanInstantlyMine(BLOCKTYPE a_Block);
 
    void AddKnownItem(const cItem & a_Item);
 
    // cEntity overrides:
    virtual cItem GetEquippedWeapon(void) const override { return m_Inventory.GetEquippedItem(); }
    virtual cItem GetEquippedHelmet(void) const override { return m_Inventory.GetEquippedHelmet(); }
    virtual cItem GetEquippedChestplate(void) const override { return m_Inventory.GetEquippedChestplate(); }
    virtual cItem GetEquippedLeggings(void) const override { return m_Inventory.GetEquippedLeggings(); }
    virtual cItem GetEquippedBoots(void) const override { return m_Inventory.GetEquippedBoots(); }
    virtual cItem GetOffHandEquipedItem(void) const override { return m_Inventory.GetShieldSlot(); }
    virtual bool IsCrouched(void) const override;
    virtual bool IsOnGround(void) const override { return m_bTouchGround; }
    virtual bool IsSprinting(void) const override;
 
private:
 
    typedef std::vector<std::vector<AString> > AStringVectorVector;
 
    std::variant<BodyStanceCrouching, BodyStanceSleeping, BodyStanceSprinting, BodyStanceStanding, BodyStanceGliding> m_BodyStance;
 
    AString m_Rank;
 
    AStringVector m_Permissions;
 
    AStringVector m_Restrictions;
 
    AStringVectorVector m_SplitPermissions;
 
    AStringVectorVector m_SplitRestrictions;
 
    // Message visuals:
    AString m_MsgPrefix, m_MsgSuffix;
    AString m_MsgNameColorCode;
 
    // Food-related variables:
    int m_FoodLevel;
 
    double m_FoodSaturationLevel;
 
    int m_FoodTickTimer;
 
    double m_FoodExhaustionLevel;
 
    cInventory m_Inventory;
 
    cItemGrid m_EnderChestContents;
 
    cWindow * m_CurrentWindow;
    cWindow * m_InventoryWindow;
 
    Vector3i m_RespawnPosition;
 
    std::string m_SpawnWorldName;
 
    std::string m_CurrentWorldName;
 
    std::string m_DefaultWorldPath;
 
    eGameMode m_GameMode;
 
    cItem m_DraggingItem;
 
    std::shared_ptr<cClientHandle> m_ClientHandle;
 
    cSlotNums m_InventoryPaintSlots;
 
    double m_NormalMaxSpeed;
 
    double m_SprintingMaxSpeed;
 
    double m_FlyingMaxSpeed;
 
    bool m_IsChargingBow;
    bool m_IsFishing;
 
    bool m_IsFlightCapable;
 
    bool m_IsFlying;
 
    bool m_IsFrozen;
 
    bool m_IsLeftHanded;
 
    bool m_IsManuallyFrozen;
 
    bool m_IsRespawnPointForced;
 
    bool m_IsTeleporting;
 
    bool m_IsVisible;
 
    cTickTimeLong m_EatingFinishTick;
 
    int m_LifetimeTotalXp;
    int m_CurrentXp;
    unsigned int m_EnchantmentSeed;
 
    int m_BowCharge;
 
    UInt32 m_FloaterID;
 
    cTeam * m_Team;
 
    cEntity * m_Spectating;
 
    StatisticsManager m_Stats;
 
    unsigned int m_TicksUntilNextSave;
 
    AString m_CustomName;
 
    int m_SkinParts;
 
    std::set<UInt32> m_KnownRecipes;
 
    std::set<cItem, cItem::sItemCompare> m_KnownItems;
 
    void HandleFood(void);
 
    void HandleFloater(void);
 
    AString GetUUIDFileName(const cUUID & a_UUID);
 
    void FreezeInternal(const Vector3d & a_Location, bool a_ManuallyFrozen);
 
    float GetLiquidHeightPercent(NIBBLETYPE a_Meta);
 
    bool IsInsideWater();
 
    float GetDigSpeed(BLOCKTYPE a_Block);
 
    void AddKnownRecipe(UInt32 RecipeId);
 
    void TickFreezeCode();
 
    void RefreshRank();
 
    // cEntity overrides:
    virtual void ApplyArmorDamage(int DamageBlocked) override;
    virtual void BroadcastMovementUpdate(const cClientHandle * a_Exclude = nullptr) override;
    virtual bool DoTakeDamage(TakeDamageInfo & TDI) override;
    virtual float GetEnchantmentBlastKnockbackReduction() override;
    virtual void HandlePhysics(std::chrono::milliseconds a_Dt, cChunk &) override { UNUSED(a_Dt); }
    virtual bool IsElytraFlying(void) const override;
    virtual bool IsInvisible() const override;
    virtual bool IsRclking(void) const override { return IsEating() || IsChargingBow(); }
    virtual void OnAddToWorld(cWorld & a_World) override;
    virtual void OnDetach() override;
    virtual void OnRemoveFromWorld(cWorld & a_World) override;
    virtual void SpawnOn(cClientHandle & a_Client) override;
    virtual void Tick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) override;
 
} ;  // tolua_export