Entity.h

Go to the documentation of this file.

#pragma once

#include "../Item.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
{
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

    enum eEntityStatus
    {
        // TODO: Investigate 0, 1, and 5 as Wiki.vg is not certain

        // Entity becomes coloured red
        esGenericHurt            = 2,
        // Entity plays death animation (entity falls to ground)
        esGenericDead            = 3,
        // Iron Golem plays attack animation (arms lift and fall)
        esIronGolemAttacking     = 4,
        // Wolf taming particles spawn (smoke)
        esWolfTaming             = 6,
        // Wolf tamed particles spawn (hearts)
        esWolfTamed              = 7,
        // Wolf plays water removal animation (shaking and water particles)
        esWolfDryingWater        = 8,
        // Informs client that eating was accepted
        esPlayerEatingAccepted   = 9,
        // Sheep plays eating animation (head lowers to ground)
        esSheepEating            = 10,
        // Iron Golem holds gift to villager children
        esIronGolemGivingPlant   = 11,
        // Villager spawns heart particles
        esVillagerBreeding       = 12,
        // Villager spawns thunderclound particles
        esVillagerAngry          = 13,
        // Villager spawns green crosses
        esVillagerHappy          = 14,
        // Witch spawns magic particle (TODO: investigation into what this is)
        esWitchMagicking         = 15,

        // It seems 16 (zombie conversion) is now done with metadata

        // Informs client to explode a firework based on its metadata
        esFireworkExploding      = 17,
        // Passive mob is in "love mode"
        esMobInLove              = 18,
    } ;

    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, double a_Width, double a_Height);
    virtual ~cEntity();

    virtual bool Initialize(OwnedEntity a_Self, cWorld & a_EntityWorld);

    // tolua_begin

    eEntityType GetEntityType(void) const { return m_EntityType; }

    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
    double           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; }
    double           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); }

    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;

    virtual void Destroy(bool a_ShouldBroadcast = true);

    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

    void SetHeight(double a_Height);

    void SetWidth(double a_Width);

    const Vector3d & GetPosition(void) const { return m_Position; }

    const Vector3d & GetSpeed(void) const { return m_Speed; }

    Vector3d GetLastSentPos(void) const { return m_LastSentPosition; }

    void DestroyNoScheduling(bool a_ShouldBroadcast);

    virtual bool DoTakeDamage(TakeDamageInfo & a_TDI);

    // tolua_begin

    virtual int GetRawDamageAgainst(const cEntity & a_Receiver);

    virtual bool ArmorCoversAgainst(eDamageType a_DamageType);

    virtual int GetArmorCoverAgainst(const cEntity * a_Attacker, eDamageType a_DamageType, int a_RawDamage);

    virtual int 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(cEntity * a_Victim) {}

    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 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);

    void ScheduleMoveToWorld(cWorld * a_World, Vector3d a_NewPosition, bool a_ShouldSetPortalCooldown = false, bool a_ShouldSendRespawn = false);

    bool MoveToWorld(cWorld * a_World, bool a_ShouldSendRespawn, Vector3d a_NewPosition);

    bool MoveToWorld(cWorld * a_World, bool a_ShouldSendRespawn = true);

    bool MoveToWorld(const AString & a_WorldName, bool a_ShouldSendRespawn = true);

    // tolua_end

    virtual bool DoMoveToWorld(cWorld * a_World, bool a_ShouldSendRespawn, Vector3d a_NewPosition);

    virtual void BroadcastMovementUpdate(const cClientHandle * a_Exclude = nullptr);

    cEntity * GetAttached();

    virtual void AttachTo(cEntity * a_AttachTo);

    virtual void Detach(void);

    bool IsAttachedTo(const cEntity * a_Entity) const;

    void WrapHeadYaw();

    void WrapRotation();

    void WrapSpeed();

    // tolua_begin

    // COMMON metadata flags; descendants may override the defaults:
    virtual bool IsOnFire   (void) const {return (m_TicksLeftBurning > 0); }
    virtual bool IsCrouched (void) const {return false; }
    virtual bool IsRiding   (void) const {return false; }
    virtual bool IsSprinting(void) const {return false; }
    virtual bool IsRclking  (void) const {return false; }
    virtual bool IsInvisible(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 AddLeashedMob(cMonster * a_Monster);

    void RemoveLeashedMob(cMonster * a_Monster);

    bool HasAnyMobLeashed() const { return m_LeashedMobs.size() > 0; }

    virtual float GetExplosionExposureRate(Vector3d a_ExplosionPosition, float a_ExlosionPower);


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_LastPosition;

    eEntityType m_EntityType;

    cWorld * m_World;

    bool m_IsWorldChangeScheduled;
    bool m_WorldChangeSetPortalCooldown;
    bool m_WorldChangeSendRespawn;
    cWorld * m_NewWorld;
    Vector3d m_NewWorldPosition;

    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;


    virtual void DoSetSpeed(double a_SpeedX, double a_SpeedY, double a_SpeedZ);

    virtual void Destroyed(void) {}  // Called after the entity has been destroyed

    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);


private:

    bool m_IsTicking;

    cChunk * m_ParentChunk;

    double   m_HeadYaw;

    Vector3d m_Rot;

    Vector3d m_Position;

    Vector3d m_LastSentPosition;

    Vector3d m_WaterSpeed;

    double m_Mass;

    double m_Width;

    double m_Height;

    int m_InvulnerableTicks;

    typedef std::list<cMonster *> cMonsterList;

    cMonsterList m_LeashedMobs;
} ;  // tolua_export