Monster.h

Go to the documentation of this file.

 
#pragma once
 
#include "../Entities/Pawn.h"
#include "../UUID.h"
#include "MonsterTypes.h"
#include "PathFinder.h"
 
 
class cItem;
class cClientHandle;
 
 
 
// tolua_begin
class cMonster:
    public cPawn
{
 
    // tolua_end
 
    using Super = cPawn;
 
    // tolua_begin
 
public:
 
    enum eFamily
    {
        mfHostile  = 0,  // Spider, Zombies ...
        mfPassive  = 1,  // Cows, Pigs
        mfAmbient  = 2,  // Bats
        mfWater    = 3,  // Squid, Guardian
 
        mfNoSpawn
    } ;
 
    // 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, const AString & a_SoundAmbient, float a_Width, float a_Height);
 
    CLASS_PROTODEF(cMonster)
 
    virtual void OnRemoveFromWorld(cWorld & a_World) override;
 
    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 IsNetherNative(void);
 
    virtual bool IsUndead(void);
 
    virtual void EventLosePlayer(void);
    virtual void CheckEventLostPlayer(std::chrono::milliseconds a_Dt);
 
    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);
 
    double GetAttackRate() { return m_AttackRate; }
    void SetAttackRate(double a_AttackRate) { m_AttackRate = a_AttackRate; }
    void SetAttackRange(double 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);
 
    // tolua_end
 
    static cTickTime GetSpawnDelay(cMonster::eFamily a_MobFamily);
 
    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; }
 
    /* the breeding processing */
 
    virtual void GetFollowedItems(cItems & a_Items) { }
 
    virtual void GetBreedingItems(cItems & a_Items) { GetFollowedItems(a_Items); }
 
    virtual void InheritFromParents(cMonster * a_Parent1, cMonster * a_Parent2) { }
 
    cMonster * GetPartner(void) const { return m_LovePartner; }
 
    void EngageLoveMode(cMonster * a_Partner);
 
    void ResetLoveMode();
 
    bool IsInLove() const { return (m_LoveTimer > 0); }
 
    bool IsInLoveCooldown() const { return (m_LoveCooldown > 0); }
 
    void LoveTick(void);
 
    void RightClickFeed(cPlayer & a_Player);
 
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;
    AString m_SoundAmbient;
 
    double m_AttackRate;
    int m_AttackDamage;
    double m_AttackRange;
    int m_AttackCoolDownTicksLeft;
    int m_SightDistance;
    std::chrono::milliseconds m_LoseSightAbandonTargetTimer;
 
    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_AmbientSoundTimer;
 
    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);
 
    /* The breeding processing */
 
    cMonster * m_LovePartner;
 
    cUUID m_Feeder;
 
    int m_LoveTimer;
 
    int m_LoveCooldown;
 
    int m_MatingTimer;
 
private:
    cPawn * m_Target;
 
    void CalcLeashActions(std::chrono::milliseconds a_Dt);
 
} ;  // tolua_export