df/d4c/a00851_source.html

#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