Monster.h

Go to the documentation of this file.

#pragma once

#include "../Entities/Pawn.h"
#include "MonsterTypes.h"
#include "PathFinder.h"


class cItem;
class cClientHandle;



// tolua_begin
class cMonster :
    public cPawn
{
    typedef cPawn super;
public:

    enum eFamily
    {
        mfHostile  = 0,  // Spider, Zombies ...
        mfPassive  = 1,  // Cows, Pigs
        mfAmbient  = 2,  // Bats
        mfWater    = 3,  // Squid, Guardian

        mfNoSpawn,
        mfUnhandled,  // Nothing. Be sure this is the last and the others are in order
    } ;

    // tolua_end

    enum MState{ATTACKING, IDLE, CHASING, ESCAPING} m_EMState;
    enum MPersonality{PASSIVE, AGGRESSIVE, COWARDLY} m_EMPersonality;

    cMonster(const AString & a_ConfigName, eMonsterType a_MobType, const AString & a_SoundHurt, const AString & a_SoundDeath, double a_Width, double a_Height);

    virtual ~cMonster() override;

    virtual void Destroy(bool a_ShouldBroadcast = true) override;

    virtual void Destroyed() override;

    CLASS_PROTODEF(cMonster)

    virtual void SpawnOn(cClientHandle & a_ClientHandle) override;

    virtual void Tick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) override;

    virtual bool DoTakeDamage(TakeDamageInfo & a_TDI) override;

    virtual void KilledBy(TakeDamageInfo & a_TDI) override;

    virtual void OnRightClicked(cPlayer & a_Player) override;

    virtual void HandleFalling(void) override;

    virtual void MoveToPosition(const Vector3d & a_Position);  // tolua_export

    // tolua_begin
    eMonsterType GetMobType(void) const { return m_MobType; }
    eFamily GetMobFamily(void) const;
    // tolua_end

    virtual void CheckEventSeePlayer(cChunk & a_Chunk);
    virtual void EventSeePlayer(cPlayer * a_Player, cChunk & a_Chunk);

    // tolua_begin

    bool CanBeLeashed() const { return m_CanBeLeashed; }

    void SetCanBeLeashed(bool a_CanBeLeashed) { m_CanBeLeashed = a_CanBeLeashed; }

    bool IsLeashed() const { return (m_LeashedTo != nullptr); }

    void LeashTo(cEntity & a_Entity, bool a_ShouldBroadcast = true);

    void Unleash(bool a_ShouldDropLeashPickup);

    cEntity * GetLeashedTo() const { return m_LeashedTo; }

    // tolua_end

    void Unleash(bool a_ShouldDropLeashPickup, bool a_ShouldBroadcast);

    void SetLeashToPos(Vector3d * pos) { m_LeashToPos = std::unique_ptr<Vector3d>(pos); }

    Vector3d * GetLeashToPos() const { return m_LeashToPos.get(); }

    void GetMonsterConfig(const AString & a_Name);

    virtual bool IsUndead(void);

    virtual void EventLosePlayer(void);
    virtual void CheckEventLostPlayer(void);

    virtual void InStateIdle    (std::chrono::milliseconds a_Dt, cChunk & a_Chunk);
    virtual void InStateChasing (std::chrono::milliseconds a_Dt, cChunk & a_Chunk);
    virtual void InStateEscaping(std::chrono::milliseconds a_Dt, cChunk & a_Chunk);

    int GetAttackRate() { return static_cast<int>(m_AttackRate); }
    void SetAttackRate(float a_AttackRate) { m_AttackRate = a_AttackRate; }
    void SetAttackRange(int a_AttackRange) { m_AttackRange = a_AttackRange; }
    void SetAttackDamage(int a_AttackDamage) { m_AttackDamage = a_AttackDamage; }
    void SetSightDistance(int a_SightDistance) { m_SightDistance = a_SightDistance; }

    float GetDropChanceWeapon() { return m_DropChanceWeapon; }
    float GetDropChanceHelmet() { return m_DropChanceHelmet; }
    float GetDropChanceChestplate() { return m_DropChanceChestplate; }
    float GetDropChanceLeggings() { return m_DropChanceLeggings; }
    float GetDropChanceBoots() { return m_DropChanceBoots; }
    bool CanPickUpLoot() { return m_CanPickUpLoot; }
    void SetDropChanceWeapon(float a_DropChanceWeapon) { m_DropChanceWeapon = a_DropChanceWeapon; }
    void SetDropChanceHelmet(float a_DropChanceHelmet) { m_DropChanceHelmet = a_DropChanceHelmet; }
    void SetDropChanceChestplate(float a_DropChanceChestplate) { m_DropChanceChestplate = a_DropChanceChestplate; }
    void SetDropChanceLeggings(float a_DropChanceLeggings) { m_DropChanceLeggings = a_DropChanceLeggings; }
    void SetDropChanceBoots(float a_DropChanceBoots) { m_DropChanceBoots = a_DropChanceBoots; }
    void SetCanPickUpLoot(bool a_CanPickUpLoot) { m_CanPickUpLoot = a_CanPickUpLoot; }
    void ResetAttackCooldown();

    void SetBurnsInDaylight(bool a_BurnsInDaylight) { m_BurnsInDaylight = a_BurnsInDaylight; }  // tolua_export
    bool BurnsInDaylight() const { return m_BurnsInDaylight; }  // tolua_export

    double GetRelativeWalkSpeed(void) const { return m_RelativeWalkSpeed; }  // tolua_export
    void SetRelativeWalkSpeed(double a_WalkSpeed) { m_RelativeWalkSpeed = a_WalkSpeed; }  // tolua_export

    // Overridables to handle ageable mobs
    virtual bool IsTame    (void) const { return false; }
    virtual bool IsSitting (void) const { return false; }

    // tolua_begin
    bool IsBaby (void) const { return m_Age < 0; }
    int GetAge (void) const { return m_Age; }
    void SetAge(int a_Age)  { m_Age = a_Age; }
    // tolua_end


    // tolua_begin

    bool HasCustomName(void) const { return !m_CustomName.empty(); }

    const AString & GetCustomName(void) const { return m_CustomName; }

    void SetCustomName(const AString & a_CustomName);

    bool IsCustomNameAlwaysVisible(void) const { return m_CustomNameAlwaysVisible; }

    void SetCustomNameAlwaysVisible(bool a_CustomNameAlwaysVisible);

    static AString MobTypeToString(eMonsterType a_MobType);

    static AString MobTypeToVanillaName(eMonsterType a_MobType);

    static eMonsterType StringToMobType(const AString & a_MobTypeName);

    static eFamily FamilyFromType(eMonsterType a_MobType);

    static int GetSpawnDelay(cMonster::eFamily a_MobFamily);

    // tolua_end

    static AString MobTypeToVanillaNBT(eMonsterType a_MobType);

    void SetTarget (cPawn * a_NewTarget);

    void UnsafeUnsetTarget();

    cPawn * GetTarget();

    static std::unique_ptr<cMonster> NewMonsterFromType(eMonsterType a_MobType);

    bool WasLastTargetAPlayer() const { return m_WasLastTargetAPlayer; }

protected:

    cPathFinder m_PathFinder;

    bool m_PathfinderActivated;

    Vector3d m_NextWayPointPosition;

    Vector3d m_FinalDestination;

    int FindFirstNonAirBlockPosition(double a_PosX, double a_PosZ);

    bool ReachedFinalDestination(void) { return ((m_FinalDestination - GetPosition()).SqrLength() < WAYPOINT_RADIUS * WAYPOINT_RADIUS); }

    bool TargetIsInRange(void)
    {
        ASSERT(GetTarget() != nullptr);
        return ((GetTarget()->GetPosition() - GetPosition()).SqrLength() < (m_AttackRange * m_AttackRange));
    }

    inline bool DoesPosYRequireJump(double a_PosY)
    {
        return (a_PosY > GetPosY() + 0.8);  // Assume that differences up to 0.8 blocks can be walked instead of jumped
    }

    void MoveToWayPoint(cChunk & a_Chunk);

    void StopMovingToPosition();

    void SetPitchAndYawFromDestination(bool a_IsFollowingPath);

    int m_JumpCoolDown;

    std::chrono::milliseconds m_IdleInterval;
    std::chrono::milliseconds m_DestroyTimer;

    eMonsterType m_MobType;
    AString m_CustomName;
    bool m_CustomNameAlwaysVisible;

    AString m_SoundHurt;
    AString m_SoundDeath;

    float m_AttackRate;
    int m_AttackDamage;
    int m_AttackRange;
    int m_AttackCoolDownTicksLeft;
    int m_SightDistance;

    float m_DropChanceWeapon;
    float m_DropChanceHelmet;
    float m_DropChanceChestplate;
    float m_DropChanceLeggings;
    float m_DropChanceBoots;
    bool m_CanPickUpLoot;
    int m_TicksSinceLastDamaged;  // How many ticks ago we were last damaged by a player?

    void HandleDaylightBurning(cChunk & a_Chunk, bool WouldBurn);
    bool WouldBurnAt(Vector3d a_Location, cChunk & a_Chunk);
    bool m_BurnsInDaylight;
    double m_RelativeWalkSpeed;

    int m_Age;
    int m_AgingTimer;

    bool m_WasLastTargetAPlayer;

    cEntity * m_LeashedTo;

    std::unique_ptr<Vector3d> m_LeashToPos;

    bool m_IsLeashActionJustDone;

    bool m_CanBeLeashed;

    void AddRandomDropItem(cItems & a_Drops, unsigned int a_Min, unsigned int a_Max, short a_Item, short a_ItemHealth = 0);

    void AddRandomUncommonDropItem(cItems & a_Drops, float a_Chance, short a_Item, short a_ItemHealth = 0);

    void AddRandomRareDropItem(cItems & a_Drops, cItems & a_Items, unsigned int a_LootingLevel);

    void AddRandomArmorDropItem(cItems & a_Drops, unsigned int a_LootingLevel);

    void AddRandomWeaponDropItem(cItems & a_Drops, unsigned int a_LootingLevel);

private:
    cPawn * m_Target;

    void CalcLeashActions(std::chrono::milliseconds a_Dt);

} ;  // tolua_export