Entity.h

Go to the documentation of this file.

 
#pragma once
 
#include "../BoundingBox.h"
#include "../Item.h"
#include "../OSSupport/AtomicUniquePtr.h"
 
 
 
 
 
// Place this macro in the public section of each cEntity descendant class and you're done :)
#define CLASS_PROTODEF(classname) \
    virtual bool IsA(const char * a_ClassName) const override\
    { \
        return ((a_ClassName != nullptr) && ((strcmp(a_ClassName, #classname) == 0) || Super::IsA(a_ClassName))); \
    } \
    virtual const char * GetClass(void) const override \
    { \
        return #classname; \
    } \
    static const char * GetClassStatic(void) \
    { \
        return #classname; \
    } \
    virtual const char * GetParentClass(void) const override \
    { \
        return Super::GetClass(); \
    }
 
#define POSX_TOINT FloorC(GetPosX())
#define POSY_TOINT FloorC(GetPosY())
#define POSZ_TOINT FloorC(GetPosZ())
#define POS_TOINT  GetPosition().Floor()
 
#define GET_AND_VERIFY_CURRENT_CHUNK(ChunkVarName, X, Z) \
    cChunk * ChunkVarName = a_Chunk.GetNeighborChunk(X, Z); \
    do { \
        if ((ChunkVarName == nullptr) || !ChunkVarName->IsValid()) \
        { \
            return; \
        } \
    } while (false)
 
 
 
 
class cWorld;
class cClientHandle;
class cPlayer;
class cChunk;
class cMonster;
 
 
 
 
 
// tolua_begin
struct TakeDamageInfo
{
    eDamageType DamageType;   // Where does the damage come from? Being hit / on fire / contact with cactus / ...
    cEntity *   Attacker;     // The attacking entity; valid only for dtAttack
    int         RawDamage;    // What damage would the receiver get without any armor. Usually: attacker mob type + weapons
    float       FinalDamage;  // What actual damage will be received. Usually: m_RawDamage minus armor
    Vector3d    Knockback;    // The amount and direction of knockback received from the damage
    // TODO: Effects - list of effects that the hit is causing. Unknown representation yet
} ;
// tolua_end
 
 
 
 
 
// tolua_begin
class cEntity
{
protected:
    struct sWorldChangeInfo
    {
        cWorld * m_NewWorld;
        Vector3d m_NewPosition;
        bool m_SetPortalCooldown;
    };
 
public:
 
    enum eEntityType
    {
        etEntity,  // For all other types
        etEnderCrystal,
        etPlayer,
        etPickup,
        etMonster,
        etFallingBlock,
        etMinecart,
        etBoat,
        etTNT,
        etProjectile,
        etExpOrb,
        etFloater,
        etItemFrame,
        etPainting,
        etLeashKnot,
 
        // Common variations
        etMob = etMonster,  // DEPRECATED, use etMonster instead!
    } ;
 
    // tolua_end
 
    static const int FIRE_TICKS_PER_DAMAGE = 10;   
    static const int FIRE_DAMAGE           = 1;    
    static const int LAVA_TICKS_PER_DAMAGE = 10;   
    static const int LAVA_DAMAGE           = 4;    
    static const int BURN_TICKS_PER_DAMAGE = 20;   
    static const int BURN_DAMAGE           = 1;    
 
    static const int BURN_TICKS            = 160;  
 
    static const int MAX_AIR_LEVEL         = 300;  
    static const int DROWNING_TICKS        = 20;   
 
    static const int VOID_BOUNDARY         = -64;  
    static const int FALL_DAMAGE_HEIGHT    = 4;    
 
    static const UInt32 INVALID_ID = 0;  // Exported to Lua in ManualBindings.cpp, ToLua doesn't parse initialized constants.
 
 
    cEntity(eEntityType a_EntityType, Vector3d a_Pos, float a_Width, float a_Height);
    virtual ~cEntity() = default;
 
    bool Initialize(OwnedEntity a_Self, cWorld & a_EntityWorld);
 
    void OnAcquireSpectator(cPlayer & a_Player);
 
    virtual void OnAddToWorld(cWorld & a_World);
 
    void OnLoseSpectator(cPlayer & a_Player);
 
    virtual void OnRemoveFromWorld(cWorld & a_World);
 
    // tolua_begin
 
    eEntityType GetEntityType(void) const { return m_EntityType; }
 
    bool IsArrow       (void) const { return IsA("cArrowEntity");              }
    bool IsEnderCrystal(void) const { return (m_EntityType == etEnderCrystal); }
    bool IsPlayer      (void) const { return (m_EntityType == etPlayer);       }
    bool IsPickup      (void) const { return (m_EntityType == etPickup);       }
    bool IsMob         (void) const { return (m_EntityType == etMonster);      }
    bool IsPawn        (void) const { return (IsMob() || IsPlayer());          }
    bool IsFallingBlock(void) const { return (m_EntityType == etFallingBlock); }
    bool IsMinecart    (void) const { return (m_EntityType == etMinecart);     }
    bool IsBoat        (void) const { return (m_EntityType == etBoat);         }
    bool IsTNT         (void) const { return (m_EntityType == etTNT);          }
    bool IsProjectile  (void) const { return (m_EntityType == etProjectile);   }
    bool IsExpOrb      (void) const { return (m_EntityType == etExpOrb);       }
    bool IsFloater     (void) const { return (m_EntityType == etFloater);      }
    bool IsItemFrame   (void) const { return (m_EntityType == etItemFrame);    }
    bool IsLeashKnot   (void) const { return (m_EntityType == etLeashKnot);    }
    bool IsPainting    (void) const { return (m_EntityType == etPainting);     }
 
    virtual bool IsA(const char * a_ClassName) const;
 
    static const char * GetClassStatic(void);
 
    virtual const char * GetClass(void) const;
 
    virtual const char * GetParentClass(void) const;
 
    virtual bool DoesPreventBlockPlacement(void) const { return true; }
 
    cWorld * GetWorld(void) const { return m_World; }
 
    double           GetHeadYaw   (void) const { return m_HeadYaw; }  // In degrees
    float            GetHeight    (void) const { return m_Height;  }
    double           GetMass      (void) const { return m_Mass;    }
    double           GetPosX      (void) const { return m_Position.x; }
    double           GetPosY      (void) const { return m_Position.y; }
    double           GetPosZ      (void) const { return m_Position.z; }
    double           GetYaw       (void) const { return m_Rot.x;   }  // In degrees, [-180, +180)
    double           GetPitch     (void) const { return m_Rot.y;   }  // In degrees, [-180, +180), but normal client clips to [-90, +90]
    double           GetRoll      (void) const { return m_Rot.z;   }  // In degrees, unused in current client
    Vector3d         GetLookVector(void) const;
    double           GetSpeedX    (void) const { return m_Speed.x; }
    double           GetSpeedY    (void) const { return m_Speed.y; }
    double           GetSpeedZ    (void) const { return m_Speed.z; }
    float            GetWidth     (void) const { return m_Width;   }
 
    int GetChunkX(void) const { return FloorC(m_Position.x / cChunkDef::Width); }
    int GetChunkZ(void) const { return FloorC(m_Position.z / cChunkDef::Width); }
 
    // Get the Entity's axis aligned bounding box, with absolute (world-relative) coordinates.
    cBoundingBox GetBoundingBox() const { return cBoundingBox(GetPosition(), GetWidth() / 2, GetHeight()); }
 
    void SetHeadYaw (double a_HeadYaw);
    void SetMass    (double a_Mass);
    void SetPosX    (double a_PosX) { SetPosition({a_PosX, m_Position.y, m_Position.z}); }
    void SetPosY    (double a_PosY) { SetPosition({m_Position.x, a_PosY, m_Position.z}); }
    void SetPosZ    (double a_PosZ) { SetPosition({m_Position.x, m_Position.y, a_PosZ}); }
    void SetPosition(double a_PosX, double a_PosY, double a_PosZ) { SetPosition({a_PosX, a_PosY, a_PosZ}); }
    void SetPosition(const Vector3d & a_Position);
    void SetYaw     (double a_Yaw);    // In degrees, normalizes to [-180, +180)
    void SetPitch   (double a_Pitch);  // In degrees, normalizes to [-180, +180)
    void SetRoll    (double a_Roll);   // In degrees, normalizes to [-180, +180)
 
    void SetSpeed(double a_SpeedX, double a_SpeedY, double a_SpeedZ);
 
    void SetSpeed(Vector3d a_Speed) { SetSpeed(a_Speed.x, a_Speed.y, a_Speed.z); }
 
    void SetSpeedX(double a_SpeedX);
 
    void SetSpeedY(double a_SpeedY);
 
    void SetSpeedZ(double a_SpeedZ);
 
    void AddPosX    (double a_AddPosX) { AddPosition(a_AddPosX, 0, 0); }
    void AddPosY    (double a_AddPosY) { AddPosition(0, a_AddPosY, 0); }
    void AddPosZ    (double a_AddPosZ) { AddPosition(0, 0, a_AddPosZ); }
    void AddPosition(double a_AddPosX, double a_AddPosY, double a_AddPosZ) { SetPosition(m_Position + Vector3d(a_AddPosX, a_AddPosY, a_AddPosZ)); }
    void AddPosition(const Vector3d & a_AddPos) { AddPosition(a_AddPos.x, a_AddPos.y, a_AddPos.z); }
    void AddSpeed   (double a_AddSpeedX, double a_AddSpeedY, double a_AddSpeedZ);
    void AddSpeed   (const Vector3d & a_AddSpeed) { AddSpeed(a_AddSpeed.x, a_AddSpeed.y, a_AddSpeed.z); }
    void AddSpeedX  (double a_AddSpeedX);
    void AddSpeedY  (double a_AddSpeedY);
    void AddSpeedZ  (double a_AddSpeedZ);
 
    virtual void HandleSpeedFromAttachee(float a_Forward, float a_Sideways);
    void SteerVehicle(float a_Forward, float a_Sideways);
 
    inline UInt32 GetUniqueID(void) const { return m_UniqueID; }
 
    inline bool IsDestroyed() const {return !IsTicking();}
 
    bool IsTicking(void) const;
 
    // tolua_end
    void Destroy();
    // tolua_begin
 
    void TakeDamage(cEntity & a_Attacker);
 
    void TakeDamage(eDamageType a_DamageType, cEntity * a_Attacker, int a_RawDamage, double a_KnockbackAmount);
 
    void TakeDamage(eDamageType a_DamageType, UInt32 a_Attacker, int a_RawDamage, double a_KnockbackAmount);
 
    void TakeDamage(eDamageType a_DamageType, cEntity * a_Attacker, int a_RawDamage, float a_FinalDamage, double a_KnockbackAmount);
 
    float GetGravity(void) const { return m_Gravity; }
 
    void SetGravity(float a_Gravity) { m_Gravity = a_Gravity; }
 
    float GetAirDrag(void) const { return m_AirDrag; }
 
    void SetAirDrag(float a_AirDrag) { m_AirDrag = a_AirDrag; }
 
    void SetYawFromSpeed(void);
 
    void SetPitchFromSpeed(void);
 
    // tolua_end
 
    const Vector3d & GetPosition(void) const { return m_Position; }
 
    const Vector3d & GetSpeed(void) const { return m_Speed; }
 
    Vector3d GetLastSentPosition(void) const { return m_LastSentPosition; }
 
    virtual bool DoTakeDamage(TakeDamageInfo & a_TDI);
 
    // tolua_begin
 
    virtual int GetRawDamageAgainst(const cEntity & a_Receiver);
 
    virtual bool ArmorCoversAgainst(eDamageType a_DamageType);
 
    virtual float GetArmorCoverAgainst(const cEntity * a_Attacker, eDamageType a_DamageType, int a_RawDamage);
 
    virtual float GetEnchantmentCoverAgainst(const cEntity * a_Attacker, eDamageType a_DamageType, int a_Damage);
 
    virtual float GetEnchantmentBlastKnockbackReduction();
 
    virtual double GetKnockbackAmountAgainst(const cEntity & a_Receiver);
 
    virtual cItem GetEquippedWeapon(void) const { return cItem(); }
 
    virtual cItem GetEquippedHelmet(void) const { return cItem(); }
 
    virtual cItem GetEquippedChestplate(void) const { return cItem(); }
 
    virtual cItem GetEquippedLeggings(void) const { return cItem(); }
 
    virtual cItem GetEquippedBoots(void) const { return cItem(); }
 
    virtual cItem GetOffHandEquipedItem(void) const { return cItem(); }
 
    virtual void ApplyArmorDamage(int DamageBlocked);
 
    // tolua_end
 
    virtual void KilledBy(TakeDamageInfo & a_TDI);
 
    // tolua_begin
 
    virtual void Killed(const cEntity & a_Victim, eDamageType a_DamageType) {}
 
    virtual void Heal(int a_HitPoints);
 
    float GetHealth(void) const { return m_Health; }
 
    void SetHealth(float a_Health);
 
    // tolua_end
 
    virtual void Tick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk);
 
    virtual void HandlePhysics(std::chrono::milliseconds a_Dt, cChunk & a_Chunk);
 
    virtual void TickBurning(cChunk & a_Chunk);
 
    virtual void DetectCacti(void);
 
    virtual void DetectMagma(void);
 
    virtual bool DetectPortal(void);
 
    virtual void TickInVoid(cChunk & a_Chunk);
 
    virtual void OnStartedBurning(void);
 
    virtual void OnFinishedBurning(void);
 
    // tolua_begin
 
    void SetMaxHealth(float a_MaxHealth);
 
    float GetMaxHealth(void) const { return m_MaxHealth; }
 
    void SetIsFireproof(bool a_IsFireproof);
 
    virtual bool IsFireproof(void) const { return m_IsFireproof; }
 
    void StartBurning(int a_TicksLeftBurning);
 
    void StopBurning(void);
 
    // tolua_end
 
    virtual void SpawnOn(cClientHandle & a_Client) = 0;
 
    // tolua_begin
 
    virtual void TeleportToEntity(cEntity & a_Entity);
 
    virtual void TeleportToCoords(double a_PosX, double a_PosY, double a_PosZ);
 
    bool MoveToWorld(cWorld & a_World, Vector3d a_NewPosition, bool a_ShouldSetPortalCooldown = false, bool a_ShouldSendRespawn = true);
 
    bool MoveToWorld(cWorld & a_World, bool a_ShouldSendRespawn, Vector3d a_NewPosition)
    {
        return MoveToWorld(a_World, a_NewPosition, false, a_ShouldSendRespawn);
    }
 
    bool MoveToWorld(cWorld & a_World, bool a_ShouldSendRespawn = true);
 
    bool MoveToWorld(const AString & a_WorldName, bool a_ShouldSendRespawn = true);
 
    // tolua_end
 
    bool IsWorldChangeScheduled() const
    {
        return (m_WorldChangeInfo.m_NewWorld != nullptr);
    }
 
    virtual void BroadcastMovementUpdate(const cClientHandle * a_Exclude = nullptr);
 
    cEntity * GetAttached();
 
    void AttachTo(cEntity & a_AttachTo);
 
    void Detach(void);
 
    bool IsAttachedTo(const cEntity * a_Entity) const;
 
    bool IsOrientationDirty() const;
 
    void WrapHeadYaw();
 
    void WrapRotation();
 
    void WrapSpeed();
 
    // tolua_begin
 
    // COMMON metadata flags; descendants may override the defaults:
    virtual bool IsCrouched    (void) const { return false; }
    virtual bool IsElytraFlying(void) const { return false; }
    virtual bool IsInvisible   (void) const { return false; }
    virtual bool IsOnFire      (void) const { return m_TicksLeftBurning > 0; }
    virtual bool IsRclking     (void) const { return false; }
    virtual bool IsRiding      (void) const { return false; }
    virtual bool IsSprinting   (void) const { return false; }
 
    virtual bool IsInFire(void) const { return m_IsInFire; }
 
    virtual bool IsInLava(void) const { return m_IsInLava; }
 
    virtual bool IsInWater(void) const { return m_IsInWater; }
 
    virtual bool IsHeadInWater(void) const { return m_IsHeadInWater; }
 
    int GetAirLevel(void) const { return m_AirLevel; }
 
    long int GetTicksAlive(void) const { return m_TicksAlive; }
 
    int GetInvulnerableTicks(void) const { return m_InvulnerableTicks; }
 
    void SetInvulnerableTicks(int a_InvulnerableTicks) { m_InvulnerableTicks = a_InvulnerableTicks; }
 
    virtual bool IsOnGround(void) const { return m_bOnGround; }
 
    // tolua_end
 
    virtual void OnRightClicked(cPlayer & a_Player) {}
 
    virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = nullptr)
    {
        UNUSED(a_Drops);
        UNUSED(a_Killer);
    }
 
    void SetWorld(cWorld * a_World) { m_World = a_World; }
 
    void SetParentChunk(cChunk * a_Chunk);
 
    cChunk * GetParentChunk() { return m_ParentChunk; }
    const cChunk * GetParentChunk() const { return m_ParentChunk; }
 
    void SetIsTicking(bool a_IsTicking);
 
    void SetSize(float a_Width, float a_Height);
 
    void AddLeashedMob(cMonster * a_Monster);
 
    void RemoveLeashedMob(cMonster * a_Monster);
 
    bool HasAnyMobLeashed() const { return m_LeashedMobs.size() > 0; }
 
    void BroadcastDeathMessage(TakeDamageInfo & a_TDI);
 
protected:
 
    struct sPortalCooldownData
    {
        unsigned short m_TicksDelayed;
 
        bool m_ShouldPreventTeleportation;
    };
 
 
    Vector3d m_Speed;
 
    UInt32 m_UniqueID;
 
    float m_Health;
    float m_MaxHealth;
 
    cEntity * m_AttachedTo;
 
    cEntity * m_Attachee;
 
    bool m_bDirtyHead;
 
    bool m_bDirtyOrientation;
 
    bool m_bHasSentNoSpeed;
 
    bool m_bOnGround;
 
    float m_Gravity;
 
    float m_AirDrag;
 
    Vector3d m_LastSentPosition;
 
    Vector3d m_LastPosition;
 
    eEntityType m_EntityType;
 
    cWorld * m_World;
 
    sWorldChangeInfo m_WorldChangeInfo;
 
    bool m_IsFireproof;
 
    int m_TicksSinceLastBurnDamage;
 
    int m_TicksSinceLastLavaDamage;
 
    int m_TicksSinceLastFireDamage;
 
    int m_TicksLeftBurning;
 
    int m_TicksSinceLastVoidDamage;
 
    bool m_IsInFire;
 
    bool m_IsInLava;
 
    bool m_IsInWater;
 
    bool m_IsHeadInWater;
 
    int m_AirLevel;
    int m_AirTickTimer;
 
    sPortalCooldownData m_PortalCooldownData;
 
    long int m_TicksAlive;
 
    void DoMoveToWorld(const sWorldChangeInfo & a_WorldChangeInfo);
 
    static void ApplyFriction(Vector3d & a_Speed, double a_SlowdownMultiplier, float a_Dt);
 
    virtual void HandleAir(void);
 
    virtual void SetSwimState(cChunk & a_Chunk);
 
    virtual void ResetPosition(Vector3d a_NewPos);
 
    void BroadcastLeashedMobs();
 
    virtual void OnDetach();
 
private:
 
    bool m_IsTicking;
 
    cChunk * m_ParentChunk;
 
    double   m_HeadYaw;
 
    Vector3d m_Rot;
 
    Vector3d m_Position;
 
    Vector3d m_WaterSpeed;
 
    double m_Mass;
 
    float m_Width;
 
    float m_Height;
 
    int m_InvulnerableTicks;
 
    typedef std::list<cMonster *> cMonsterList;
 
    cMonsterList m_LeashedMobs;
 
    std::vector<cPlayer *> m_Spectators;
} ;  // tolua_export