diff options
Diffstat (limited to 'src')
113 files changed, 2452 insertions, 1370 deletions
diff --git a/src/Blocks/BlockFence.h b/src/Blocks/BlockFence.h index 63390cd37..9c25013f0 100644 --- a/src/Blocks/BlockFence.h +++ b/src/Blocks/BlockFence.h @@ -6,7 +6,6 @@ #include "../EffectID.h" #include "Entities/LeashKnot.h" #include "BoundingBox.h" -#include "../Mobs/PassiveMonster.h" diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 08bb2c270..661db57ae 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -8,7 +8,7 @@ include_directories (SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/../lib/libevent/include set(FOLDERS OSSupport HTTP Items Blocks Protocol Generating mbedTLS++ Bindings - WorldStorage Mobs Entities Simulator Simulator/IncrementalRedstoneSimulator + WorldStorage Mobs Mobs/Behaviors Entities Simulator Simulator/IncrementalRedstoneSimulator BlockEntities UI Noise ) @@ -348,7 +348,7 @@ if (NOT MSVC) target_link_libraries(${CMAKE_PROJECT_NAME} OSSupport HTTPServer Bindings Items Blocks Noise Protocol Generating WorldStorage - Mobs Entities Simulator IncrementalRedstoneSimulator + Mobs Behaviors Entities Simulator IncrementalRedstoneSimulator BlockEntities UI mbedTLS++ ) endif () diff --git a/src/ClientHandle.cpp b/src/ClientHandle.cpp index 6923c9855..93ade0ac4 100644 --- a/src/ClientHandle.cpp +++ b/src/ClientHandle.cpp @@ -189,7 +189,7 @@ void cClientHandle::Destroy(void) auto world = player->GetWorld(); if (world != nullptr) { - player->StopEveryoneFromTargetingMe(); + // player->StopEveryoneFromTargetingMe(); // mobTodo player->SetIsTicking(false); if (WasAddedToWorld) diff --git a/src/Entities/Entity.cpp b/src/Entities/Entity.cpp index 836e69961..38443793e 100644 --- a/src/Entities/Entity.cpp +++ b/src/Entities/Entity.cpp @@ -239,7 +239,9 @@ void cEntity::Destroy(bool a_ShouldBroadcast) } cChunk * ParentChunk = GetParentChunk(); - m_World->QueueTask([this, ParentChunk](cWorld & a_World) + // Destroy the entity after two seconds, to give time for all raw pointers such as m_Target + // to de-target this entity. This is a temporary solution. + m_World->ScheduleTask(40, [this, ParentChunk](cWorld & a_World) { LOGD("Destroying entity #%i (%s) from chunk (%d, %d)", this->GetUniqueID(), this->GetClass(), @@ -1591,12 +1593,12 @@ bool cEntity::DoMoveToWorld(cWorld * a_World, bool a_ShouldSendRespawn, Vector3d // Stop all mobs from targeting this entity // Stop this entity from targeting other mobs - if (this->IsMob()) + /* if (this->IsMob()) { cMonster * Monster = static_cast<cMonster*>(this); Monster->SetTarget(nullptr); - Monster->StopEveryoneFromTargetingMe(); - } + Monster->StopEveryoneFromTargetingMe(); mobTodo MovingWorld event for all behaviors? + }*/ // Queue add to new world and removal from the old one cWorld * OldWorld = GetWorld(); diff --git a/src/Entities/Pawn.cpp b/src/Entities/Pawn.cpp index 233cdfa85..0fa11997b 100644 --- a/src/Entities/Pawn.cpp +++ b/src/Entities/Pawn.cpp @@ -29,7 +29,7 @@ cPawn::cPawn(eEntityType a_EntityType, double a_Width, double a_Height) : cPawn::~cPawn() { - ASSERT(m_TargetingMe.size() == 0); + } @@ -38,7 +38,6 @@ cPawn::~cPawn() void cPawn::Destroyed() { - StopEveryoneFromTargetingMe(); super::Destroyed(); } @@ -260,38 +259,6 @@ void cPawn::ClearEntityEffects() -void cPawn::NoLongerTargetingMe(cMonster * a_Monster) -{ - ASSERT(IsTicking()); // Our destroy override is supposed to clear all targets before we're destroyed. - for (auto i = m_TargetingMe.begin(); i != m_TargetingMe.end(); ++i) - { - cMonster * Monster = *i; - if (Monster == a_Monster) - { - ASSERT(Monster->GetTarget() != this); // The monster is notifying us it is no longer targeting us, assert if that's a lie - m_TargetingMe.erase(i); - return; - } - } - ASSERT(false); // If this happens, something is wrong. Perhaps the monster never called TargetingMe() or called NoLongerTargetingMe() twice. -} - - - - - -void cPawn::TargetingMe(cMonster * a_Monster) -{ - ASSERT(IsTicking()); - ASSERT(m_TargetingMe.size() < 10000); - ASSERT(a_Monster->GetTarget() == this); - m_TargetingMe.push_back(a_Monster); -} - - - - - void cPawn::HandleFalling(void) { /* Not pretty looking, and is more suited to wherever server-sided collision detection is implemented. @@ -462,23 +429,6 @@ void cPawn::HandleFalling(void) -void cPawn::StopEveryoneFromTargetingMe() -{ - std::vector<cMonster*>::iterator i = m_TargetingMe.begin(); - while (i != m_TargetingMe.end()) - { - cMonster * Monster = *i; - ASSERT(Monster->GetTarget() == this); - Monster->UnsafeUnsetTarget(); - i = m_TargetingMe.erase(i); - } - ASSERT(m_TargetingMe.size() == 0); -} - - - - - std::map<cEntityEffect::eType, cEntityEffect *> cPawn::GetEntityEffects() { std::map<cEntityEffect::eType, cEntityEffect *> Effects; diff --git a/src/Entities/Pawn.h b/src/Entities/Pawn.h index 480b523ea..935122012 100644 --- a/src/Entities/Pawn.h +++ b/src/Entities/Pawn.h @@ -33,11 +33,6 @@ public: virtual void HandleAir(void) override; virtual void HandleFalling(void); - /** Tells all pawns which are targeting us to stop targeting us. */ - void StopEveryoneFromTargetingMe(); - - - // tolua_begin /** Applies an entity effect. @@ -58,12 +53,6 @@ public: // tolua_end - /** Remove the monster from the list of monsters targeting this pawn. */ - void NoLongerTargetingMe(cMonster * a_Monster); - - /** Add the monster to the list of monsters targeting this pawn. (Does not check if already in list!) */ - void TargetingMe(cMonster * a_Monster); - /** Returns all entity effects */ std::map<cEntityEffect::eType, cEntityEffect *> GetEntityEffects(); @@ -76,11 +65,6 @@ protected: double m_LastGroundHeight; bool m_bTouchGround; - -private: - - /** A list of all monsters that are targeting this pawn. */ - std::vector<cMonster*> m_TargetingMe; } ; // tolua_export diff --git a/src/Entities/Player.cpp b/src/Entities/Player.cpp index fb2274cad..4189841b8 100644 --- a/src/Entities/Player.cpp +++ b/src/Entities/Player.cpp @@ -2018,7 +2018,7 @@ bool cPlayer::DoMoveToWorld(cWorld * a_World, bool a_ShouldSendRespawn, Vector3d FreezeInternal(a_NewPosition, false); // Stop all mobs from targeting this player - StopEveryoneFromTargetingMe(); + // StopEveryoneFromTargetingMe(); // mobTodo cClientHandle * ch = this->GetClientHandle(); if (ch != nullptr) diff --git a/src/Mobs/AggressiveMonster.cpp b/src/Mobs/AggressiveMonster.cpp deleted file mode 100644 index fec14e6e9..000000000 --- a/src/Mobs/AggressiveMonster.cpp +++ /dev/null @@ -1,109 +0,0 @@ - -#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules - -#include "AggressiveMonster.h" - -#include "../World.h" -#include "../Entities/Player.h" -#include "../LineBlockTracer.h" - - - - - -cAggressiveMonster::cAggressiveMonster(const AString & a_ConfigName, eMonsterType a_MobType, const AString & a_SoundHurt, const AString & a_SoundDeath, double a_Width, double a_Height) : - super(a_ConfigName, a_MobType, a_SoundHurt, a_SoundDeath, a_Width, a_Height) -{ - m_EMPersonality = AGGRESSIVE; -} - - - - - -// What to do if in Chasing State -void cAggressiveMonster::InStateChasing(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) -{ - super::InStateChasing(a_Dt, a_Chunk); - - if (GetTarget() != nullptr) - { - MoveToPosition(GetTarget()->GetPosition()); - } -} - - - - - - -void cAggressiveMonster::EventSeePlayer(cPlayer * a_Player, cChunk & a_Chunk) -{ - if (!a_Player->CanMobsTarget()) - { - return; - } - - super::EventSeePlayer(a_Player, a_Chunk); - m_EMState = CHASING; -} - - - - - -void cAggressiveMonster::Tick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) -{ - super::Tick(a_Dt, a_Chunk); - if (!IsTicking()) - { - // The base class tick destroyed us - return; - } - - if (m_EMState == CHASING) - { - CheckEventLostPlayer(); - } - else - { - CheckEventSeePlayer(a_Chunk); - } - - auto target = GetTarget(); - if (target == nullptr) - { - return; - } - - // TODO: Currently all mobs see through lava, but only Nether-native mobs should be able to. - Vector3d MyHeadPosition = GetPosition() + Vector3d(0, GetHeight(), 0); - Vector3d TargetPosition = target->GetPosition() + Vector3d(0, target->GetHeight(), 0); - if ( - TargetIsInRange() && - cLineBlockTracer::LineOfSightTrace(*GetWorld(), MyHeadPosition, TargetPosition, cLineBlockTracer::losAirWaterLava) && - (GetHealth() > 0.0) - ) - { - // Attack if reached destination, target isn't null, and have a clear line of sight to target (so won't attack through walls) - Attack(a_Dt); - } -} - - - - - -bool cAggressiveMonster::Attack(std::chrono::milliseconds a_Dt) -{ - if ((GetTarget() == nullptr) || (m_AttackCoolDownTicksLeft != 0)) - { - return false; - } - - // Setting this higher gives us more wiggle room for attackrate - ResetAttackCooldown(); - GetTarget()->TakeDamage(dtMobAttack, this, m_AttackDamage, 0); - - return true; -} diff --git a/src/Mobs/AggressiveMonster.h b/src/Mobs/AggressiveMonster.h deleted file mode 100644 index 9ab8df06f..000000000 --- a/src/Mobs/AggressiveMonster.h +++ /dev/null @@ -1,33 +0,0 @@ - -#pragma once - -#include "Monster.h" - - - - - -class cAggressiveMonster : - public cMonster -{ - typedef cMonster super; - -public: - - cAggressiveMonster(const AString & a_ConfigName, eMonsterType a_MobType, const AString & a_SoundHurt, const AString & a_SoundDeath, double a_Width, double a_Height); - - virtual void Tick (std::chrono::milliseconds a_Dt, cChunk & a_Chunk) override; - virtual void InStateChasing(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) override; - - - virtual void EventSeePlayer(cPlayer * a_Player, cChunk & a_Chunk) override; - - /** Try to perform attack - returns true if attack was deemed successful (hit player, fired projectile, creeper exploded, etc.) even if it didn't actually do damage - return false if e.g. the mob is still in cooldown from a previous attack */ - virtual bool Attack(std::chrono::milliseconds a_Dt); -} ; - - - - diff --git a/src/Mobs/Bat.cpp b/src/Mobs/Bat.cpp index e419ceb2d..906b99320 100644 --- a/src/Mobs/Bat.cpp +++ b/src/Mobs/Bat.cpp @@ -4,12 +4,13 @@ #include "Bat.h" #include "../Chunk.h" - cBat::cBat(void) : - super("Bat", mtBat, "entity.bat.hurt", "entity.bat.death", 0.5, 0.9) + super("Bat", mtBat, "entity.bat.hurt", "entity.bat.death", 0.5, 0.9) { - SetGravity(-2.0f); - SetAirDrag(0.05f); + SetGravity(-2.0f); + SetAirDrag(0.05f); + + } diff --git a/src/Mobs/Bat.h b/src/Mobs/Bat.h index 2da2dc3f2..0c3ed647f 100644 --- a/src/Mobs/Bat.h +++ b/src/Mobs/Bat.h @@ -1,16 +1,16 @@ #pragma once -#include "PassiveMonster.h" +#include "Monster.h" class cBat : - public cPassiveMonster + public cMonster { - typedef cPassiveMonster super; + typedef cMonster super; public: cBat(void); diff --git a/src/Mobs/Behaviors/Behavior.cpp b/src/Mobs/Behaviors/Behavior.cpp new file mode 100644 index 000000000..86922427f --- /dev/null +++ b/src/Mobs/Behaviors/Behavior.cpp @@ -0,0 +1,102 @@ +#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules + +#include "Behavior.h" +#include "../Monster.h" + + + +bool cBehavior::IsControlDesired(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) +{ + UNUSED(a_Dt); + UNUSED(a_Chunk); + LOGD("ERROR: Probably forgot to implement cBehavior::IsControlDesired but implement cBehavior::Tick"); + return false; +} + + + + + +bool cBehavior::ControlStarting(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) +{ + UNUSED(a_Dt); + UNUSED(a_Chunk); + return true; +} + + + + + +bool cBehavior::ControlEnding(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) +{ + UNUSED(a_Dt); + UNUSED(a_Chunk); + return true; +} + + + + + +void cBehavior::Tick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) +{ + UNUSED(a_Dt); + UNUSED(a_Chunk); + LOGD("ERROR: Called a TICK on a behavior that doesn't have one."); + ASSERT(1 == 0); +} + + + + + +void cBehavior::PostTick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) +{ + UNUSED(a_Dt); + UNUSED(a_Chunk); + LOGD("ERROR: Called a PostTick on a behavior that doesn't have one."); + ASSERT(1 == 0); +} + + + + + +void cBehavior::PreTick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) +{ + UNUSED(a_Dt); + UNUSED(a_Chunk); + LOGD("ERROR: Called a PreTick on a behavior that doesn't have one."); + ASSERT(1 == 0); +} + + + + + +void cBehavior::OnRightClicked(cPlayer & a_Player) +{ + LOGD("ERROR: Called onRightClicked on a behavior that doesn't have one."); + ASSERT(1 == 0); +} + + + + + +void cBehavior::Destroyed() +{ + LOGD("ERROR: Called Destroyed on a behavior that doesn't have one."); + ASSERT(1 == 0); +} + + + + +void cBehavior::DoTakeDamage(TakeDamageInfo & a_TDI) +{ + UNUSED(a_TDI); + LOGD("ERROR: Called DoTakeDamage on a behavior that doesn't have one."); + ASSERT(1 == 0); +} diff --git a/src/Mobs/Behaviors/Behavior.h b/src/Mobs/Behaviors/Behavior.h new file mode 100644 index 000000000..27833cc9b --- /dev/null +++ b/src/Mobs/Behaviors/Behavior.h @@ -0,0 +1,30 @@ +#pragma once + +struct TakeDamageInfo; +class cChunk; +class cPlayer; +class cMonster; +class cPawn; +class cWorld; +class cItems; +class cEntity; +struct TakeDamageInfo; +#include <chrono> + +class cBehavior +{ +public: + // Tick-related + virtual bool IsControlDesired(std::chrono::milliseconds a_Dt, cChunk & a_Chunk); + virtual bool ControlStarting(std::chrono::milliseconds a_Dt, cChunk & a_Chunk); + virtual bool ControlEnding(std::chrono::milliseconds a_Dt, cChunk & a_Chunk); + virtual void Tick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk); + virtual void PostTick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk); + virtual void PreTick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk); + + // Other + virtual void OnRightClicked(cPlayer & a_Player); + virtual void Destroyed(); + virtual void DoTakeDamage(TakeDamageInfo & a_TDI); + virtual ~cBehavior() {} +}; diff --git a/src/Mobs/Behaviors/BehaviorAggressive.cpp b/src/Mobs/Behaviors/BehaviorAggressive.cpp new file mode 100644 index 000000000..2e3333e89 --- /dev/null +++ b/src/Mobs/Behaviors/BehaviorAggressive.cpp @@ -0,0 +1,42 @@ +#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules + +#include "BehaviorAggressive.h" +#include "BehaviorAttacker.h" +#include "../Monster.h" +#include "../../Chunk.h" +#include "../../Entities/Player.h" + +void cBehaviorAggressive::AttachToMonster(cMonster & a_Parent) +{ + m_Parent = &a_Parent; + m_Parent->AttachPreTickBehavior(this); +} + + +void cBehaviorAggressive::PreTick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) +{ + UNUSED(a_Dt); + UNUSED(a_Chunk); + + // Target something new if we have no target + cBehaviorAttacker * BehaviorAttacker = m_Parent->GetBehaviorAttacker(); + if ((BehaviorAttacker != nullptr) && (BehaviorAttacker->GetTarget() == nullptr)) + { + // mobTodo enhance this + BehaviorAttacker->SetTarget(FindNewTarget()); + } +} + + + + + +cPawn * cBehaviorAggressive::FindNewTarget() +{ + cPlayer * Closest = m_Parent->GetNearestPlayer(); + if ((Closest != nullptr) && (!Closest->CanMobsTarget())) + { + return nullptr; + } + return Closest; // May be null +} diff --git a/src/Mobs/Behaviors/BehaviorAggressive.h b/src/Mobs/Behaviors/BehaviorAggressive.h new file mode 100644 index 000000000..840d925d5 --- /dev/null +++ b/src/Mobs/Behaviors/BehaviorAggressive.h @@ -0,0 +1,31 @@ +#pragma once + + +class cBehaviorAggressive; + +#include "Behavior.h" + +/** The mob is agressive toward specific mobtypes, or toward the player. +This Behavior has a dependency on BehaviorAttacker. */ +class cBehaviorAggressive : public cBehavior +{ + +public: + void AttachToMonster(cMonster & a_Parent); + + // cBehaviorAggressive(cMonster * a_Parent, bool a_HatesPlayer); + // TODO agression toward specific players, and specific mobtypes, etc + // Agression under specific conditions (nighttime, etc) + + // Functions our host Monster should invoke: + void PreTick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) override; + +private: + cPawn * FindNewTarget(); + + // Our parent + cMonster * m_Parent; + + // The mob we want to attack + cPawn * m_Target; +}; diff --git a/src/Mobs/Behaviors/BehaviorAttacker.cpp b/src/Mobs/Behaviors/BehaviorAttacker.cpp new file mode 100644 index 000000000..67a27a277 --- /dev/null +++ b/src/Mobs/Behaviors/BehaviorAttacker.cpp @@ -0,0 +1,289 @@ + +#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules + +#include "BehaviorAttacker.h" +#include "BehaviorStriker.h" +#include "../Monster.h" +#include "../../Entities/Pawn.h" +#include "../../Entities/Player.h" +#include "../../Tracer.h" + + +cBehaviorAttacker::cBehaviorAttacker() : + m_AttackRate(3) + , m_AttackDamage(1) + , m_AttackRange(1) + , m_AttackCoolDownTicksLeft(0) + , m_TicksSinceLastDamaged(100) + , m_IsStriking(false) + , m_Target(nullptr) +{ + +} + + + + + +void cBehaviorAttacker::AttachToMonster(cMonster & a_Parent) +{ + m_Parent = &a_Parent; + m_Parent->AttachTickBehavior(this); + m_Parent->AttachDestroyBehavior(this); + m_Parent->AttachPostTickBehavior(this); + m_Parent->AttachDoTakeDamageBehavior(this); + m_Parent->m_BehaviorAttackerPointer = this; +} + + + + + +bool cBehaviorAttacker::IsControlDesired(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) +{ + UNUSED(a_Dt); + UNUSED(a_Chunk); + // If we have a target, we have something to do! Return true and control the mob Ticks. + // Otherwise return false. + return (m_IsStriking || (GetTarget() != nullptr)); +} + + + + + +void cBehaviorAttacker::Tick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) +{ + UNUSED(a_Dt); + UNUSED(a_Chunk); + + if (m_IsStriking) + { + if (StrikeTarget(++m_StrikeTickCnt)) + { + m_Parent->UnpinBehavior(this); + m_IsStriking = false; + ResetStrikeCooldown(); + } + #ifdef _DEBUG + if (m_StrikeTickCnt > 100) + { + LOGD("Sanity check failed. An attack took more than 5 seconds. Hmm"); + ASSERT(1 == 0); + } + #endif + return; + } + + if ((GetTarget() != nullptr)) + { + ASSERT(GetTarget()->IsTicking()); + + if (GetTarget()->IsPlayer()) + { + if (!static_cast<cPlayer *>(GetTarget())->CanMobsTarget()) + { + SetTarget(nullptr); + } + } + } + + + ASSERT((GetTarget() == nullptr) || (GetTarget()->IsPawn() && (GetTarget()->GetWorld() == m_Parent->GetWorld()))); + if (GetTarget() != nullptr) + { + m_Parent->SetLookingAt(m_Target); + if (TargetOutOfSight()) + { + SetTarget(nullptr); + } + else + { + if (TargetIsInStrikeRadiusAndLineOfSight()) + { + StrikeTargetIfReady(); + } + else + { + m_Parent->MoveToPosition(m_Target->GetPosition()); + // todo BehaviorApproacher for creeper sneaking, etc + } + } + } +} + + + + + +void cBehaviorAttacker::PostTick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) +{ + if (m_TicksSinceLastDamaged < 100) + { + ++m_TicksSinceLastDamaged; + } + + if (m_AttackCoolDownTicksLeft > 0) + { + m_AttackCoolDownTicksLeft -= 1; + } +} + + + + + +void cBehaviorAttacker::DoTakeDamage(TakeDamageInfo & a_TDI) +{ + if ((a_TDI.Attacker != nullptr) && a_TDI.Attacker->IsPawn()) + { + if ( + (!a_TDI.Attacker->IsPlayer()) || + (static_cast<cPlayer *>(a_TDI.Attacker)->CanMobsTarget()) + ) + { + SetTarget(static_cast<cPawn*>(a_TDI.Attacker)); + } + m_TicksSinceLastDamaged = 0; + } +} + + + + + +void cBehaviorAttacker::Destroyed() +{ + SetTarget(nullptr); +} + + + + + +void cBehaviorAttacker::SetAttackRate(float a_AttackRate) +{ + m_AttackRate = a_AttackRate; +} + + + + + +void cBehaviorAttacker::SetAttackRange(int a_AttackRange) +{ + m_AttackRange = a_AttackRange; +} + + + + + +void cBehaviorAttacker::SetAttackDamage(int a_AttackDamage) +{ + m_AttackDamage = a_AttackDamage; +} + + + + +cPawn * cBehaviorAttacker::GetTarget() +{ + return m_Target; +} + + + + + +void cBehaviorAttacker::SetTarget(cPawn * a_Target) +{ + m_Target = a_Target; +} + + + + + +void cBehaviorAttacker::StrikeTarget() +{ + if (m_IsStriking || (m_Target == nullptr)) + { + return; + } + m_IsStriking = true; + m_StrikeTickCnt = 0; + m_Parent->PinBehavior(this); +} + + + + + +bool cBehaviorAttacker::TargetIsInStrikeRadius(void) +{ + ASSERT(GetTarget() != nullptr); + return ((GetTarget()->GetPosition() - m_Parent->GetPosition()).SqrLength() < (m_AttackRange * m_AttackRange)); +} + + + + + +bool cBehaviorAttacker::TargetIsInStrikeRadiusAndLineOfSight() +{ + ASSERT(m_Target != nullptr); + ASSERT(m_Parent != nullptr); + + + cTracer LineOfSight(m_Parent->GetWorld()); + Vector3d MyHeadPosition = m_Parent->GetPosition() + Vector3d(0, m_Parent->GetHeight(), 0); + Vector3d AttackDirection(GetTarget()->GetPosition() + Vector3d(0, GetTarget()->GetHeight(), 0) - MyHeadPosition); + + if (TargetIsInStrikeRadius()/* && + !LineOfSight.Trace(MyHeadPosition, AttackDirection, static_cast<int>(AttackDirection.Length()))*/ && + (m_Parent->GetHealth() > 0.0) + ) + { + return true; + } + else + { + return false; + } +} + + + + + +bool cBehaviorAttacker::TargetOutOfSight() +{ + ASSERT(m_Target != nullptr); + if ((GetTarget()->GetPosition() - m_Parent->GetPosition()).Length() > m_Parent->GetSightDistance()) + { + return true; + } + return false; +} + + + + + +void cBehaviorAttacker::ResetStrikeCooldown() +{ + m_AttackCoolDownTicksLeft = static_cast<int>(3 * 20 * m_AttackRate); // A second has 20 ticks, an attack rate of 1 means 1 hit every 3 seconds +} + + + + + +void cBehaviorAttacker::StrikeTargetIfReady() +{ + if (m_AttackCoolDownTicksLeft == 0) + { + StrikeTarget(); + } +} diff --git a/src/Mobs/Behaviors/BehaviorAttacker.h b/src/Mobs/Behaviors/BehaviorAttacker.h new file mode 100644 index 000000000..78ed70994 --- /dev/null +++ b/src/Mobs/Behaviors/BehaviorAttacker.h @@ -0,0 +1,81 @@ +#pragma once + +class cBehaviorAttacker; + +#include "Behavior.h" + + +/** Grants attack capability to the mob. Note that this is not the same as agression! +The mob may possess this trait and not attack anyone or only attack when provoked. +Unlike most traits, this one has several forms, and therefore it is an abstract type +You should use one of its derived classes, and you cannot use it directly. */ +class cBehaviorAttacker : public cBehavior +{ + +public: + cBehaviorAttacker(); + void AttachToMonster(cMonster & a_Parent); + + + // Our host monster will call these once it loads its config file + void SetAttackRate(float a_AttackRate); + void SetAttackRange(int a_AttackRange); + void SetAttackDamage(int a_AttackDamage); + + // Behavior functions + bool IsControlDesired(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) override; + virtual void Tick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) override; + void Destroyed() override; + void PostTick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) override; + void DoTakeDamage(TakeDamageInfo & a_TDI) override; + + /** Returns the target pointer, or a nullptr if we're not targeting anyone. */ + cPawn * GetTarget(); + + /** Sets a new target. Forgets the older target if present. Set this to nullptr to unset target. */ + void SetTarget(cPawn * a_Target); + + /** Makes the mob strike a target the next tick. Ignores the strike cooldown. + * Ignored if already striking or if no target is set. */ + void StrikeTarget(); + + /** Makes the mob strike a target the next tick only if the strike cooldown permits it. + * Ignored if already striking or if no target is set. */ + void StrikeTargetIfReady(); +protected: + + /** Called when the actual attack should be made. Will be called again and again every tick until + it returns false. a_StrikeTickCnt tracks how many times it was called. It is 1 the first call. + It increments by 1 each call. This mechanism allows multi-tick attacks, like blazes shooting multiple + fireballs, but most attacks are single tick and return true the first call. */ + virtual bool StrikeTarget(int a_StrikeTickCnt) = 0; + + // Target related methods + bool TargetIsInStrikeRadius(); + bool TargetIsInStrikeRadiusAndLineOfSight(); + bool TargetOutOfSight(); + void StrikeTargetIfReady(std::chrono::milliseconds a_Dt, cChunk & a_Chunk); + + // Cooldown stuff + void ResetStrikeCooldown(); + + // Our attacking parameters (Set by the setter methods, loaded from a config file in cMonster) + float m_AttackRate; + int m_AttackDamage; + int m_AttackRange; + int m_AttackCoolDownTicksLeft; + + int m_TicksSinceLastDamaged; // How many ticks ago were we last damaged by a player? + + bool m_IsStriking; + + /** Our parent */ + cMonster * m_Parent; + +private: + + // The mob we want to attack + cPawn * m_Target; + int m_StrikeTickCnt; + +}; diff --git a/src/Mobs/Behaviors/BehaviorAttackerMelee.cpp b/src/Mobs/Behaviors/BehaviorAttackerMelee.cpp new file mode 100644 index 000000000..337d8d216 --- /dev/null +++ b/src/Mobs/Behaviors/BehaviorAttackerMelee.cpp @@ -0,0 +1,13 @@ +#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules + +#include "BehaviorAttackerMelee.h" +#include "../Monster.h" +#include "../../Entities/Pawn.h" +#include "../../BlockID.h" + +bool cBehaviorAttackerMelee::StrikeTarget(int a_StrikeTickCnt) +{ + UNUSED(a_StrikeTickCnt); + GetTarget()->TakeDamage(dtMobAttack, m_Parent, m_AttackDamage, 0); + return true; // Finish the strike. It only takes 1 tick. +} diff --git a/src/Mobs/Behaviors/BehaviorAttackerMelee.h b/src/Mobs/Behaviors/BehaviorAttackerMelee.h new file mode 100644 index 000000000..b079c94fc --- /dev/null +++ b/src/Mobs/Behaviors/BehaviorAttackerMelee.h @@ -0,0 +1,11 @@ +#pragma once + +#include "BehaviorAttacker.h" + +/** Makes the mob fight back any other mob that damages it. Mob should have BehaviorAttacker to work. +This behavior does not make sense in combination with BehaviorCoward. */ +class cBehaviorAttackerMelee : public cBehaviorAttacker +{ +public: + bool StrikeTarget(int a_StrikeTickCnt) override; +}; diff --git a/src/Mobs/Behaviors/BehaviorBrave.cpp b/src/Mobs/Behaviors/BehaviorBrave.cpp new file mode 100644 index 000000000..6aba310a1 --- /dev/null +++ b/src/Mobs/Behaviors/BehaviorBrave.cpp @@ -0,0 +1,27 @@ +#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules + +#include "BehaviorBrave.h" +#include "BehaviorAttacker.h" +#include "../Monster.h" +#include "../../Entities/Entity.h" + +void cBehaviorBrave::AttachToMonster(cMonster & a_Parent) +{ + m_Parent = &a_Parent; + m_Parent->AttachDoTakeDamageBehavior(this); +} + + + + +void cBehaviorBrave::DoTakeDamage(TakeDamageInfo & a_TDI) +{ + cBehaviorAttacker * AttackBehavior = m_Parent->GetBehaviorAttacker(); + if ((AttackBehavior != nullptr) && (a_TDI.Attacker != m_Parent) && + (a_TDI.Attacker != nullptr) && (a_TDI.Attacker->IsPawn()) + ) + { + AttackBehavior->SetTarget(static_cast<cPawn*>(a_TDI.Attacker)); + } +} + diff --git a/src/Mobs/Behaviors/BehaviorBrave.h b/src/Mobs/Behaviors/BehaviorBrave.h new file mode 100644 index 000000000..0a59f90b8 --- /dev/null +++ b/src/Mobs/Behaviors/BehaviorBrave.h @@ -0,0 +1,15 @@ +#pragma once + +#include "Behavior.h" + +/** Makes the mob fight back any other mob that damages it. Mob should have BehaviorAttacker to work. +This behavior does not make sense in combination with BehaviorCoward. */ +class cBehaviorBrave : cBehavior +{ +public: + void AttachToMonster(cMonster & a_Parent); + void DoTakeDamage(TakeDamageInfo & a_TDI) override; + +private: + cMonster * m_Parent; // Our Parent +}; diff --git a/src/Mobs/Behaviors/BehaviorBreeder.cpp b/src/Mobs/Behaviors/BehaviorBreeder.cpp new file mode 100644 index 000000000..7ede92c52 --- /dev/null +++ b/src/Mobs/Behaviors/BehaviorBreeder.cpp @@ -0,0 +1,252 @@ +#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules + +#include "BehaviorBreeder.h" +#include "../../World.h" +#include "../Monster.h" +#include "../../Entities/Player.h" +#include "../../Item.h" +#include "../../BoundingBox.h" + +cBehaviorBreeder::cBehaviorBreeder() : + m_LovePartner(nullptr), + m_LoveTimer(0), + m_LoveCooldown(0), + m_MatingTimer(0) +{ +} + + + + + +void cBehaviorBreeder::AttachToMonster(cMonster & a_Parent) +{ + m_Parent = &a_Parent; + m_Parent->AttachTickBehavior(this); + m_Parent->AttachPostTickBehavior(this); + m_Parent->AttachRightClickBehavior(this); + m_Parent->AttachDestroyBehavior(this); + m_Parent->m_BehaviorBreederPointer = this; +} + + + + + +void cBehaviorBreeder::Tick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) +{ + LOGD("mobDebug - Behavior Breeder: Tick"); + UNUSED(a_Dt); + UNUSED(a_Chunk); + cWorld * World = m_Parent->GetWorld(); + // if we have a partner, mate + if (m_LovePartner != nullptr) + { + if (m_MatingTimer > 0) + { + // If we should still mate, keep bumping into them until baby is made + Vector3d Pos = m_LovePartner->GetPosition(); + m_Parent->MoveToPosition(Pos); + } + else + { + // Mating finished. Spawn baby + Vector3f Pos = (m_Parent->GetPosition() + m_LovePartner->GetPosition()) * 0.5; + UInt32 BabyID = World->SpawnMob(Pos.x, Pos.y, Pos.z, m_Parent->GetMobType(), true); + + class cBabyInheritCallback : + public cEntityCallback + { + public: + cMonster * Baby; + cBabyInheritCallback() : Baby(nullptr) { } + virtual bool Item(cEntity * a_Entity) override + { + Baby = static_cast<cMonster *>(a_Entity); + return true; + } + } Callback; + + m_Parent->GetWorld()->DoWithEntityByID(BabyID, Callback); + if (Callback.Baby != nullptr) + { + Callback.Baby->InheritFromParents(m_Parent, m_LovePartner); + } + + cFastRandom Random; + World->SpawnExperienceOrb(Pos.x, Pos.y, Pos.z, 1 + (Random.RandInt() % 6)); + + m_LovePartner->GetBehaviorBreeder()->ResetLoveMode(); + ResetLoveMode(); + } + } +} + + + + + +void cBehaviorBreeder::PostTick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) +{ + UNUSED(a_Dt); + UNUSED(a_Chunk); + if (m_MatingTimer > 0) + { + m_MatingTimer--; + } + if (m_LoveCooldown > 0) + { + m_LoveCooldown--; + } + if (m_LoveTimer > 0) + { + m_LoveTimer--; + } +} + + + + + +bool cBehaviorBreeder::IsControlDesired(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) +{ + UNUSED(a_Dt); + UNUSED(a_Chunk); + cWorld * World = m_Parent->GetWorld(); + + // if we have a love partner, we should control the mob + if (m_LovePartner != nullptr) + { + return true; + } + + // If we are in love mode and we have no partner, try to find one + if (m_LoveTimer > 0) + { + class LookForLover : public cEntityCallback + { + public: + cMonster * m_Me; + LookForLover(cMonster * a_Me) : + m_Me(a_Me) + { + } + + virtual bool Item(cEntity * a_Entity) override + { + // If the entity is not a monster, don't breed with it + // Also, do not self-breed + if ((a_Entity->GetEntityType() != cEntity::eEntityType::etMonster) || (a_Entity == m_Me)) + { + return false; + } + + auto PotentialPartner = static_cast<cMonster*>(a_Entity); + + // If the potential partner is not of the same species, don't breed with it + if (PotentialPartner->GetMobType() != m_Me->GetMobType()) + { + return false; + } + + auto PartnerBreedingBehavior = PotentialPartner->GetBehaviorBreeder(); + auto MyBreedingBehavior = m_Me->GetBehaviorBreeder(); + + // If the potential partner is not in love + // Or they already have a mate, do not breed with them + + if ((!PartnerBreedingBehavior->IsInLove()) || (PartnerBreedingBehavior->GetPartner() != nullptr)) + { + return false; + } + + // All conditions met, let's breed! + PartnerBreedingBehavior->EngageLoveMode(m_Me); + MyBreedingBehavior->EngageLoveMode(PotentialPartner); + return true; + } + } Callback(m_Parent); + + World->ForEachEntityInBox(cBoundingBox(m_Parent->GetPosition(), 8, 8), Callback); + if (m_LovePartner != nullptr) + { + return true; // We found love and took control of the monster, prevent other Behaviors from doing so + } + } + + return false; +} + +void cBehaviorBreeder::Destroyed() +{ + LOGD("mobDebug - Behavior Breeder: Destroyed"); + if (m_LovePartner != nullptr) + { + m_LovePartner->GetBehaviorBreeder()->ResetLoveMode(); + } +} + + + + + +void cBehaviorBreeder::OnRightClicked(cPlayer & a_Player) +{ + // If a player holding breeding items right-clicked me, go into love mode + if ((m_LoveCooldown == 0) && !IsInLove() && !m_Parent->IsBaby()) + { + short HeldItem = a_Player.GetEquippedItem().m_ItemType; + cItems BreedingItems; + m_Parent->GetFollowedItems(BreedingItems); + if (BreedingItems.ContainsType(HeldItem)) + { + if (!a_Player.IsGameModeCreative()) + { + a_Player.GetInventory().RemoveOneEquippedItem(); + } + m_LoveTimer = 20 * 30; // half a minute + m_Parent->GetWorld()->BroadcastEntityStatus(*m_Parent, cEntity::eEntityStatus::esMobInLove); + } + } +} + + + +void cBehaviorBreeder::EngageLoveMode(cMonster * a_Partner) +{ + m_LovePartner = a_Partner; + m_MatingTimer = 50; // about 3 seconds of mating +} + + + + + +void cBehaviorBreeder::ResetLoveMode() +{ + m_LovePartner = nullptr; + m_LoveTimer = 0; + m_MatingTimer = 0; + m_LoveCooldown = 20 * 60 * 5; // 5 minutes + + // when an animal is in love mode, the client only stops sending the hearts if we let them know it's in cooldown, which is done with the "age" metadata + m_Parent->GetWorld()->BroadcastEntityMetadata(*m_Parent); +} + + + + + +bool cBehaviorBreeder::IsInLove() const +{ + return m_LoveTimer > 0; +} + + + + + +bool cBehaviorBreeder::IsInLoveCooldown() const +{ + return (m_LoveCooldown > 0); +} diff --git a/src/Mobs/Behaviors/BehaviorBreeder.h b/src/Mobs/Behaviors/BehaviorBreeder.h new file mode 100644 index 000000000..a3d0b51af --- /dev/null +++ b/src/Mobs/Behaviors/BehaviorBreeder.h @@ -0,0 +1,52 @@ +#pragma once + +class cBehaviorBreeder; + +#include "Behavior.h" + +/** Grants breeding capabilities to the mob. */ +class cBehaviorBreeder : public cBehavior +{ + +public: + cBehaviorBreeder(); + void AttachToMonster(cMonster & a_Parent); + + // Functions our host Monster should invoke: + bool IsControlDesired(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) override; + void Tick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) override; + void PostTick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) override; + void OnRightClicked(cPlayer & a_Player) override; + void Destroyed() override; + + /** Returns the partner which the monster is currently mating with. */ + cMonster * GetPartner(void) const { return m_LovePartner; } + + /** Start the mating process. Causes the monster to keep bumping into the partner until m_MatingTimer reaches zero. */ + void EngageLoveMode(cMonster * a_Partner); + + /** Finish the mating process. Called after a baby is born. Resets all breeding related timers and sets m_LoveCooldown to 20 minutes. */ + void ResetLoveMode(); + + /** Returns whether the monster has just been fed and is ready to mate. If this is "true" and GetPartner isn't "nullptr", then the monster is mating. */ + bool IsInLove() const; + + /** Returns whether the monster is tired of breeding and is in the cooldown state. */ + bool IsInLoveCooldown() const; + +private: + /** Our parent */ + cMonster * m_Parent; + + /** The monster's breeding partner. */ + cMonster * m_LovePartner; + + /** If above 0, the monster is in love mode, and will breed if a nearby monster is also in love mode. Decrements by 1 per tick till reaching zero. */ + int m_LoveTimer; + + /** If above 0, the monster is in cooldown mode and will refuse to breed. Decrements by 1 per tick till reaching zero. */ + int m_LoveCooldown; + + /** The monster is engaged in mating, once this reaches zero, a baby will be born. Decrements by 1 per tick till reaching zero, then a baby is made and ResetLoveMode() is called. */ + int m_MatingTimer; +}; diff --git a/src/Mobs/Behaviors/BehaviorCoward.cpp b/src/Mobs/Behaviors/BehaviorCoward.cpp new file mode 100644 index 000000000..132735e0f --- /dev/null +++ b/src/Mobs/Behaviors/BehaviorCoward.cpp @@ -0,0 +1,94 @@ +#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules + +#include "BehaviorCoward.h" +#include "../Monster.h" +#include "../../World.h" +#include "../../Entities/Player.h" +#include "../../Entities/Entity.h" + +cBehaviorCoward::cBehaviorCoward() : + m_Attacker(nullptr) +{ +} + + + + +void cBehaviorCoward::AttachToMonster(cMonster & a_Parent) +{ + m_Parent = &a_Parent; + m_Parent->AttachTickBehavior(this); + m_Parent->AttachDoTakeDamageBehavior(this); +} + + + + + +bool cBehaviorCoward::IsControlDesired(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) +{ + UNUSED(a_Dt); + UNUSED(a_Chunk); + return (m_Attacker != nullptr); //mobTodo probably not so safe pointer (and cChaser m_Target too) +} + + + + + +bool cBehaviorCoward::ControlStarting(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) +{ + UNUSED(a_Dt); + UNUSED(a_Chunk); + m_Parent->SetRelativeWalkSpeed(m_Parent->GetRelativeWalkSpeed() * 3); + return true; +} + + +bool cBehaviorCoward::ControlEnding(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) +{ + UNUSED(a_Dt); + UNUSED(a_Chunk); + m_Parent->SetRelativeWalkSpeed(m_Parent->GetRelativeWalkSpeed() / 3); + return true; +} + + + + + +void cBehaviorCoward::Tick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) +{ + UNUSED(a_Dt); + UNUSED(a_Chunk); + if (m_Attacker == nullptr) + { + return; + } + + // TODO NOT SAFE + if (m_Attacker->IsDestroyed() || (m_Attacker->GetPosition() - m_Parent->GetPosition()).Length() > m_Parent->GetSightDistance()) + { + // We lost the attacker + m_Attacker = nullptr; + return; + } + + Vector3d newloc = m_Parent->GetPosition(); + newloc.x = (m_Attacker->GetPosition().x < newloc.x)? (newloc.x + m_Parent->GetSightDistance()): (newloc.x - m_Parent->GetSightDistance()); + newloc.z = (m_Attacker->GetPosition().z < newloc.z)? (newloc.z + m_Parent->GetSightDistance()): (newloc.z - m_Parent->GetSightDistance()); + m_Parent->MoveToPosition(newloc); +} + + + + + +void cBehaviorCoward::DoTakeDamage(TakeDamageInfo & a_TDI) +{ + if ((a_TDI.Attacker != m_Parent) && (a_TDI.Attacker != nullptr)) + { + m_Attacker = a_TDI.Attacker; + } +} + diff --git a/src/Mobs/Behaviors/BehaviorCoward.h b/src/Mobs/Behaviors/BehaviorCoward.h new file mode 100644 index 000000000..3232f807b --- /dev/null +++ b/src/Mobs/Behaviors/BehaviorCoward.h @@ -0,0 +1,22 @@ +#pragma once + +#include "Behavior.h" + +/** Makes the mob run away from any other mob that damages it. */ +class cBehaviorCoward : cBehavior +{ +public: + cBehaviorCoward(); + void AttachToMonster(cMonster & a_Parent); + + bool IsControlDesired(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) override; + bool ControlStarting(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) override; + bool ControlEnding(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) override; + void Tick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) override; + void DoTakeDamage(TakeDamageInfo & a_TDI) override; + + +private: + cMonster * m_Parent; // Our Parent + cEntity * m_Attacker; // The entity we're running away from +}; diff --git a/src/Mobs/Behaviors/BehaviorDayLightBurner.cpp b/src/Mobs/Behaviors/BehaviorDayLightBurner.cpp new file mode 100644 index 000000000..ab234e56f --- /dev/null +++ b/src/Mobs/Behaviors/BehaviorDayLightBurner.cpp @@ -0,0 +1,106 @@ +#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules + +#include "BehaviorDayLightBurner.h" +#include "../Monster.h" +#include "../../Entities/Player.h" +#include "../../Entities/Entity.h" + +#include "../../Chunk.h" + + + + + +void cBehaviorDayLightBurner::AttachToMonster(cMonster & a_Parent) +{ + m_Parent = &a_Parent; + m_Parent->AttachPostTickBehavior(this); +} + + + + + +void cBehaviorDayLightBurner::PostTick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) +{ + // mobTodo WouldBurn + bool WouldBurn = false; // TEMP + + int RelY = static_cast<int>(m_Parent->GetPosY()); + if ((RelY < 0) || (RelY >= cChunkDef::Height)) + { + // Outside the world + return; + } + if (!a_Chunk.IsLightValid()) + { + m_Parent->GetWorld()->QueueLightChunk(m_Parent->GetChunkX(), m_Parent->GetChunkZ()); + return; + } + + if (!m_Parent->IsOnFire() && WouldBurn) + { + // Burn for 100 ticks, then decide again + m_Parent->StartBurning(100); + } +} + + + + +bool cBehaviorDayLightBurner::WouldBurnAt(Vector3d a_Location, cChunk & a_Chunk) +{ + int RelY = FloorC(a_Location.y); + if (RelY <= 0) + { + // The mob is about to die, no point in burning + return false; + } + if (RelY >= cChunkDef::Height) + { + // Always burn above the world + return true; + } + + PREPARE_REL_AND_CHUNK(a_Location, a_Chunk); + if (!RelSuccess) + { + return false; + } + + if ( + (Chunk->GetBlock(Rel.x, Rel.y, Rel.z) != E_BLOCK_SOULSAND) && // Not on soulsand + (m_Parent->GetWorld()->GetTimeOfDay() < 12000 + 1000) && // Daytime + m_Parent->GetWorld()->IsWeatherSunnyAt(static_cast<int>(m_Parent->GetPosX()), static_cast<int>(m_Parent->GetPosZ())) // Not raining + ) + { + int MobHeight = CeilC(a_Location.y + m_Parent->GetHeight()) - 1; // The height of the mob head + if (MobHeight >= cChunkDef::Height) + { + return true; + } + // Start with the highest block and scan down to just abovethe mob's head. + // If a non transparent is found, return false (do not burn). Otherwise return true. + // Note that this loop is not a performance concern as transparent blocks are rare and the loop almost always bailes out + // instantly.(An exception is e.g. standing under a long column of glass). + int CurrentBlock = Chunk->GetHeight(Rel.x, Rel.z); + while (CurrentBlock > MobHeight) + { + BLOCKTYPE Block = Chunk->GetBlock(Rel.x, CurrentBlock, Rel.z); + if ( + // Do not burn if a block above us meets one of the following conditions: + (!cBlockInfo::IsTransparent(Block)) || + (Block == E_BLOCK_LEAVES) || + (Block == E_BLOCK_NEW_LEAVES) || + (IsBlockWater(Block)) + ) + { + return false; + } + --CurrentBlock; + } + return true; + + } + return false; +} diff --git a/src/Mobs/Behaviors/BehaviorDayLightBurner.h b/src/Mobs/Behaviors/BehaviorDayLightBurner.h new file mode 100644 index 000000000..07812b9db --- /dev/null +++ b/src/Mobs/Behaviors/BehaviorDayLightBurner.h @@ -0,0 +1,17 @@ +#pragma once + +// mobTodo I just need vector3d +#include "Behavior.h" +#include "../../World.h" + +class cBehaviorDayLightBurner : cBehavior +{ +public: + void AttachToMonster(cMonster & a_Parent); + void PostTick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) override; + bool WouldBurnAt(Vector3d a_Location, cChunk & a_Chunk); + +private: + cMonster * m_Parent; // Our Parent + cEntity * m_Attacker; // The entity we're running away from +}; diff --git a/src/Mobs/Behaviors/BehaviorDoNothing.cpp b/src/Mobs/Behaviors/BehaviorDoNothing.cpp new file mode 100644 index 000000000..aeb4b815e --- /dev/null +++ b/src/Mobs/Behaviors/BehaviorDoNothing.cpp @@ -0,0 +1,24 @@ +#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules + +#include "BehaviorDoNothing.h" +#include "../Monster.h" + +void cBehaviorDoNothing::AttachToMonster(cMonster & a_Parent) +{ + m_Parent = &a_Parent; + m_Parent->AttachTickBehavior(this); +} + +bool cBehaviorDoNothing::IsControlDesired(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) +{ + UNUSED(a_Dt); + UNUSED(a_Chunk); + return true; +} + +void cBehaviorDoNothing::Tick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) +{ + UNUSED(a_Dt); + UNUSED(a_Chunk); + return; +} diff --git a/src/Mobs/Behaviors/BehaviorDoNothing.h b/src/Mobs/Behaviors/BehaviorDoNothing.h new file mode 100644 index 000000000..52c0c7c08 --- /dev/null +++ b/src/Mobs/Behaviors/BehaviorDoNothing.h @@ -0,0 +1,19 @@ +#pragma once + +// Always takes control of the tick and does nothing. Used for unimplemented mobs like squids. + +class cBehaviorDoNothing; + +#include "Behavior.h" + +class cBehaviorDoNothing : public cBehavior +{ +public: + void AttachToMonster(cMonster & a_Parent); + bool IsControlDesired(std::chrono::milliseconds a_Dt, cChunk & a_Chunk); + void Tick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk); + +private: + /** Our parent */ + cMonster * m_Parent; +}; diff --git a/src/Mobs/Behaviors/BehaviorItemDropper.cpp b/src/Mobs/Behaviors/BehaviorItemDropper.cpp new file mode 100644 index 000000000..d39993012 --- /dev/null +++ b/src/Mobs/Behaviors/BehaviorItemDropper.cpp @@ -0,0 +1,50 @@ +#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules + +#include "BehaviorItemDropper.h" +#include "../Monster.h" +#include "../../World.h" + + +void cBehaviorItemDropper::AttachToMonster(cMonster & a_Parent) +{ + m_Parent = &a_Parent; + m_EggDropTimer = 0; + m_Parent->AttachPostTickBehavior(this); +} + + + + + +void cBehaviorItemDropper::PostTick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) +{ + if (!m_Parent->IsTicking()) + { + // The base class tick destroyed us + return; + } + + if (m_Parent->IsBaby()) + { + return; // Babies don't lay eggs + } + + if ((m_EggDropTimer == 6000) && GetRandomProvider().RandBool()) + { + cItems Drops; + m_EggDropTimer = 0; + Drops.push_back(cItem(E_ITEM_EGG, 1)); + m_Parent->GetWorld()->SpawnItemPickups(Drops, m_Parent->GetPosX(), m_Parent->GetPosY(), m_Parent->GetPosZ(), 10); + } + else if (m_EggDropTimer == 12000) + { + cItems Drops; + m_EggDropTimer = 0; + Drops.push_back(cItem(E_ITEM_EGG, 1)); + m_Parent->GetWorld()->SpawnItemPickups(Drops, m_Parent->GetPosX(), m_Parent->GetPosY(), m_Parent->GetPosZ(), 10); + } + else + { + m_EggDropTimer++; + } +} diff --git a/src/Mobs/Behaviors/BehaviorItemDropper.h b/src/Mobs/Behaviors/BehaviorItemDropper.h new file mode 100644 index 000000000..2b9623ecf --- /dev/null +++ b/src/Mobs/Behaviors/BehaviorItemDropper.h @@ -0,0 +1,17 @@ +#pragma once + +// mobTodo a more generic, not chickenspecific dropper + +#include "Behavior.h" + +/** Makes the mob periodically lay eggs. */ +class cBehaviorItemDropper : cBehavior +{ +public: + void AttachToMonster(cMonster & a_Parent); + void PostTick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) override; + +private: + cMonster * m_Parent; // Our Parent + int m_EggDropTimer; +}; diff --git a/src/Mobs/Behaviors/BehaviorItemFollower.cpp b/src/Mobs/Behaviors/BehaviorItemFollower.cpp new file mode 100644 index 000000000..6978b2765 --- /dev/null +++ b/src/Mobs/Behaviors/BehaviorItemFollower.cpp @@ -0,0 +1,64 @@ +#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules + +#include "BehaviorItemFollower.h" +#include "../Monster.h" +#include "../../World.h" +#include "../../Entities/Player.h" + + +void cBehaviorItemFollower::AttachToMonster(cMonster & a_Parent) +{ + LOGD("mobDebug - Behavior ItemFollower: Attach"); + m_Parent = &a_Parent; + m_Parent->AttachTickBehavior(this); +} + + + + + +bool cBehaviorItemFollower::IsControlDesired(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) +{ + UNUSED(a_Dt); + UNUSED(a_Chunk); + cItems FollowedItems; + m_Parent->GetFollowedItems(FollowedItems); + if (FollowedItems.Size() > 0) + { + cPlayer * a_Closest_Player = m_Parent->GetNearestPlayer(); + if (a_Closest_Player != nullptr) + { + cItem EquippedItem = a_Closest_Player->GetEquippedItem(); + if (FollowedItems.ContainsType(EquippedItem)) + { + return true; // We take control of the monster. Now it'll call our tick + } + } + } + return false; +} + + + + + +void cBehaviorItemFollower::Tick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) +{ + UNUSED(a_Dt); + UNUSED(a_Chunk); + cItems FollowedItems; + m_Parent->GetFollowedItems(FollowedItems); + if (FollowedItems.Size() > 0) + { + cPlayer * a_Closest_Player = m_Parent->GetNearestPlayer(); + if (a_Closest_Player != nullptr) + { + cItem EquippedItem = a_Closest_Player->GetEquippedItem(); + if (FollowedItems.ContainsType(EquippedItem)) + { + Vector3d PlayerPos = a_Closest_Player->GetPosition(); + m_Parent->MoveToPosition(PlayerPos); + } + } + } +} diff --git a/src/Mobs/Behaviors/BehaviorItemFollower.h b/src/Mobs/Behaviors/BehaviorItemFollower.h new file mode 100644 index 000000000..8c79ec763 --- /dev/null +++ b/src/Mobs/Behaviors/BehaviorItemFollower.h @@ -0,0 +1,19 @@ +#pragma once + + +class cBehaviorItemFollower; + +#include "Behavior.h" +/** Makes the mob follow specific items when held by the player. +Currently relies on cMonster::GetFollowedItems for the item list. */ +class cBehaviorItemFollower : public cBehavior +{ +public: + void AttachToMonster(cMonster & a_Parent); + bool IsControlDesired(std::chrono::milliseconds a_Dt, cChunk & a_Chunk); + void Tick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk); + +private: + /** Our parent */ + cMonster * m_Parent; +}; diff --git a/src/Mobs/Behaviors/BehaviorItemReplacer.cpp b/src/Mobs/Behaviors/BehaviorItemReplacer.cpp new file mode 100644 index 000000000..b53f08b33 --- /dev/null +++ b/src/Mobs/Behaviors/BehaviorItemReplacer.cpp @@ -0,0 +1,40 @@ +#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules + +#include "BehaviorItemReplacer.h" +#include "../Monster.h" +#include "../Entities/Player.h" + + +cBehaviorItemReplacer::cBehaviorItemReplacer(short a_OriginalItem, short a_NewItem) : + m_OriginalItem(a_OriginalItem) , + m_NewItem(a_NewItem) +{ + +} + + + + + +void cBehaviorItemReplacer::AttachToMonster(cMonster & a_Parent) +{ + m_Parent = &a_Parent; + m_Parent->AttachRightClickBehavior(this); +} + + + + + +void cBehaviorItemReplacer::OnRightClicked(cPlayer & a_Player) +{ + short HeldItem = a_Player.GetEquippedItem().m_ItemType; + if (HeldItem == m_OriginalItem) + { + if (!a_Player.IsGameModeCreative()) + { + a_Player.GetInventory().RemoveOneEquippedItem(); + a_Player.GetInventory().AddItem(m_NewItem); + } + } +} diff --git a/src/Mobs/Behaviors/BehaviorItemReplacer.h b/src/Mobs/Behaviors/BehaviorItemReplacer.h new file mode 100644 index 000000000..e35729f0e --- /dev/null +++ b/src/Mobs/Behaviors/BehaviorItemReplacer.h @@ -0,0 +1,26 @@ +#pragma once + + +class cBehaviorItemReplacer; + +#include "Behavior.h" + +/** When right clicked while holding a_OriginalItem, a mob having this behavior replaces the original item +with a_NewItem. This is used for milking cows. +*/ +class cBehaviorItemReplacer : public cBehavior +{ + +public: + cBehaviorItemReplacer(short a_OriginalItem, short a_NewItem); + void AttachToMonster(cMonster & a_Parent); + void OnRightClicked(cPlayer & a_Player) override; +private: + // Our parent + cMonster * m_Parent; + short m_OriginalItem; // Replace this item with NewItem + short m_NewItem; +}; + + + diff --git a/src/Mobs/Behaviors/BehaviorStriker.cpp b/src/Mobs/Behaviors/BehaviorStriker.cpp new file mode 100644 index 000000000..e09bb45f9 --- /dev/null +++ b/src/Mobs/Behaviors/BehaviorStriker.cpp @@ -0,0 +1,7 @@ +/* +bool cAggressiveMonster::Attack(std::chrono::milliseconds a_Dt) +{ + GetTarget()->TakeDamage(dtMobAttack, this, m_AttackDamage, 0); + + return true; +} */ diff --git a/src/Mobs/Behaviors/BehaviorStriker.h b/src/Mobs/Behaviors/BehaviorStriker.h new file mode 100644 index 000000000..6fc094476 --- /dev/null +++ b/src/Mobs/Behaviors/BehaviorStriker.h @@ -0,0 +1,13 @@ +#pragma once +class cBehaviorStriker +{ + +}; + +/* +bool cAggressiveMonster::Attack(std::chrono::milliseconds a_Dt) +{ + GetTarget()->TakeDamage(dtMobAttack, this, m_AttackDamage, 0); + + return true; +} */ diff --git a/src/Mobs/Behaviors/BehaviorWanderer.cpp b/src/Mobs/Behaviors/BehaviorWanderer.cpp new file mode 100644 index 000000000..b57d5f033 --- /dev/null +++ b/src/Mobs/Behaviors/BehaviorWanderer.cpp @@ -0,0 +1,85 @@ +#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules +#include "BehaviorWanderer.h" +#include "../Monster.h" +#include "../../Chunk.h" +#include "../../World.h" + +cBehaviorWanderer::cBehaviorWanderer() : m_IdleInterval(0) +{ + +} + + + + + +void cBehaviorWanderer::AttachToMonster(cMonster & a_Parent) +{ + LOGD("mobDebug - Behavior Wanderer: Attach"); + m_Parent = &a_Parent; + m_Parent->AttachTickBehavior(this); +} + + + + + +bool cBehaviorWanderer::IsControlDesired(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) +{ + // Wandering behavior always happily accepts control. + // It should therefore be the last one attached to a monster. + UNUSED(a_Dt); + UNUSED(a_Chunk); + return true; +} + + + + + +void cBehaviorWanderer::Tick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) +{ + if (m_Parent->IsPathFinderActivated()) + { + return; // Still getting there + } + + m_IdleInterval += a_Dt; + + if (m_IdleInterval > std::chrono::seconds(1)) + { + // At this interval the results are predictable + int rem = m_Parent->GetWorld()->GetTickRandomNumber(6) + 1; + m_IdleInterval -= std::chrono::seconds(1); // So nothing gets dropped when the server hangs for a few seconds + + Vector3d Dist; + Dist.x = static_cast<double>(m_Parent->GetWorld()->GetTickRandomNumber(10)) - 5.0; + Dist.z = static_cast<double>(m_Parent->GetWorld()->GetTickRandomNumber(10)) - 5.0; + + if ((Dist.SqrLength() > 2) && (rem >= 3)) + { + + Vector3d Destination(m_Parent->GetPosX() + Dist.x, m_Parent->GetPosition().y, m_Parent->GetPosZ() + Dist.z); + + cChunk * Chunk = a_Chunk.GetNeighborChunk(static_cast<int>(Destination.x), static_cast<int>(Destination.z)); + if ((Chunk == nullptr) || !Chunk->IsValid()) + { + return; + } + + BLOCKTYPE BlockType; + NIBBLETYPE BlockMeta; + int RelX = static_cast<int>(Destination.x) - Chunk->GetPosX() * cChunkDef::Width; + int RelZ = static_cast<int>(Destination.z) - Chunk->GetPosZ() * cChunkDef::Width; + int YBelowUs = static_cast<int>(Destination.y) - 1; + if (YBelowUs >= 0) + { + Chunk->GetBlockTypeMeta(RelX, YBelowUs, RelZ, BlockType, BlockMeta); + if (BlockType != E_BLOCK_STATIONARY_WATER) // Idle mobs shouldn't enter water on purpose + { + m_Parent->MoveToPosition(Destination); + } + } + } + } +} diff --git a/src/Mobs/Behaviors/BehaviorWanderer.h b/src/Mobs/Behaviors/BehaviorWanderer.h new file mode 100644 index 000000000..c694eb331 --- /dev/null +++ b/src/Mobs/Behaviors/BehaviorWanderer.h @@ -0,0 +1,23 @@ +#pragma once + +// The mob will wander around +#include <chrono> +#include "Behavior.h" + +class cBehaviorWanderer : cBehavior +{ + +public: + cBehaviorWanderer(); + void AttachToMonster(cMonster & a_Parent); + + // Functions our host Monster should invoke: + bool IsControlDesired(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) override; + void Tick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) override; + + +private: + cMonster * m_Parent; // Our Parent + + std::chrono::milliseconds m_IdleInterval; +}; diff --git a/src/Mobs/Behaviors/CMakeLists.txt b/src/Mobs/Behaviors/CMakeLists.txt new file mode 100644 index 000000000..686d0937b --- /dev/null +++ b/src/Mobs/Behaviors/CMakeLists.txt @@ -0,0 +1,43 @@ + +cmake_minimum_required (VERSION 2.6) +project (Cuberite) + +include_directories ("${PROJECT_SOURCE_DIR}/../") + +SET (SRCS + Behavior.cpp + BehaviorAggressive.cpp + BehaviorAttacker.cpp + BehaviorBrave.cpp + BehaviorBreeder.cpp + BehaviorDoNothing.cpp + BehaviorDayLightBurner.cpp + BehaviorCoward.cpp + BehaviorItemDropper.cpp + BehaviorItemFollower.cpp + BehaviorItemReplacer.cpp + BehaviorAttackerMelee.cpp + BehaviorStriker.cpp + BehaviorWanderer.cpp +) + +SET (HDRS + Behavior.h + BehaviorAggressive.h + BehaviorAttacker.h + BehaviorBrave.h + BehaviorBreeder.h + BehaviorDoNothing.h + BehaviorDayLightBurner.h + BehaviorCoward.h + BehaviorItemDropper.h + BehaviorItemFollower.h + BehaviorItemReplacer.h + BehaviorAttackerMelee.h + BehaviorStriker.h + BehaviorWanderer.h +) + +if(NOT MSVC) + add_library(Behaviors ${SRCS} ${HDRS}) +endif() diff --git a/src/Mobs/Blaze.cpp b/src/Mobs/Blaze.cpp index a48bfa886..df54be1fd 100644 --- a/src/Mobs/Blaze.cpp +++ b/src/Mobs/Blaze.cpp @@ -11,6 +11,7 @@ cBlaze::cBlaze(void) : super("Blaze", mtBlaze, "entity.blaze.hurt", "entity.blaze.death", 0.6, 1.8) { + m_EMPersonality = AGGRESSIVE; SetGravity(-8.0f); SetAirDrag(0.05f); } @@ -31,7 +32,8 @@ void cBlaze::GetDrops(cItems & a_Drops, cEntity * a_Killer) - +// mobTODO +/* bool cBlaze::Attack(std::chrono::milliseconds a_Dt) { if ((GetTarget() != nullptr) && (m_AttackCoolDownTicksLeft == 0)) @@ -53,4 +55,4 @@ bool cBlaze::Attack(std::chrono::milliseconds a_Dt) return true; } return false; -} +}*/ diff --git a/src/Mobs/Blaze.h b/src/Mobs/Blaze.h index ca755b626..1fb165a37 100644 --- a/src/Mobs/Blaze.h +++ b/src/Mobs/Blaze.h @@ -1,16 +1,11 @@ - #pragma once -#include "AggressiveMonster.h" - - - - +#include "Monster.h" class cBlaze : - public cAggressiveMonster + public cMonster { - typedef cAggressiveMonster super; + typedef cMonster super; public: cBlaze(void); @@ -18,5 +13,4 @@ public: CLASS_PROTODEF(cBlaze) virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = nullptr) override; - virtual bool Attack(std::chrono::milliseconds a_Dt) override; } ; diff --git a/src/Mobs/CMakeLists.txt b/src/Mobs/CMakeLists.txt index 55ae36e1e..51d9cd630 100644 --- a/src/Mobs/CMakeLists.txt +++ b/src/Mobs/CMakeLists.txt @@ -3,7 +3,6 @@ project (Cuberite) include_directories ("${PROJECT_SOURCE_DIR}/../") SET (SRCS - AggressiveMonster.cpp Bat.cpp Blaze.cpp CaveSpider.cpp @@ -21,12 +20,11 @@ SET (SRCS Monster.cpp Mooshroom.cpp Ocelot.cpp - PassiveAggressiveMonster.cpp - PassiveMonster.cpp Path.cpp PathFinder.cpp Pig.cpp Rabbit.cpp + MobPointer.cpp Sheep.cpp Skeleton.cpp Slime.cpp @@ -41,7 +39,6 @@ SET (SRCS ZombiePigman.cpp) SET (HDRS - AggressiveMonster.h Bat.h Blaze.h CaveSpider.h @@ -61,12 +58,11 @@ SET (HDRS MonsterTypes.h Mooshroom.h Ocelot.h - PassiveAggressiveMonster.h - PassiveMonster.h Path.h PathFinder.h Pig.h Rabbit.h + MobPointer.h Sheep.h Silverfish.h Skeleton.h diff --git a/src/Mobs/CaveSpider.cpp b/src/Mobs/CaveSpider.cpp index c6aa8af61..0e33282c0 100644 --- a/src/Mobs/CaveSpider.cpp +++ b/src/Mobs/CaveSpider.cpp @@ -10,6 +10,7 @@ cCaveSpider::cCaveSpider(void) : super("CaveSpider", mtCaveSpider, "entity.spider.hurt", "entity.spider.death", 0.7, 0.5) { + m_EMPersonality = AGGRESSIVE; } @@ -31,7 +32,7 @@ void cCaveSpider::Tick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) - +/* bool cCaveSpider::Attack(std::chrono::milliseconds a_Dt) { if (!super::Attack(a_Dt)) @@ -45,7 +46,7 @@ bool cCaveSpider::Attack(std::chrono::milliseconds a_Dt) static_cast<cPawn *>(GetTarget())->AddEntityEffect(cEntityEffect::effPoison, 7 * 20, 0); } return true; -} +}*/ diff --git a/src/Mobs/CaveSpider.h b/src/Mobs/CaveSpider.h index cf4b8e17c..f59809d03 100644 --- a/src/Mobs/CaveSpider.h +++ b/src/Mobs/CaveSpider.h @@ -1,15 +1,15 @@ #pragma once -#include "AggressiveMonster.h" +#include "Monster.h" class cCaveSpider : - public cAggressiveMonster + public cMonster { - typedef cAggressiveMonster super; + typedef cMonster super; public: cCaveSpider(void); @@ -17,7 +17,6 @@ public: CLASS_PROTODEF(cCaveSpider) virtual void Tick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) override; - virtual bool Attack(std::chrono::milliseconds a_Dt) override; virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = nullptr) override; } ; diff --git a/src/Mobs/Chicken.cpp b/src/Mobs/Chicken.cpp index 1068295e6..a7b27fc11 100644 --- a/src/Mobs/Chicken.cpp +++ b/src/Mobs/Chicken.cpp @@ -5,53 +5,17 @@ - - - - cChicken::cChicken(void) : - super("Chicken", mtChicken, "entity.chicken.hurt", "entity.chicken.death", 0.3, 0.4), - m_EggDropTimer(0) + super("Chicken", mtChicken, "entity.chicken.hurt", "entity.chicken.death", 0.3, 0.4) { SetGravity(-2.0f); SetAirDrag(0.0f); -} - - - - -void cChicken::Tick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) -{ - super::Tick(a_Dt, a_Chunk); - if (!IsTicking()) - { - // The base class tick destroyed us - return; - } - - if (IsBaby()) - { - return; // Babies don't lay eggs - } - - if ((m_EggDropTimer == 6000) && GetRandomProvider().RandBool()) - { - cItems Drops; - m_EggDropTimer = 0; - Drops.push_back(cItem(E_ITEM_EGG, 1)); - m_World->SpawnItemPickups(Drops, GetPosX(), GetPosY(), GetPosZ(), 10); - } - else if (m_EggDropTimer == 12000) - { - cItems Drops; - m_EggDropTimer = 0; - Drops.push_back(cItem(E_ITEM_EGG, 1)); - m_World->SpawnItemPickups(Drops, GetPosX(), GetPosY(), GetPosZ(), 10); - } - else - { - m_EggDropTimer++; - } + m_EMPersonality = PASSIVE; + m_BehaviorBreeder.AttachToMonster(*this); + m_BehaviorCoward.AttachToMonster(*this); + m_BehaviorItemFollower.AttachToMonster(*this); + m_BehaviorWanderer.AttachToMonster(*this); + m_BehaviorItemDropper.AttachToMonster(*this); } diff --git a/src/Mobs/Chicken.h b/src/Mobs/Chicken.h index 3be338b15..f60f3672f 100644 --- a/src/Mobs/Chicken.h +++ b/src/Mobs/Chicken.h @@ -1,15 +1,18 @@ #pragma once -#include "PassiveMonster.h" - - +#include "Behaviors/BehaviorBreeder.h" +#include "Behaviors/BehaviorItemFollower.h" +#include "Behaviors/BehaviorCoward.h" +#include "Behaviors/BehaviorWanderer.h" +#include "Behaviors/BehaviorItemDropper.h" +#include "Monster.h" class cChicken : - public cPassiveMonster + public cMonster { - typedef cPassiveMonster super; + typedef cMonster super; public: cChicken(void); @@ -17,7 +20,6 @@ public: CLASS_PROTODEF(cChicken) virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = nullptr) override; - virtual void Tick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) override; virtual void GetFollowedItems(cItems & a_Items) override { @@ -27,8 +29,13 @@ public: virtual void HandleFalling(void) override; private: + // Tick controlling behaviors + cBehaviorBreeder m_BehaviorBreeder; + cBehaviorItemFollower m_BehaviorItemFollower; + cBehaviorCoward m_BehaviorCoward; + cBehaviorWanderer m_BehaviorWanderer; - int m_EggDropTimer; + cBehaviorItemDropper m_BehaviorItemDropper; } ; diff --git a/src/Mobs/Cow.cpp b/src/Mobs/Cow.cpp index 9736fe440..3d94986bb 100644 --- a/src/Mobs/Cow.cpp +++ b/src/Mobs/Cow.cpp @@ -6,13 +6,16 @@ - - - - cCow::cCow(void) : - super("Cow", mtCow, "entity.cow.hurt", "entity.cow.death", 0.9, 1.3) + super("Cow", mtCow, "entity.cow.hurt", "entity.cow.death", 0.9, 1.3), + m_BehaviorItemReplacer(E_ITEM_BUCKET, E_ITEM_MILK) { + m_EMPersonality = PASSIVE; + m_BehaviorBreeder.AttachToMonster(*this); + m_BehaviorCoward.AttachToMonster(*this); + m_BehaviorItemFollower.AttachToMonster(*this); + m_BehaviorWanderer.AttachToMonster(*this); + m_BehaviorItemReplacer.AttachToMonster(*this); } @@ -29,22 +32,3 @@ void cCow::GetDrops(cItems & a_Drops, cEntity * a_Killer) AddRandomDropItem(a_Drops, 0, 2 + LootingLevel, E_ITEM_LEATHER); AddRandomDropItem(a_Drops, 1, 3 + LootingLevel, IsOnFire() ? E_ITEM_STEAK : E_ITEM_RAW_BEEF); } - - - - - -void cCow::OnRightClicked(cPlayer & a_Player) -{ - super::OnRightClicked(a_Player); - - short HeldItem = a_Player.GetEquippedItem().m_ItemType; - if (HeldItem == E_ITEM_BUCKET) - { - if (!a_Player.IsGameModeCreative()) - { - a_Player.GetInventory().RemoveOneEquippedItem(); - a_Player.GetInventory().AddItem(E_ITEM_MILK); - } - } -} diff --git a/src/Mobs/Cow.h b/src/Mobs/Cow.h index 569c6e619..58380065a 100644 --- a/src/Mobs/Cow.h +++ b/src/Mobs/Cow.h @@ -1,30 +1,36 @@ - #pragma once -#include "PassiveMonster.h" - - - +#include "Behaviors/BehaviorBreeder.h" +#include "Behaviors/BehaviorItemFollower.h" +#include "Behaviors/BehaviorCoward.h" +#include "Behaviors/BehaviorWanderer.h" +#include "Behaviors/BehaviorItemReplacer.h" +#include "Monster.h" - -class cCow : - public cPassiveMonster +class cCow : public cMonster { - typedef cPassiveMonster super; - public: cCow(); + ~cCow() {} + typedef cMonster super; CLASS_PROTODEF(cCow) virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = nullptr) override; - virtual void OnRightClicked(cPlayer & a_Player) override; virtual void GetFollowedItems(cItems & a_Items) override { a_Items.Add(E_ITEM_WHEAT); } - +private: + // Tick controlling behaviors + cBehaviorBreeder m_BehaviorBreeder; + cBehaviorItemFollower m_BehaviorItemFollower; + cBehaviorCoward m_BehaviorCoward; + cBehaviorWanderer m_BehaviorWanderer; + + // Non tick controlling behaviors + cBehaviorItemReplacer m_BehaviorItemReplacer; } ; diff --git a/src/Mobs/Creeper.cpp b/src/Mobs/Creeper.cpp index 84b68cf7c..8de236863 100644 --- a/src/Mobs/Creeper.cpp +++ b/src/Mobs/Creeper.cpp @@ -17,6 +17,7 @@ cCreeper::cCreeper(void) : m_BurnedWithFlintAndSteel(false), m_ExplodingTimer(0) { + m_EMPersonality = AGGRESSIVE; } @@ -26,6 +27,8 @@ cCreeper::cCreeper(void) : void cCreeper::Tick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) { super::Tick(a_Dt, a_Chunk); + /* mobTodo + if (!IsTicking()) { // The base class tick destroyed us @@ -53,7 +56,8 @@ void cCreeper::Tick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) m_World->DoExplosionAt((m_bIsCharged ? 5 : 3), GetPosX(), GetPosY(), GetPosZ(), false, esMonster, this); Destroy(); // Just in case we aren't killed by the explosion } - } + } */ + } @@ -125,7 +129,8 @@ bool cCreeper::DoTakeDamage(TakeDamageInfo & a_TDI) - +// mobTODO +/* bool cCreeper::Attack(std::chrono::milliseconds a_Dt) { UNUSED(a_Dt); @@ -139,7 +144,7 @@ bool cCreeper::Attack(std::chrono::milliseconds a_Dt) return true; } return false; -} +}*/ diff --git a/src/Mobs/Creeper.h b/src/Mobs/Creeper.h index aea36def3..28a0dd512 100644 --- a/src/Mobs/Creeper.h +++ b/src/Mobs/Creeper.h @@ -1,16 +1,16 @@ #pragma once -#include "AggressiveMonster.h" +#include "Monster.h" class cCreeper : - public cAggressiveMonster + public cMonster { - typedef cAggressiveMonster super; + typedef cMonster super; public: cCreeper(void); @@ -19,7 +19,6 @@ public: virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = nullptr) override; virtual bool DoTakeDamage(TakeDamageInfo & a_TDI) override; - virtual bool Attack(std::chrono::milliseconds a_Dt) override; virtual void Tick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) override; virtual void OnRightClicked(cPlayer & a_Player) override; diff --git a/src/Mobs/EnderDragon.cpp b/src/Mobs/EnderDragon.cpp index 360fe581b..4db5baf87 100644 --- a/src/Mobs/EnderDragon.cpp +++ b/src/Mobs/EnderDragon.cpp @@ -11,6 +11,7 @@ cEnderDragon::cEnderDragon(void) : // TODO: Vanilla source says this, but is it right? Dragons fly, they don't stand super("EnderDragon", mtEnderDragon, "entity.enderdragon.hurt", "entity.enderdragon.death", 16.0, 8.0) { + m_EMPersonality = AGGRESSIVE; } diff --git a/src/Mobs/EnderDragon.h b/src/Mobs/EnderDragon.h index 43acdcd54..0528af77c 100644 --- a/src/Mobs/EnderDragon.h +++ b/src/Mobs/EnderDragon.h @@ -1,16 +1,12 @@ #pragma once -#include "AggressiveMonster.h" - - - - +#include "Monster.h" class cEnderDragon : - public cAggressiveMonster + public cMonster { - typedef cAggressiveMonster super; + typedef cMonster super; public: cEnderDragon(void); diff --git a/src/Mobs/Enderman.cpp b/src/Mobs/Enderman.cpp index 5cfe0d4cd..72301b21a 100644 --- a/src/Mobs/Enderman.cpp +++ b/src/Mobs/Enderman.cpp @@ -79,6 +79,7 @@ cEnderman::cEnderman(void) : CarriedBlock(E_BLOCK_AIR), CarriedMeta(0) { + m_EMPersonality = PASSIVE; } @@ -98,67 +99,6 @@ void cEnderman::GetDrops(cItems & a_Drops, cEntity * a_Killer) -void cEnderman::CheckEventSeePlayer(cChunk & a_Chunk) -{ - if (GetTarget() != nullptr) - { - return; - } - - cPlayerLookCheck Callback(GetPosition(), m_SightDistance); - if (m_World->ForEachPlayer(Callback)) - { - return; - } - - ASSERT(Callback.GetPlayer() != nullptr); - - if (!CheckLight()) - { - // Insufficient light for enderman to become aggravated - // TODO: Teleport to a suitable location - return; - } - - if (!Callback.GetPlayer()->CanMobsTarget()) - { - return; - } - - // Target the player - cMonster::EventSeePlayer(Callback.GetPlayer(), a_Chunk); - m_EMState = CHASING; - m_bIsScreaming = true; - GetWorld()->BroadcastEntityMetadata(*this); -} - - - - - -void cEnderman::CheckEventLostPlayer(void) -{ - super::CheckEventLostPlayer(); - if (!CheckLight()) - { - EventLosePlayer(); - } -} - - - - - -void cEnderman::EventLosePlayer() -{ - super::EventLosePlayer(); - m_bIsScreaming = false; - GetWorld()->BroadcastEntityMetadata(*this); -} - - - - bool cEnderman::CheckLight() { @@ -197,7 +137,7 @@ void cEnderman::Tick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) // Take damage when touching water, drowning damage seems to be most appropriate if (CheckRain() || IsSwimming()) { - EventLosePlayer(); + // EventLosePlayer(); //mobTodo TakeDamage(dtDrowning, nullptr, 1, 0); // TODO teleport to a safe location } diff --git a/src/Mobs/Enderman.h b/src/Mobs/Enderman.h index c9ffbeaba..c3568e1db 100644 --- a/src/Mobs/Enderman.h +++ b/src/Mobs/Enderman.h @@ -1,16 +1,14 @@ - #pragma once - -#include "PassiveAggressiveMonster.h" +#include "Monster.h" class cEnderman : - public cPassiveAggressiveMonster + public cMonster { - typedef cPassiveAggressiveMonster super; + typedef cMonster super; public: cEnderman(void); @@ -18,9 +16,6 @@ public: CLASS_PROTODEF(cEnderman) virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = nullptr) override; - virtual void CheckEventSeePlayer(cChunk & a_Chunk) override; - virtual void CheckEventLostPlayer(void) override; - virtual void EventLosePlayer(void) override; virtual void Tick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) override; bool IsScreaming(void) const {return m_bIsScreaming; } diff --git a/src/Mobs/Ghast.cpp b/src/Mobs/Ghast.cpp index 2488e63b1..d9cd31f45 100644 --- a/src/Mobs/Ghast.cpp +++ b/src/Mobs/Ghast.cpp @@ -11,6 +11,7 @@ cGhast::cGhast(void) : super("Ghast", mtGhast, "entity.ghast.hurt", "entity.ghast.death", 4, 4) { + m_EMPersonality = AGGRESSIVE; } @@ -31,8 +32,8 @@ void cGhast::GetDrops(cItems & a_Drops, cEntity * a_Killer) - -bool cGhast::Attack(std::chrono::milliseconds a_Dt) +// mobTODO +/*bool cGhast::Attack(std::chrono::milliseconds a_Dt) { if ((GetTarget() != nullptr) && (m_AttackCoolDownTicksLeft == 0)) { @@ -51,7 +52,7 @@ bool cGhast::Attack(std::chrono::milliseconds a_Dt) return true; } return false; -} +}*/ diff --git a/src/Mobs/Ghast.h b/src/Mobs/Ghast.h index a41a72ddc..7fea31ae8 100644 --- a/src/Mobs/Ghast.h +++ b/src/Mobs/Ghast.h @@ -1,16 +1,14 @@ - #pragma once - -#include "AggressiveMonster.h" +#include "Monster.h" class cGhast : - public cAggressiveMonster + public cMonster { - typedef cAggressiveMonster super; + typedef cMonster super; public: cGhast(void); @@ -18,7 +16,6 @@ public: CLASS_PROTODEF(cGhast) virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = nullptr) override; - virtual bool Attack(std::chrono::milliseconds a_Dt) override; bool IsCharging(void) const {return false; } } ; diff --git a/src/Mobs/Giant.cpp b/src/Mobs/Giant.cpp index 0f235e10f..c25b4e6a0 100644 --- a/src/Mobs/Giant.cpp +++ b/src/Mobs/Giant.cpp @@ -10,7 +10,7 @@ cGiant::cGiant(void) : super("Giant", mtGiant, "entity.zombie.hurt", "entity.zombie.death", 3.6, 10.8) { - + m_EMPersonality = AGGRESSIVE; } diff --git a/src/Mobs/Giant.h b/src/Mobs/Giant.h index 70e93894c..f1734437b 100644 --- a/src/Mobs/Giant.h +++ b/src/Mobs/Giant.h @@ -1,16 +1,16 @@ #pragma once -#include "AggressiveMonster.h" +#include "Monster.h" class cGiant : - public cAggressiveMonster + public cMonster { - typedef cAggressiveMonster super; + typedef cMonster super; public: cGiant(void); diff --git a/src/Mobs/Guardian.cpp b/src/Mobs/Guardian.cpp index f36f98ea8..ca6b04d55 100644 --- a/src/Mobs/Guardian.cpp +++ b/src/Mobs/Guardian.cpp @@ -11,6 +11,7 @@ cGuardian::cGuardian(void) : super("Guardian", mtGuardian, "entity.guardian.hurt", "entity.guardian.death", 0.875, 0.8) { + m_EMPersonality = AGGRESSIVE; } diff --git a/src/Mobs/Guardian.h b/src/Mobs/Guardian.h index 289654f57..988f36832 100644 --- a/src/Mobs/Guardian.h +++ b/src/Mobs/Guardian.h @@ -1,16 +1,16 @@ #pragma once -#include "AggressiveMonster.h" +#include "Monster.h" class cGuardian : - public cAggressiveMonster + public cMonster { - typedef cAggressiveMonster super; + typedef cMonster super; public: cGuardian(); diff --git a/src/Mobs/Horse.cpp b/src/Mobs/Horse.cpp index 13630b0e3..6ff53df69 100644 --- a/src/Mobs/Horse.cpp +++ b/src/Mobs/Horse.cpp @@ -27,6 +27,11 @@ cHorse::cHorse(int Type, int Color, int Style, int TameTimes) : m_RearTickCount(0), m_MaxSpeed(14.0) { + m_EMPersonality = PASSIVE; + m_BehaviorBreeder.AttachToMonster(*this); + m_BehaviorCoward.AttachToMonster(*this); + m_BehaviorItemFollower.AttachToMonster(*this); + m_BehaviorWanderer.AttachToMonster(*this); } @@ -185,19 +190,6 @@ void cHorse::GetDrops(cItems & a_Drops, cEntity * a_Killer) -void cHorse::InStateIdle(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) -{ - // If horse is tame and someone is sitting on it, don't walk around - if ((!m_bIsTame) || (m_Attachee == nullptr)) - { - super::InStateIdle(a_Dt, a_Chunk); - } -} - - - - - void cHorse::HandleSpeedFromAttachee(float a_Forward, float a_Sideways) { if ((m_bIsTame) && (m_bIsSaddled)) diff --git a/src/Mobs/Horse.h b/src/Mobs/Horse.h index 82026a0ee..e96a1f8a9 100644 --- a/src/Mobs/Horse.h +++ b/src/Mobs/Horse.h @@ -1,16 +1,20 @@ #pragma once -#include "PassiveMonster.h" +#include "Behaviors/BehaviorBreeder.h" +#include "Behaviors/BehaviorItemFollower.h" +#include "Behaviors/BehaviorCoward.h" +#include "Behaviors/BehaviorWanderer.h" +#include "Monster.h" class cHorse : - public cPassiveMonster + public cMonster { - typedef cPassiveMonster super; + typedef cMonster super; public: cHorse(int Type, int Color, int Style, int TameTimes); @@ -18,7 +22,6 @@ public: CLASS_PROTODEF(cHorse) virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = nullptr) override; - virtual void InStateIdle(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) override; virtual void HandleSpeedFromAttachee(float a_Forward, float a_Sideways) override; virtual void Tick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) override; virtual void OnRightClicked(cPlayer & a_Player) override; @@ -39,8 +42,12 @@ public: a_Items.Add(E_ITEM_GOLDEN_CARROT); a_Items.Add(E_ITEM_GOLDEN_APPLE); } - private: + // Tick controlling behaviors + cBehaviorBreeder m_BehaviorBreeder; + cBehaviorItemFollower m_BehaviorItemFollower; + cBehaviorCoward m_BehaviorCoward; + cBehaviorWanderer m_BehaviorWanderer; bool m_bHasChest, m_bIsEating, m_bIsRearing, m_bIsMouthOpen, m_bIsTame, m_bIsSaddled; int m_Type, m_Color, m_Style, m_Armour, m_TimesToTame, m_TameAttemptTimes, m_RearTickCount; diff --git a/src/Mobs/IronGolem.cpp b/src/Mobs/IronGolem.cpp index 448ed8dc0..223161c68 100644 --- a/src/Mobs/IronGolem.cpp +++ b/src/Mobs/IronGolem.cpp @@ -10,6 +10,7 @@ cIronGolem::cIronGolem(void) : super("IronGolem", mtIronGolem, "entity.irongolem.hurt", "entity.irongolem.death", 1.4, 2.9) { + m_EMPersonality = PASSIVE; } diff --git a/src/Mobs/IronGolem.h b/src/Mobs/IronGolem.h index 7d35686e7..c35452e3b 100644 --- a/src/Mobs/IronGolem.h +++ b/src/Mobs/IronGolem.h @@ -1,16 +1,16 @@ #pragma once -#include "PassiveAggressiveMonster.h" +#include "Monster.h" class cIronGolem : - public cPassiveAggressiveMonster + public cMonster { - typedef cPassiveAggressiveMonster super; + typedef cMonster super; public: cIronGolem(void); diff --git a/src/Mobs/MagmaCube.cpp b/src/Mobs/MagmaCube.cpp index 4d70a0291..dd4e6916e 100644 --- a/src/Mobs/MagmaCube.cpp +++ b/src/Mobs/MagmaCube.cpp @@ -10,6 +10,7 @@ cMagmaCube::cMagmaCube(int a_Size) : super("MagmaCube", mtMagmaCube, Printf("entity.%smagmacube.hurt", GetSizeName(a_Size).c_str()), Printf("entity.%smagmacube.death", GetSizeName(a_Size).c_str()), 0.6 * a_Size, 0.6 * a_Size), m_Size(a_Size) { + m_EMPersonality = AGGRESSIVE; } diff --git a/src/Mobs/MagmaCube.h b/src/Mobs/MagmaCube.h index 5fc8105ba..960ff0c90 100644 --- a/src/Mobs/MagmaCube.h +++ b/src/Mobs/MagmaCube.h @@ -1,15 +1,15 @@ #pragma once -#include "AggressiveMonster.h" +#include "Monster.h" class cMagmaCube : - public cAggressiveMonster + public cMonster { - typedef cAggressiveMonster super; + typedef cMonster super; public: /** Creates a MagmaCube of the specified size; with 1 being the smallest */ diff --git a/src/Mobs/MobPointer.cpp b/src/Mobs/MobPointer.cpp new file mode 100644 index 000000000..8fb64867d --- /dev/null +++ b/src/Mobs/MobPointer.cpp @@ -0,0 +1,78 @@ +#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules + +#include "../Entities/Pawn.h" +#include "MobPointer.h" +#include "../World.h" + +cMobPointer::cMobPointer(cPawn * a_Pointer) : m_Pointer(a_Pointer) +{ + // Constructor +} + + + + + +cMobPointer::cMobPointer(const cMobPointer & a_MobPointer) : m_Pointer(a_MobPointer.m_Pointer) +{ + // Copy constructor +} + + + + + +cMobPointer::cMobPointer(cMobPointer && a_MobPointer) +{ + // move Constructor + m_Pointer = a_MobPointer.m_Pointer; + a_MobPointer.m_Pointer = nullptr; +} + + + + + +cMobPointer& cMobPointer::operator=(const cMobPointer& a_MobPointer) +{ + // Copy assignment operator + m_Pointer = a_MobPointer.m_Pointer; + return *this; +} + + + + + +cMobPointer& cMobPointer::operator=(cMobPointer&& a_MobPointer) +{ + // Move assignment operator + m_Pointer = a_MobPointer.m_Pointer; + a_MobPointer.m_Pointer = nullptr; + return *this; +} + + + + + +void cMobPointer::SetPointer(cPawn * a_Pointer) +{ + m_Pointer = a_Pointer; +} + + + + + +cPawn * cMobPointer::GetPointer(cWorld * a_CurrentWorld) +{ + if (m_Pointer != nullptr) + { + if (!m_Pointer->IsTicking() || (m_Pointer->GetWorld() != a_CurrentWorld)) + { + m_Pointer = nullptr; + } + } + return m_Pointer; +} diff --git a/src/Mobs/MobPointer.h b/src/Mobs/MobPointer.h new file mode 100644 index 000000000..3534d760d --- /dev/null +++ b/src/Mobs/MobPointer.h @@ -0,0 +1,35 @@ +#pragma once + +/** This class allows mobs to hold pointers to other mobs/players in a safe manner. +When calling GetPointer(), it first checks if the Monster/Player being pointed to is still valid. +If not, it returns a nullptr. The returned raw pointer must be used locally and then discarded. +it MUST NOT be preserved across ticks. +*/ + +class cPawn; +class cWorld; +class cMobPointer +{ +public: + cMobPointer(cPawn * a_Pointer); // Constructor + cMobPointer(const cMobPointer & a_MobPointer); // Copy constructor + cMobPointer(cMobPointer && a_MobPointer); // Move constructor + cMobPointer& operator=(const cMobPointer& a_MobPointer); // Copy assignment operator + cMobPointer& operator=(cMobPointer&& a_MobPointer); // Move assignment operator + + void SetPointer(cPawn * a_Pointer); // set Pointer + + /** Returns the raw pointer. The returned raw pointer must + be used locally and then discarded. it MUST NOT be preserved across ticks. + Returns null if raw pointer is null. Returns null if mob is destroyed or moved worlds. + Must be called at least once per tick, even if the raw pointer is not going to be used that tick. */ + cPawn * GetPointer(cWorld * a_CurrentWorld); + + +private: + cPawn * m_Pointer; +} ; + + + + diff --git a/src/Mobs/Monster.cpp b/src/Mobs/Monster.cpp index 0d433d861..fc1c1678d 100644 --- a/src/Mobs/Monster.cpp +++ b/src/Mobs/Monster.cpp @@ -19,6 +19,9 @@ #include "PathFinder.h" #include "../Entities/LeashKnot.h" +// Temporary pathfinder hack +#include "Behaviors/BehaviorDayLightBurner.h" + @@ -82,8 +85,10 @@ static const struct cMonster::cMonster(const AString & a_ConfigName, eMonsterType a_MobType, const AString & a_SoundHurt, const AString & a_SoundDeath, double a_Width, double a_Height) : super(etMonster, a_Width, a_Height) - , m_EMState(IDLE) + , m_BehaviorBreederPointer(nullptr) + , m_BehaviorAttackerPointer(nullptr) , m_EMPersonality(AGGRESSIVE) + , m_NearestPlayerIsStale(true) , m_PathFinder(a_Width, a_Height) , m_PathfinderActivated(false) , m_JumpCoolDown(0) @@ -94,10 +99,6 @@ cMonster::cMonster(const AString & a_ConfigName, eMonsterType a_MobType, const A , m_CustomNameAlwaysVisible(false) , m_SoundHurt(a_SoundHurt) , m_SoundDeath(a_SoundDeath) - , m_AttackRate(3) - , m_AttackDamage(1) - , m_AttackRange(1) - , m_AttackCoolDownTicksLeft(0) , m_SightDistance(25) , m_DropChanceWeapon(0.085f) , m_DropChanceHelmet(0.085f) @@ -105,8 +106,6 @@ cMonster::cMonster(const AString & a_ConfigName, eMonsterType a_MobType, const A , m_DropChanceLeggings(0.085f) , m_DropChanceBoots(0.085f) , m_CanPickUpLoot(true) - , m_TicksSinceLastDamaged(100) - , m_BurnsInDaylight(false) , m_RelativeWalkSpeed(1) , m_Age(1) , m_AgingTimer(20 * 60 * 20) // about 20 minutes @@ -115,7 +114,11 @@ cMonster::cMonster(const AString & a_ConfigName, eMonsterType a_MobType, const A , m_LeashToPos(nullptr) , m_IsLeashActionJustDone(false) , m_CanBeLeashed(GetMobFamily() == eFamily::mfPassive) - , m_Target(nullptr) + , m_LookingAt(nullptr) + , m_CurrentTickControllingBehavior(nullptr) + , m_NewTickControllingBehavior(nullptr) + , m_PinnedBehavior(nullptr) + , m_TickControllingBehaviorState(Normal) { if (!a_ConfigName.empty()) { @@ -129,7 +132,7 @@ cMonster::cMonster(const AString & a_ConfigName, eMonsterType a_MobType, const A cMonster::~cMonster() { - ASSERT(GetTarget() == nullptr); + } @@ -138,6 +141,9 @@ cMonster::~cMonster() void cMonster::Destroy(bool a_ShouldBroadcast) { + //mobtodo Destroy vs Destroyed + + // mobTodo behavior for leash if (IsLeashed()) { cEntity * LeashedTo = GetLeashedTo(); @@ -159,7 +165,11 @@ void cMonster::Destroy(bool a_ShouldBroadcast) void cMonster::Destroyed() { - SetTarget(nullptr); // Tell them we're no longer targeting them. + for (cBehavior * Behavior : m_AttachedDestroyBehaviors) + { + Behavior->Destroyed(); + } + super::Destroyed(); } @@ -183,6 +193,7 @@ void cMonster::SpawnOn(cClientHandle & a_Client) void cMonster::MoveToWayPoint(cChunk & a_Chunk) { + UNUSED(a_Chunk); if ((m_NextWayPointPosition - GetPosition()).SqrLength() < WAYPOINT_RADIUS * WAYPOINT_RADIUS) { return; @@ -282,6 +293,8 @@ void cMonster::StopMovingToPosition() void cMonster::Tick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) { + // LOGD("mobDebug - Monster tick begins"); + m_NearestPlayerIsStale = true; super::Tick(a_Dt, a_Chunk); if (!IsTicking()) { @@ -290,12 +303,6 @@ void cMonster::Tick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) } GET_AND_VERIFY_CURRENT_CHUNK(Chunk, POSX_TOINT, POSZ_TOINT); - ASSERT((GetTarget() == nullptr) || (GetTarget()->IsPawn() && (GetTarget()->GetWorld() == GetWorld()))); - if (m_AttackCoolDownTicksLeft > 0) - { - m_AttackCoolDownTicksLeft -= 1; - } - if (m_Health <= 0) { // The mob is dead, but we're still animating the "puff" they leave when they die @@ -307,26 +314,113 @@ void cMonster::Tick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) return; } - if (m_TicksSinceLastDamaged < 100) + // All behaviors can execute PostTick and PreTick. + // These are for bookkeeping or passive actions like laying eggs. + // They MUST NOT control mob movement or interefere with the main Tick. + for (cBehavior * Behavior : m_AttachedPreTickBehaviors) { - ++m_TicksSinceLastDamaged; + // LOGD("mobDebug - preTick"); + ASSERT(Behavior != nullptr); + Behavior->PreTick(a_Dt, a_Chunk); } - if ((GetTarget() != nullptr)) - { - ASSERT(GetTarget()->IsTicking()); - if (GetTarget()->IsPlayer()) + // Note 1: Each monster tick, at most one Behavior executes its Tick method. + // Note 2: Each monster tick, exactly one of these is executed: + // ControlStarting, Tick, ControlEnding + + // If we're in a regular tick cycle + if (m_TickControllingBehaviorState == Normal) + { + if (IsLeashed()) + { + // do not tick behaviors + // mobTodo temporary leash special case. Needs a behavior eventually. + } + else if (m_PinnedBehavior != nullptr) + { + // A behavior is pinned. We give it control automatically. + ASSERT(m_CurrentTickControllingBehavior == m_PinnedBehavior); + m_CurrentTickControllingBehavior->Tick(a_Dt, a_Chunk); + } + else { - if (!static_cast<cPlayer *>(GetTarget())->CanMobsTarget()) + // ask the behaviors sequentially if they are interested in controlling this mob + // Stop at the first one that says yes. + m_NewTickControllingBehavior = nullptr; + for (cBehavior * Behavior : m_AttachedTickBehaviors) { - SetTarget(nullptr); - m_EMState = IDLE; + if (Behavior->IsControlDesired(a_Dt, a_Chunk)) + { + m_NewTickControllingBehavior = Behavior; + break; + } + } + ASSERT(m_NewTickControllingBehavior != nullptr); // it's not OK if no one asks for control + if (m_CurrentTickControllingBehavior == m_NewTickControllingBehavior) + { + // The Behavior asking for control is the same as the behavior from last tick. + // Nothing special, just tick it. + // LOGD("mobDebug - Tick"); + m_CurrentTickControllingBehavior->Tick(a_Dt, a_Chunk); + } + else if (m_CurrentTickControllingBehavior == nullptr) + { + // first behavior to ever control + m_TickControllingBehaviorState = NewControlStarting; + } + else + { + // The behavior asking for control is not the same as the behavior from last tick. + // Begin the control swapping process. + m_TickControllingBehaviorState = OldControlEnding; } } + } - // Process the undead burning in daylight. - HandleDaylightBurning(*Chunk, WouldBurnAt(GetPosition(), *Chunk)); + // Make the current controlling behavior clean up + if (m_TickControllingBehaviorState == OldControlEnding) + { + ASSERT(m_CurrentTickControllingBehavior != nullptr); + if (m_CurrentTickControllingBehavior->ControlEnding(a_Dt, a_Chunk)) + { + // The current behavior told us it is ready for letting go of control + m_TickControllingBehaviorState = NewControlStarting; + } + else + { + // The current behavior is not ready for releasing control. We'll execute ControlEnding + // next tick too. + m_TickControllingBehaviorState = OldControlEnding; + } + } + // Make the new controlling behavior set up + else if (m_TickControllingBehaviorState == NewControlStarting) + { + ASSERT(m_NewTickControllingBehavior != nullptr); + if (m_NewTickControllingBehavior->ControlStarting(a_Dt, a_Chunk)) + { + // The new behavior told us it is ready for taking control + // The new behavior is now the current behavior. Next tick it will execute its Tick. + m_TickControllingBehaviorState = Normal; + m_CurrentTickControllingBehavior = m_NewTickControllingBehavior; + } + else + { + // The new behavior is not ready for taking control. + // We'll execute ControlStarting next tick too. + m_TickControllingBehaviorState = NewControlStarting; + } + } + + // All behaviors can execute PostTick and PreTick. + // These are for bookkeeping or passive actions like laying eggs. + // They MUST NOT control mob movement or interefere with the main Tick. + for (cBehavior * Behavior : m_AttachedPostTickBehaviors) + { + // LOGD("mobDebug - PostTick"); + Behavior->PostTick(a_Dt, a_Chunk); + } bool a_IsFollowingPath = false; if (m_PathfinderActivated) @@ -337,8 +431,9 @@ void cMonster::Tick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) } else { + // mobToDo fix dont care // Note that m_NextWayPointPosition is actually returned by GetNextWayPoint) - switch (m_PathFinder.GetNextWayPoint(*Chunk, GetPosition(), &m_FinalDestination, &m_NextWayPointPosition, m_EMState == IDLE ? true : false)) + switch (m_PathFinder.GetNextWayPoint(*Chunk, GetPosition(), &m_FinalDestination, &m_NextWayPointPosition, true)) { case ePathFinderStatus::PATH_FOUND: { @@ -347,9 +442,13 @@ void cMonster::Tick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) 2. I was not hurt by a player recently. Then STOP. */ if ( - m_BurnsInDaylight && ((m_TicksSinceLastDamaged >= 100) || (m_EMState == IDLE)) && - WouldBurnAt(m_NextWayPointPosition, *Chunk) && - !WouldBurnAt(GetPosition(), *Chunk) + //mobTodo emstate + /* (GetBehaviorDayLightBurner() != nullptr) && (m_TicksSinceLastDamaged >= 100) && + GetBehaviorDayLightBurner()->WouldBurnAt(m_NextWayPointPosition, *Chunk) && + !(GetBehaviorDayLightBurner()->WouldBurnAt(GetPosition(), *Chunk)) */ + 1 == 0 + + // This logic should probably be in chaser ) { // If we burn in daylight, and we would burn at the next step, and we won't burn where we are right now, and we weren't provoked recently: @@ -377,30 +476,10 @@ void cMonster::Tick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) SetPitchAndYawFromDestination(a_IsFollowingPath); - switch (m_EMState) - { - case IDLE: - { - // If enemy passive we ignore checks for player visibility. - InStateIdle(a_Dt, a_Chunk); - break; - } - case CHASING: - { - // If we do not see a player anymore skip chasing action. - InStateChasing(a_Dt, a_Chunk); - break; - } - case ESCAPING: - { - InStateEscaping(a_Dt, a_Chunk); - break; - } - case ATTACKING: break; - } // switch (m_EMState) - // Leash calculations - if ((m_TicksAlive % LEASH_ACTIONS_TICK_STEP) == 0) + if ((m_TickControllingBehaviorState == Normal) && + ((m_TicksAlive % LEASH_ACTIONS_TICK_STEP) == 0) + ) { CalcLeashActions(); } @@ -458,9 +537,10 @@ void cMonster::CalcLeashActions() void cMonster::SetPitchAndYawFromDestination(bool a_IsFollowingPath) { Vector3d BodyDistance; - if (!a_IsFollowingPath && (GetTarget() != nullptr)) + cPawn * LookingAt = m_LookingAt.GetPointer(GetWorld()); + if (!a_IsFollowingPath && (LookingAt != nullptr)) { - BodyDistance = GetTarget()->GetPosition() - GetPosition(); + BodyDistance = LookingAt->GetPosition() - GetPosition(); } else { @@ -472,15 +552,15 @@ void cMonster::SetPitchAndYawFromDestination(bool a_IsFollowingPath) SetYaw(BodyRotation); Vector3d HeadDistance; - if (GetTarget() != nullptr) + if (LookingAt != nullptr) { - if (GetTarget()->IsPlayer()) // Look at a player + if (LookingAt->IsPlayer()) // Look at a player { - HeadDistance = GetTarget()->GetPosition() - GetPosition(); + HeadDistance = LookingAt->GetPosition() - GetPosition(); } else // Look at some other entity { - HeadDistance = GetTarget()->GetPosition() - GetPosition(); + HeadDistance = LookingAt->GetPosition() - GetPosition(); // HeadDistance.y = GetTarget()->GetPosY() + GetHeight(); } } @@ -555,22 +635,18 @@ bool cMonster::DoTakeDamage(TakeDamageInfo & a_TDI) return false; } + if (!m_SoundHurt.empty() && (m_Health > 0)) { m_World->BroadcastSoundEffect(m_SoundHurt, GetPosX(), GetPosY(), GetPosZ(), 1.0f, 0.8f); } - if ((a_TDI.Attacker != nullptr) && a_TDI.Attacker->IsPawn()) + for (cBehavior * Behavior : m_AttachedDoTakeDamageBehaviors) { - if ( - (!a_TDI.Attacker->IsPlayer()) || - (static_cast<cPlayer *>(a_TDI.Attacker)->CanMobsTarget()) - ) - { - SetTarget(static_cast<cPawn*>(a_TDI.Attacker)); - } - m_TicksSinceLastDamaged = 0; + ASSERT(Behavior != nullptr); + Behavior->DoTakeDamage(a_TDI); } + return true; } @@ -661,6 +737,7 @@ void cMonster::OnRightClicked(cPlayer & a_Player) { super::OnRightClicked(a_Player); + // mobTodo put this in a behavior? const cItem & EquippedItem = a_Player.GetEquippedItem(); if ((EquippedItem.m_ItemType == E_ITEM_NAME_TAG) && !EquippedItem.m_CustomName.empty()) { @@ -671,6 +748,12 @@ void cMonster::OnRightClicked(cPlayer & a_Player) } } + for (cBehavior * Behavior : m_AttachedOnRightClickBehaviors) + { + Behavior->OnRightClicked(a_Player); + } + + // mobTodo put this in a behavior? // Using leashes m_IsLeashActionJustDone = false; if (IsLeashed() && (GetLeashedTo() == &a_Player)) // a player can only unleash a mob leashed to him @@ -696,159 +779,6 @@ void cMonster::OnRightClicked(cPlayer & a_Player) -// Checks to see if EventSeePlayer should be fired -// monster sez: Do I see the player -void cMonster::CheckEventSeePlayer(cChunk & a_Chunk) -{ - // TODO: Rewrite this to use cWorld's DoWithPlayers() - cPlayer * Closest = m_World->FindClosestPlayer(GetPosition(), static_cast<float>(m_SightDistance), false); - - if (Closest != nullptr) - { - EventSeePlayer(Closest, a_Chunk); - } -} - - - - - -void cMonster::CheckEventLostPlayer(void) -{ - if (GetTarget() != nullptr) - { - if ((GetTarget()->GetPosition() - GetPosition()).Length() > m_SightDistance) - { - EventLosePlayer(); - } - } - else - { - EventLosePlayer(); - } -} - - - - - -// What to do if player is seen -// default to change state to chasing -void cMonster::EventSeePlayer(cPlayer * a_SeenPlayer, cChunk & a_Chunk) -{ - UNUSED(a_Chunk); - SetTarget(a_SeenPlayer); -} - - - - - -void cMonster::EventLosePlayer(void) -{ - SetTarget(nullptr); - m_EMState = IDLE; -} - - - - - -void cMonster::InStateIdle(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) -{ - if (m_PathfinderActivated) - { - return; // Still getting there - } - - m_IdleInterval += a_Dt; - - if (m_IdleInterval > std::chrono::seconds(1)) - { - auto & Random = GetRandomProvider(); - - // At this interval the results are predictable - int rem = Random.RandInt(1, 7); - m_IdleInterval -= std::chrono::seconds(1); // So nothing gets dropped when the server hangs for a few seconds - - Vector3d Dist; - Dist.x = static_cast<double>(Random.RandInt(-5, 5)); - Dist.z = static_cast<double>(Random.RandInt(-5, 5)); - - if ((Dist.SqrLength() > 2) && (rem >= 3)) - { - - Vector3d Destination(GetPosX() + Dist.x, GetPosition().y, GetPosZ() + Dist.z); - - cChunk * Chunk = a_Chunk.GetNeighborChunk(static_cast<int>(Destination.x), static_cast<int>(Destination.z)); - if ((Chunk == nullptr) || !Chunk->IsValid()) - { - return; - } - - BLOCKTYPE BlockType; - NIBBLETYPE BlockMeta; - int RelX = static_cast<int>(Destination.x) - Chunk->GetPosX() * cChunkDef::Width; - int RelZ = static_cast<int>(Destination.z) - Chunk->GetPosZ() * cChunkDef::Width; - int YBelowUs = static_cast<int>(Destination.y) - 1; - if (YBelowUs >= 0) - { - Chunk->GetBlockTypeMeta(RelX, YBelowUs, RelZ, BlockType, BlockMeta); - if (BlockType != E_BLOCK_STATIONARY_WATER) // Idle mobs shouldn't enter water on purpose - { - MoveToPosition(Destination); - } - } - } - } -} - - - - - -// What to do if in Chasing State -// This state should always be defined in each child class -void cMonster::InStateChasing(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) -{ - UNUSED(a_Dt); -} - - - - - -// What to do if in Escaping State -void cMonster::InStateEscaping(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) -{ - UNUSED(a_Dt); - - if (GetTarget() != nullptr) - { - Vector3d newloc = GetPosition(); - newloc.x = (GetTarget()->GetPosition().x < newloc.x)? (newloc.x + m_SightDistance): (newloc.x - m_SightDistance); - newloc.z = (GetTarget()->GetPosition().z < newloc.z)? (newloc.z + m_SightDistance): (newloc.z - m_SightDistance); - MoveToPosition(newloc); - } - else - { - m_EMState = IDLE; // This shouldnt be required but just to be safe - } -} - - - - - -void cMonster::ResetAttackCooldown() -{ - m_AttackCoolDownTicksLeft = static_cast<int>(3 * 20 * m_AttackRate); // A second has 20 ticks, an attack rate of 1 means 1 hit every 3 seconds -} - - - - - void cMonster::SetCustomName(const AString & a_CustomName) { m_CustomName = a_CustomName; @@ -1064,16 +994,19 @@ int cMonster::GetSpawnDelay(cMonster::eFamily a_MobFamily) -/** Sets the target. */ -void cMonster::SetTarget (cPawn * a_NewTarget) + +void cMonster::SetLookingAt(cPawn * a_NewTarget) { + m_LookingAt.SetPointer(a_NewTarget); + + /* ASSERT((a_NewTarget == nullptr) || (IsTicking())); - if (m_Target == a_NewTarget) + if (m_LookingAt == a_NewTarget) { return; } - cPawn * OldTarget = m_Target; - m_Target = a_NewTarget; + cPawn * OldTarget = m_LookingAt; + m_LookingAt = a_NewTarget; if (OldTarget != nullptr) { @@ -1087,26 +1020,91 @@ void cMonster::SetTarget (cPawn * a_NewTarget) // Notify the new target that we are now targeting it. m_Target->TargetingMe(this); m_WasLastTargetAPlayer = m_Target->IsPlayer(); - } + }*/ } +bool cMonster::IsPathFinderActivated() const +{ + return m_PathfinderActivated; +} + -void cMonster::UnsafeUnsetTarget() + + + +cBehaviorBreeder * cMonster::GetBehaviorBreeder() { - m_Target = nullptr; + return m_BehaviorBreederPointer; } -cPawn * cMonster::GetTarget() +const cBehaviorBreeder * cMonster::GetBehaviorBreeder() const { - return m_Target; + return static_cast<const cBehaviorBreeder *>(m_BehaviorBreederPointer); +} + + + + + +cBehaviorAttacker * cMonster::GetBehaviorAttacker() +{ + return m_BehaviorAttackerPointer; +} + + + + + +void cMonster::InheritFromParents(cMonster * a_Parent1, cMonster * a_Parent2) +{ + UNUSED(a_Parent1); + UNUSED(a_Parent2); + return; +} + + + + + +void cMonster::GetFollowedItems(cItems & a_Items) +{ + return; +} + + + + + +void cMonster::GetBreedingItems(cItems & a_Items) +{ + return GetFollowedItems(a_Items); +} + + + + + +cPlayer * cMonster::GetNearestPlayer() +{ + if (m_NearestPlayerIsStale) + { + // TODO: Rewrite this to use cWorld's DoWithPlayers() + m_NearestPlayer = GetWorld()->FindClosestPlayer(GetPosition(), static_cast<float>(GetSightDistance())); + m_NearestPlayerIsStale = false; + } + if ((m_NearestPlayer != nullptr) && (!m_NearestPlayer->IsTicking())) + { + m_NearestPlayer = nullptr; + } + return m_NearestPlayer; } @@ -1300,98 +1298,80 @@ void cMonster::AddRandomWeaponDropItem(cItems & a_Drops, unsigned int a_LootingL +void cMonster::AttachPreTickBehavior(cBehavior * a_Behavior) +{ + ASSERT(a_Behavior != nullptr); + m_AttachedPreTickBehaviors.push_back(a_Behavior); +} + + + -void cMonster::HandleDaylightBurning(cChunk & a_Chunk, bool WouldBurn) +void cMonster::AttachPostTickBehavior(cBehavior * a_Behavior) { - if (!m_BurnsInDaylight) - { - return; - } + ASSERT(a_Behavior != nullptr); + m_AttachedPostTickBehaviors.push_back(a_Behavior); +} - int RelY = POSY_TOINT; - if ((RelY < 0) || (RelY >= cChunkDef::Height)) - { - // Outside the world - return; - } - if (!a_Chunk.IsLightValid()) - { - m_World->QueueLightChunk(GetChunkX(), GetChunkZ()); - return; - } - if (!IsOnFire() && WouldBurn) - { - // Burn for 100 ticks, then decide again - StartBurning(100); - } + + + +void cMonster::AttachTickBehavior(cBehavior * a_Behavior) +{ + ASSERT(a_Behavior != nullptr); + m_AttachedTickBehaviors.push_back(a_Behavior); } -bool cMonster::WouldBurnAt(Vector3d a_Location, cChunk & a_Chunk) + +void cMonster::AttachDestroyBehavior(cBehavior * a_Behavior) { - // If the Y coord is out of range, return the most logical result without considering anything else: - int RelY = FloorC(a_Location.y); - if (RelY < 0) - { - // Never burn under the world - return false; - } - if (RelY >= cChunkDef::Height) - { - // Always burn above the world - return true; - } - if (RelY <= 0) - { - // The mob is about to die, no point in burning - return false; - } + ASSERT(a_Behavior != nullptr); + m_AttachedDestroyBehaviors.push_back(a_Behavior); +} - PREPARE_REL_AND_CHUNK(a_Location, a_Chunk); - if (!RelSuccess) - { - return false; - } - if ( - (Chunk->GetBlock(Rel.x, Rel.y, Rel.z) != E_BLOCK_SOULSAND) && // Not on soulsand - (GetWorld()->GetTimeOfDay() < 12000 + 1000) && // Daytime - GetWorld()->IsWeatherSunnyAt(POSX_TOINT, POSZ_TOINT) // Not raining - ) - { - int MobHeight = CeilC(a_Location.y + GetHeight()) - 1; // The block Y coord of the mob's head - if (MobHeight >= cChunkDef::Height) - { - return true; - } - // Start with the highest block and scan down to just above the mob's head. - // If a non transparent is found, return false (do not burn). Otherwise return true. - // Note that this loop is not a performance concern as transparent blocks are rare and the loop almost always bailes out - // instantly.(An exception is e.g. standing under a long column of glass). - int CurrentBlock = Chunk->GetHeight(Rel.x, Rel.z); - while (CurrentBlock > MobHeight) - { - BLOCKTYPE Block = Chunk->GetBlock(Rel.x, CurrentBlock, Rel.z); - if ( - // Do not burn if a block above us meets one of the following conditions: - (!cBlockInfo::IsTransparent(Block)) || - (Block == E_BLOCK_LEAVES) || - (Block == E_BLOCK_NEW_LEAVES) || - (IsBlockWater(Block)) - ) - { - return false; - } - --CurrentBlock; - } - return true; - } - return false; + + +void cMonster::AttachRightClickBehavior(cBehavior * a_Behavior) +{ + ASSERT(a_Behavior != nullptr); + m_AttachedOnRightClickBehaviors.push_back(a_Behavior); +} + + + + + +void cMonster::AttachDoTakeDamageBehavior(cBehavior * a_Behavior) +{ + m_AttachedDoTakeDamageBehaviors.push_back(a_Behavior); +} + + + + +void cMonster::PinBehavior(cBehavior * a_Behavior) +{ + ASSERT(m_TickControllingBehaviorState == Normal); + m_PinnedBehavior = a_Behavior; + ASSERT(m_CurrentTickControllingBehavior == m_PinnedBehavior); +} + + + + + +void cMonster::UnpinBehavior(cBehavior * a_Behavior) +{ + ASSERT(m_TickControllingBehaviorState == Normal); + ASSERT(m_PinnedBehavior = a_Behavior); + m_PinnedBehavior = nullptr; } diff --git a/src/Mobs/Monster.h b/src/Mobs/Monster.h index 1f6bd6011..1ed443aad 100644 --- a/src/Mobs/Monster.h +++ b/src/Mobs/Monster.h @@ -4,12 +4,23 @@ #include "../Entities/Pawn.h" #include "MonsterTypes.h" #include "PathFinder.h" - +#include "Behaviors/BehaviorWanderer.h" +#include "MobPointer.h" +#include <vector> class cItem; class cClientHandle; +//Behavior fwds +class cPassiveMonster; +class cBehaviorAggressive; +class cBehaviorBreeder; +class cBehaviorAttacker; +class cBehaviorStriker; +class cBehaviorWanderer; +class cBehaviorDayLightBurner; +class cBehavior; // tolua_begin class cMonster : @@ -31,7 +42,6 @@ public: // tolua_end - enum MState{ATTACKING, IDLE, CHASING, ESCAPING} m_EMState; enum MPersonality{PASSIVE, AGGRESSIVE, COWARDLY} m_EMPersonality; /** Creates the mob object. @@ -69,9 +79,6 @@ public: eFamily GetMobFamily(void) const; // tolua_end - virtual void CheckEventSeePlayer(cChunk & a_Chunk); - virtual void EventSeePlayer(cPlayer * a_Player, cChunk & a_Chunk); - // tolua_begin /** Returns whether the mob can be leashed. */ @@ -109,18 +116,8 @@ public: /** Returns whether this mob is undead (skeleton, zombie, etc.) */ 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; } + int GetSightDistance() { return m_SightDistance; } float GetDropChanceWeapon() { return m_DropChanceWeapon; } float GetDropChanceHelmet() { return m_DropChanceHelmet; } @@ -134,10 +131,6 @@ public: 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(); - - /** Sets whether the mob burns in daylight. Only evaluated at next burn-decision tick */ - void SetBurnsInDaylight(bool a_BurnsInDaylight) { m_BurnsInDaylight = a_BurnsInDaylight; } double GetRelativeWalkSpeed(void) const { return m_RelativeWalkSpeed; } // tolua_export void SetRelativeWalkSpeed(double a_WalkSpeed) { m_RelativeWalkSpeed = a_WalkSpeed; } // tolua_export @@ -193,14 +186,7 @@ public: static AString MobTypeToVanillaNBT(eMonsterType a_MobType); /** Sets the target that this mob will chase. Pass a nullptr to unset. */ - void SetTarget (cPawn * a_NewTarget); - - /** Unset the target without notifying the target entity. Do not use this, use SetTarget(nullptr) instead. - This is only used by cPawn internally. */ - void UnsafeUnsetTarget(); - - /** Returns the current target. */ - cPawn * GetTarget(); + void SetLookingAt(cPawn * a_NewTarget); /** Creates a new object of the specified mob. a_MobType is the type of the mob to be created @@ -211,7 +197,39 @@ public: /** Returns if this mob last target was a player to avoid destruction on player quit */ bool WasLastTargetAPlayer() const { return m_WasLastTargetAPlayer; } -protected: + bool IsPathFinderActivated() const; + + // Behavior getters (most are probably not used. mobTodo - cleanup most of them) + cBehaviorBreeder * GetBehaviorBreeder(); + const cBehaviorBreeder * GetBehaviorBreeder() const; + cBehaviorAttacker * GetBehaviorAttacker();\ + cBehaviorBreeder * m_BehaviorBreederPointer; + cBehaviorAttacker * m_BehaviorAttackerPointer; + + // Polymorphic behavior functions + virtual void InheritFromParents(cMonster * a_Parent1, cMonster * a_Parent2); + virtual void GetFollowedItems(cItems & a_Items); + virtual void GetBreedingItems(cItems & a_Items); + + cPlayer * GetNearestPlayer(); + + // These should only be called from cBehavior::attachToMonster + void AttachPreTickBehavior(cBehavior * a_Behavior); + void AttachPostTickBehavior(cBehavior * a_Behavior); + void AttachTickBehavior(cBehavior * a_Behavior); + void AttachDestroyBehavior(cBehavior * a_Behavior); + void AttachRightClickBehavior(cBehavior * a_Behavior); + void AttachDoTakeDamageBehavior(cBehavior * a_Behavior); + + void PinBehavior(cBehavior * a_Behavior); + void UnpinBehavior(cBehavior * a_Behavior); + protected: + + /** Whether or not m_NearestPlayer is stale. Always true at the beginning of a tick. + When true, GetNearestPlayer() actually searches for a player, updates m_NearestPlayer, and sets it to false. + otherwise it returns m_NearestPlayer. This means we only perform 1 search per tick. */ + bool m_NearestPlayerIsStale; + cPlayer * m_NearestPlayer; /** The pathfinder instance handles pathfinding for this monster. */ cPathFinder m_PathFinder; @@ -234,13 +252,6 @@ protected: /** Returns if the ultimate, final destination has been reached. */ bool ReachedFinalDestination(void) { return ((m_FinalDestination - GetPosition()).SqrLength() < WAYPOINT_RADIUS * WAYPOINT_RADIUS); } - /** Returns whether or not the target is close enough for attack. */ - bool TargetIsInRange(void) - { - ASSERT(GetTarget() != nullptr); - return ((GetTarget()->GetPosition() - GetPosition()).SqrLength() < (m_AttackRange * m_AttackRange)); - } - /** Returns whether the monster needs to jump to reach a given height. */ inline bool DoesPosYRequireJump(double a_PosY) { @@ -268,11 +279,7 @@ protected: AString m_SoundHurt; AString m_SoundDeath; - float m_AttackRate; - int m_AttackDamage; - int m_AttackRange; - int m_AttackCoolDownTicksLeft; - int m_SightDistance; + int m_SightDistance; // mobTodo what to do with this? float m_DropChanceWeapon; float m_DropChanceHelmet; @@ -280,11 +287,7 @@ protected: 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; @@ -320,12 +323,22 @@ protected: void AddRandomWeaponDropItem(cItems & a_Drops, unsigned int a_LootingLevel); private: - /** A pointer to the entity this mobile is aiming to reach. - The validity of this pointer SHALL be guaranteed by the pointee; - it MUST be reset when the pointee changes worlds or is destroyed. */ - cPawn * m_Target; + /** A pointer to the entity this mobile is lookingAt */ + cMobPointer m_LookingAt; /** Leash calculations inside Tick function */ void CalcLeashActions(); + std::vector<cBehavior*> m_AttachedPreTickBehaviors; + std::vector<cBehavior*> m_AttachedTickBehaviors; + std::vector<cBehavior*> m_AttachedPostTickBehaviors; + std::vector<cBehavior*> m_AttachedDestroyBehaviors; + std::vector<cBehavior*> m_AttachedOnRightClickBehaviors; + std::vector<cBehavior*> m_AttachedDoTakeDamageBehaviors; + + cBehavior * m_CurrentTickControllingBehavior; + cBehavior * m_NewTickControllingBehavior; + cBehavior * m_PinnedBehavior; + enum TickState{NewControlStarting, OldControlEnding, Normal} m_TickControllingBehaviorState; + } ; // tolua_export diff --git a/src/Mobs/Mooshroom.cpp b/src/Mobs/Mooshroom.cpp index b6feca76e..91baaee66 100644 --- a/src/Mobs/Mooshroom.cpp +++ b/src/Mobs/Mooshroom.cpp @@ -16,6 +16,11 @@ cMooshroom::cMooshroom(void) : super("Mooshroom", mtMooshroom, "entity.cow.hurt", "entity.cow.death", 0.9, 1.3) { + m_EMPersonality = PASSIVE; + m_BehaviorBreeder.AttachToMonster(*this); + m_BehaviorCoward.AttachToMonster(*this); + m_BehaviorItemFollower.AttachToMonster(*this); + m_BehaviorWanderer.AttachToMonster(*this); } @@ -39,6 +44,7 @@ void cMooshroom::GetDrops(cItems & a_Drops, cEntity * a_Killer) void cMooshroom::OnRightClicked(cPlayer & a_Player) { + // mobTodo Behaviors switch (a_Player.GetEquippedItem().m_ItemType) { case E_ITEM_BUCKET: @@ -72,4 +78,3 @@ void cMooshroom::OnRightClicked(cPlayer & a_Player) } break; } } - diff --git a/src/Mobs/Mooshroom.h b/src/Mobs/Mooshroom.h index 625963190..06e5cf8ce 100644 --- a/src/Mobs/Mooshroom.h +++ b/src/Mobs/Mooshroom.h @@ -1,16 +1,20 @@ #pragma once -#include "PassiveMonster.h" +#include "Behaviors/BehaviorBreeder.h" +#include "Behaviors/BehaviorItemFollower.h" +#include "Behaviors/BehaviorCoward.h" +#include "Behaviors/BehaviorWanderer.h" +#include "Monster.h" class cMooshroom : - public cPassiveMonster + public cMonster { - typedef cPassiveMonster super; + typedef cMonster super; public: cMooshroom(void); @@ -24,6 +28,12 @@ public: { a_Items.Add(E_ITEM_WHEAT); } +private: + // Tick controlling behaviors + cBehaviorBreeder m_BehaviorBreeder; + cBehaviorItemFollower m_BehaviorItemFollower; + cBehaviorCoward m_BehaviorCoward; + cBehaviorWanderer m_BehaviorWanderer; } ; diff --git a/src/Mobs/Ocelot.cpp b/src/Mobs/Ocelot.cpp index e5004a1d1..e89b18186 100644 --- a/src/Mobs/Ocelot.cpp +++ b/src/Mobs/Ocelot.cpp @@ -20,6 +20,7 @@ cOcelot::cOcelot(void) : m_CatType(ctWildOcelot), m_OwnerName("") { + m_EMPersonality = PASSIVE; } diff --git a/src/Mobs/Ocelot.h b/src/Mobs/Ocelot.h index 75758a973..d27467683 100644 --- a/src/Mobs/Ocelot.h +++ b/src/Mobs/Ocelot.h @@ -1,7 +1,7 @@ #pragma once -#include "PassiveMonster.h" +#include "Monster.h" #include "../UUID.h" @@ -9,9 +9,9 @@ class cOcelot : - public cPassiveMonster + public cMonster { - typedef cPassiveMonster super; + typedef cMonster super; public: diff --git a/src/Mobs/PassiveAggressiveMonster.cpp b/src/Mobs/PassiveAggressiveMonster.cpp deleted file mode 100644 index 8715ba9c2..000000000 --- a/src/Mobs/PassiveAggressiveMonster.cpp +++ /dev/null @@ -1,48 +0,0 @@ - -#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules - -#include "PassiveAggressiveMonster.h" - -#include "../Entities/Player.h" - - - - - -cPassiveAggressiveMonster::cPassiveAggressiveMonster(const AString & a_ConfigName, eMonsterType a_MobType, const AString & a_SoundHurt, const AString & a_SoundDeath, double a_Width, double a_Height) : - super(a_ConfigName, a_MobType, a_SoundHurt, a_SoundDeath, a_Width, a_Height) -{ - m_EMPersonality = PASSIVE; -} - - - - - -bool cPassiveAggressiveMonster::DoTakeDamage(TakeDamageInfo & a_TDI) -{ - if (!super::DoTakeDamage(a_TDI)) - { - return false; - } - - if ((GetTarget() != nullptr) && (GetTarget()->IsPlayer())) - { - if (static_cast<cPlayer *>(GetTarget())->CanMobsTarget()) - { - m_EMState = CHASING; - } - } - return true; -} - - - - - -void cPassiveAggressiveMonster::EventSeePlayer(cPlayer *, cChunk & a_Chunk) -{ - // don't do anything, neutral mobs don't react to just seeing the player -} - - diff --git a/src/Mobs/PassiveAggressiveMonster.h b/src/Mobs/PassiveAggressiveMonster.h deleted file mode 100644 index 764e27779..000000000 --- a/src/Mobs/PassiveAggressiveMonster.h +++ /dev/null @@ -1,24 +0,0 @@ - -#pragma once - -#include "AggressiveMonster.h" - - - - - -class cPassiveAggressiveMonster : - public cAggressiveMonster -{ - typedef cAggressiveMonster super; - -public: - cPassiveAggressiveMonster(const AString & a_ConfigName, eMonsterType a_MobType, const AString & a_SoundHurt, const AString & a_SoundDeath, double a_Width, double a_Height); - - virtual bool DoTakeDamage(TakeDamageInfo & a_TDI) override; - virtual void EventSeePlayer(cPlayer *, cChunk & a_Chunk) override; -} ; - - - - diff --git a/src/Mobs/PassiveMonster.cpp b/src/Mobs/PassiveMonster.cpp deleted file mode 100644 index a2089e13f..000000000 --- a/src/Mobs/PassiveMonster.cpp +++ /dev/null @@ -1,263 +0,0 @@ - -#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules - -#include "PassiveMonster.h" -#include "../World.h" -#include "../Entities/Player.h" -#include "BoundingBox.h" -#include "../Items/ItemSpawnEgg.h" - - - - -cPassiveMonster::cPassiveMonster(const AString & a_ConfigName, eMonsterType a_MobType, const AString & a_SoundHurt, const AString & a_SoundDeath, double a_Width, double a_Height) : - super(a_ConfigName, a_MobType, a_SoundHurt, a_SoundDeath, a_Width, a_Height), - m_LovePartner(nullptr), - m_LoveTimer(0), - m_LoveCooldown(0), - m_MatingTimer(0) -{ - m_EMPersonality = PASSIVE; -} - - - - - -bool cPassiveMonster::DoTakeDamage(TakeDamageInfo & a_TDI) -{ - if (!super::DoTakeDamage(a_TDI)) - { - return false; - } - if ((a_TDI.Attacker != this) && (a_TDI.Attacker != nullptr)) - { - m_EMState = ESCAPING; - } - return true; -} - - - - - -void cPassiveMonster::EngageLoveMode(cPassiveMonster * a_Partner) -{ - m_LovePartner = a_Partner; - m_MatingTimer = 50; // about 3 seconds of mating -} - - - - - -void cPassiveMonster::ResetLoveMode() -{ - m_LovePartner = nullptr; - m_LoveTimer = 0; - m_MatingTimer = 0; - m_LoveCooldown = 20 * 60 * 5; // 5 minutes - - // when an animal is in love mode, the client only stops sending the hearts if we let them know it's in cooldown, which is done with the "age" metadata - m_World->BroadcastEntityMetadata(*this); -} - - - - - -void cPassiveMonster::Destroyed() -{ - if (m_LovePartner != nullptr) - { - m_LovePartner->ResetLoveMode(); - } - super::Destroyed(); -} - - - - - -void cPassiveMonster::Tick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) -{ - super::Tick(a_Dt, a_Chunk); - if (!IsTicking()) - { - // The base class tick destroyed us - return; - } - - if (m_EMState == ESCAPING) - { - CheckEventLostPlayer(); - } - - // if we have a partner, mate - if (m_LovePartner != nullptr) - { - - if (m_MatingTimer > 0) - { - // If we should still mate, keep bumping into them until baby is made - Vector3d Pos = m_LovePartner->GetPosition(); - MoveToPosition(Pos); - } - else - { - // Mating finished. Spawn baby - Vector3f Pos = (GetPosition() + m_LovePartner->GetPosition()) * 0.5; - UInt32 BabyID = m_World->SpawnMob(Pos.x, Pos.y, Pos.z, GetMobType(), true); - - class cBabyInheritCallback : - public cEntityCallback - { - public: - cPassiveMonster * Baby; - cBabyInheritCallback() : Baby(nullptr) { } - virtual bool Item(cEntity * a_Entity) override - { - Baby = static_cast<cPassiveMonster *>(a_Entity); - return true; - } - } Callback; - - m_World->DoWithEntityByID(BabyID, Callback); - if (Callback.Baby != nullptr) - { - Callback.Baby->InheritFromParents(this, m_LovePartner); - } - - m_World->SpawnExperienceOrb(Pos.x, Pos.y, Pos.z, GetRandomProvider().RandInt(1, 6)); - - m_LovePartner->ResetLoveMode(); - ResetLoveMode(); - } - } - else - { - // We have no partner, so we just chase the player if they have our breeding item - cItems FollowedItems; - GetFollowedItems(FollowedItems); - if (FollowedItems.Size() > 0) - { - cPlayer * a_Closest_Player = m_World->FindClosestPlayer(GetPosition(), static_cast<float>(m_SightDistance)); - if (a_Closest_Player != nullptr) - { - cItem EquippedItem = a_Closest_Player->GetEquippedItem(); - if (FollowedItems.ContainsType(EquippedItem)) - { - Vector3d PlayerPos = a_Closest_Player->GetPosition(); - MoveToPosition(PlayerPos); - } - } - } - } - - // If we are in love mode but we have no partner, search for a partner neabry - if (m_LoveTimer > 0) - { - if (m_LovePartner == nullptr) - { - class LookForLover : public cEntityCallback - { - public: - cEntity * m_Me; - - LookForLover(cEntity * a_Me) : - m_Me(a_Me) - { - } - - virtual bool Item(cEntity * a_Entity) override - { - // If the entity is not a monster, don't breed with it - // Also, do not self-breed - if ((a_Entity->GetEntityType() != etMonster) || (a_Entity == m_Me)) - { - return false; - } - - cPassiveMonster * Me = static_cast<cPassiveMonster*>(m_Me); - cPassiveMonster * PotentialPartner = static_cast<cPassiveMonster*>(a_Entity); - - // If the potential partner is not of the same species, don't breed with it - if (PotentialPartner->GetMobType() != Me->GetMobType()) - { - return false; - } - - // If the potential partner is not in love - // Or they already have a mate, do not breed with them - if ((!PotentialPartner->IsInLove()) || (PotentialPartner->GetPartner() != nullptr)) - { - return false; - } - - // All conditions met, let's breed! - PotentialPartner->EngageLoveMode(Me); - Me->EngageLoveMode(PotentialPartner); - return true; - } - } Callback(this); - - m_World->ForEachEntityInBox(cBoundingBox(GetPosition(), 8, 8, -4), Callback); - } - - m_LoveTimer--; - } - if (m_MatingTimer > 0) - { - m_MatingTimer--; - } - if (m_LoveCooldown > 0) - { - m_LoveCooldown--; - } -} - - - - - -void cPassiveMonster::OnRightClicked(cPlayer & a_Player) -{ - super::OnRightClicked(a_Player); - - const cItem & EquippedItem = a_Player.GetEquippedItem(); - - // If a player holding breeding items right-clicked me, go into love mode - if ((m_LoveCooldown == 0) && !IsInLove() && !IsBaby()) - { - cItems Items; - GetBreedingItems(Items); - if (Items.ContainsType(EquippedItem.m_ItemType)) - { - if (!a_Player.IsGameModeCreative()) - { - a_Player.GetInventory().RemoveOneEquippedItem(); - } - m_LoveTimer = 20 * 30; // half a minute - m_World->BroadcastEntityStatus(*this, esMobInLove); - } - } - // If a player holding my spawn egg right-clicked me, spawn a new baby - if (EquippedItem.m_ItemType == E_ITEM_SPAWN_EGG) - { - eMonsterType MonsterType = cItemSpawnEggHandler::ItemDamageToMonsterType(EquippedItem.m_ItemDamage); - if ( - (MonsterType == m_MobType) && - (m_World->SpawnMob(GetPosX(), GetPosY(), GetPosZ(), m_MobType, true) != cEntity::INVALID_ID) // Spawning succeeded - ) - { - if (!a_Player.IsGameModeCreative()) - { - // The mob was spawned, "use" the item: - a_Player.GetInventory().RemoveOneEquippedItem(); - } - } - } -} - - - diff --git a/src/Mobs/PassiveMonster.h b/src/Mobs/PassiveMonster.h deleted file mode 100644 index 9a2627417..000000000 --- a/src/Mobs/PassiveMonster.h +++ /dev/null @@ -1,66 +0,0 @@ - -#pragma once - -#include "Monster.h" - - - - - -class cPassiveMonster : - public cMonster -{ - typedef cMonster super; - -public: - cPassiveMonster(const AString & a_ConfigName, eMonsterType a_MobType, const AString & a_SoundHurt, const AString & a_SoundDeath, double a_Width, double a_Height); - - virtual void Tick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) override; - virtual void OnRightClicked(cPlayer & a_Player) override; - - /** When hit by someone, run away */ - virtual bool DoTakeDamage(TakeDamageInfo & a_TDI) override; - - /** Returns the items that the animal of this class follows when a player holds it in hand. */ - virtual void GetFollowedItems(cItems & a_Items) { } - - /** Returns the items that make the animal breed - this is usually the same as the ones that make the animal follow, but not necessarily. */ - virtual void GetBreedingItems(cItems & a_Items) { GetFollowedItems(a_Items); } - - /** Called after the baby is born, allows the baby to inherit the parents' properties (color, etc.) */ - virtual void InheritFromParents(cPassiveMonster * a_Parent1, cPassiveMonster * a_Parent2) { } - - /** Returns the partner which the monster is currently mating with. */ - cPassiveMonster * GetPartner(void) const { return m_LovePartner; } - - /** Start the mating process. Causes the monster to keep bumping into the partner until m_MatingTimer reaches zero. */ - void EngageLoveMode(cPassiveMonster * a_Partner); - - /** Finish the mating process. Called after a baby is born. Resets all breeding related timers and sets m_LoveCooldown to 20 minutes. */ - void ResetLoveMode(); - - /** Returns whether the monster has just been fed and is ready to mate. If this is "true" and GetPartner isn't "nullptr", then the monster is mating. */ - bool IsInLove() const { return (m_LoveTimer > 0); } - - /** Returns whether the monster is tired of breeding and is in the cooldown state. */ - bool IsInLoveCooldown() const { return (m_LoveCooldown > 0); } - - virtual void Destroyed(void) override; - -protected: - /** The monster's breeding partner. */ - cPassiveMonster * m_LovePartner; - - /** If above 0, the monster is in love mode, and will breed if a nearby monster is also in love mode. Decrements by 1 per tick till reaching zero. */ - int m_LoveTimer; - - /** If above 0, the monster is in cooldown mode and will refuse to breed. Decrements by 1 per tick till reaching zero. */ - int m_LoveCooldown; - - /** The monster is engaged in mating, once this reaches zero, a baby will be born. Decrements by 1 per tick till reaching zero, then a baby is made and ResetLoveMode() is called. */ - int m_MatingTimer; -}; - - - - diff --git a/src/Mobs/Path.h b/src/Mobs/Path.h index 977c5be1c..40e1de6f0 100644 --- a/src/Mobs/Path.h +++ b/src/Mobs/Path.h @@ -10,7 +10,7 @@ class cPath; #include "../FastRandom.h" #ifdef COMPILING_PATHFIND_DEBUGGER - /* Note: the COMPILING_PATHFIND_DEBUGGER flag is used by Native / WiseOldMan95 to debug + /* Note: the COMPILING_PATHFIND_DEBUGGER flag is used by LogicParrot to debug this class outside of Cuberite. This preprocessor flag is never set when compiling Cuberite. */ #include "PathFinderIrrlicht_Head.h" #endif diff --git a/src/Mobs/Pig.cpp b/src/Mobs/Pig.cpp index 82901b061..ce5e9dca0 100644 --- a/src/Mobs/Pig.cpp +++ b/src/Mobs/Pig.cpp @@ -13,6 +13,11 @@ cPig::cPig(void) : super("Pig", mtPig, "entity.pig.hurt", "entity.pig.death", 0.9, 0.9), m_bIsSaddled(false) { + m_EMPersonality = PASSIVE; + m_BehaviorBreeder.AttachToMonster(*this); + m_BehaviorCoward.AttachToMonster(*this); + m_BehaviorItemFollower.AttachToMonster(*this); + m_BehaviorWanderer.AttachToMonster(*this); } @@ -41,6 +46,9 @@ void cPig::OnRightClicked(cPlayer & a_Player) { super::OnRightClicked(a_Player); + // Behavior note: saddling is pig-specific. It is not transferrable to other mobs. + // Therefore saddling is not a standalone behavior and is hardcoded into the pig. + if (m_bIsSaddled) { if (m_Attachee != nullptr) @@ -91,6 +99,9 @@ void cPig::Tick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) return; } + // Behavior note: saddling is pig-specific. It is not transferrable to other mobs. + // Therefore saddling is not a standalone behavior and is hardcoded into the pig. + // If the attachee player is holding a carrot-on-stick, let them drive this pig: if (m_bIsSaddled && (m_Attachee != nullptr)) { @@ -120,7 +131,3 @@ bool cPig::DoTakeDamage(TakeDamageInfo & a_TDI) } return true; } - - - - diff --git a/src/Mobs/Pig.h b/src/Mobs/Pig.h index ed0685e5f..9a138f83e 100644 --- a/src/Mobs/Pig.h +++ b/src/Mobs/Pig.h @@ -1,16 +1,16 @@ - #pragma once -#include "PassiveMonster.h" - - - +#include "Behaviors/BehaviorBreeder.h" +#include "Behaviors/BehaviorItemFollower.h" +#include "Behaviors/BehaviorCoward.h" +#include "Behaviors/BehaviorWanderer.h" +#include "Monster.h" class cPig : - public cPassiveMonster + public cMonster { - typedef cPassiveMonster super; + typedef cMonster super; public: cPig(void); @@ -30,8 +30,12 @@ public: } bool IsSaddled(void) const { return m_bIsSaddled; } - private: + // Tick controlling behaviors + cBehaviorBreeder m_BehaviorBreeder; + cBehaviorItemFollower m_BehaviorItemFollower; + cBehaviorCoward m_BehaviorCoward; + cBehaviorWanderer m_BehaviorWanderer; bool m_bIsSaddled; diff --git a/src/Mobs/Rabbit.cpp b/src/Mobs/Rabbit.cpp index f4de0ba0c..0be458e3b 100644 --- a/src/Mobs/Rabbit.cpp +++ b/src/Mobs/Rabbit.cpp @@ -14,6 +14,11 @@ cRabbit::cRabbit(void) : static_cast<UInt8>(eRabbitType::SaltAndPepper) // Max possible Rabbit-Type )), 0) { + m_EMPersonality = PASSIVE; + m_BehaviorBreeder.AttachToMonster(*this); + m_BehaviorCoward.AttachToMonster(*this); + m_BehaviorItemFollower.AttachToMonster(*this); + m_BehaviorWanderer.AttachToMonster(*this); } @@ -44,4 +49,3 @@ void cRabbit::GetDrops(cItems & a_Drops, cEntity * a_Killer) RareDrops.Add(cItem(E_ITEM_RABBITS_FOOT)); AddRandomRareDropItem(a_Drops, RareDrops, LootingLevel); } - diff --git a/src/Mobs/Rabbit.h b/src/Mobs/Rabbit.h index 289ff0282..119ba280b 100644 --- a/src/Mobs/Rabbit.h +++ b/src/Mobs/Rabbit.h @@ -1,8 +1,11 @@ #pragma once -#include "PassiveMonster.h" - +#include "Behaviors/BehaviorBreeder.h" +#include "Behaviors/BehaviorItemFollower.h" +#include "Behaviors/BehaviorCoward.h" +#include "Behaviors/BehaviorWanderer.h" +#include "Monster.h" @@ -23,9 +26,9 @@ enum class eRabbitType : UInt8 class cRabbit : - public cPassiveMonster + public cMonster { - typedef cPassiveMonster super; + typedef cMonster super; public: cRabbit(); @@ -43,8 +46,12 @@ public: eRabbitType GetRabbitType() const { return m_Type; } int GetMoreCarrotTicks() const { return m_MoreCarrotTicks; } - private: + // Tick controlling behaviors + cBehaviorBreeder m_BehaviorBreeder; + cBehaviorItemFollower m_BehaviorItemFollower; + cBehaviorCoward m_BehaviorCoward; + cBehaviorWanderer m_BehaviorWanderer; eRabbitType m_Type; int m_MoreCarrotTicks; // Ticks until the Rabbit eat planted Carrots diff --git a/src/Mobs/Sheep.cpp b/src/Mobs/Sheep.cpp index fef1adac6..bd69db6c2 100644 --- a/src/Mobs/Sheep.cpp +++ b/src/Mobs/Sheep.cpp @@ -13,10 +13,16 @@ cSheep::cSheep(int a_Color) : super("Sheep", mtSheep, "entity.sheep.hurt", "entity.sheep.death", 0.6, 1.3), + m_TimeToStopEating(-1), m_IsSheared(false), - m_WoolColor(a_Color), - m_TimeToStopEating(-1) + m_WoolColor(a_Color) { + m_EMPersonality = PASSIVE; + m_BehaviorBreeder.AttachToMonster(*this); + m_BehaviorCoward.AttachToMonster(*this); + m_BehaviorItemFollower.AttachToMonster(*this); + m_BehaviorWanderer.AttachToMonster(*this); + // Generate random wool color. if (m_WoolColor == -1) { @@ -135,7 +141,7 @@ void cSheep::Tick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) -void cSheep::InheritFromParents(cPassiveMonster * a_Parent1, cPassiveMonster * a_Parent2) +void cSheep::InheritFromParents(cMonster * a_Parent1, cMonster * a_Parent2) { static const struct { @@ -203,4 +209,3 @@ NIBBLETYPE cSheep::GenerateNaturalRandomColor(void) return E_META_WOOL_PINK; } } - diff --git a/src/Mobs/Sheep.h b/src/Mobs/Sheep.h index c8af067f3..89fa41edf 100644 --- a/src/Mobs/Sheep.h +++ b/src/Mobs/Sheep.h @@ -1,16 +1,18 @@ #pragma once -#include "PassiveMonster.h" - - +#include "Behaviors/BehaviorBreeder.h" +#include "Behaviors/BehaviorItemFollower.h" +#include "Behaviors/BehaviorCoward.h" +#include "Behaviors/BehaviorWanderer.h" +#include "Monster.h" class cSheep : - public cPassiveMonster + public cMonster { - typedef cPassiveMonster super; + typedef cMonster super; public: @@ -25,7 +27,7 @@ public: virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = nullptr) override; virtual void OnRightClicked(cPlayer & a_Player) override; virtual void Tick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) override; - virtual void InheritFromParents(cPassiveMonster * a_Parent1, cPassiveMonster * a_Parent2) override; + virtual void InheritFromParents(cMonster * a_Parent1, cMonster * a_Parent2) override; virtual void GetFollowedItems(cItems & a_Items) override { @@ -41,12 +43,21 @@ public: int GetFurColor(void) const { return m_WoolColor; } void SetFurColor(int a_WoolColor) { m_WoolColor = a_WoolColor; } - private: - bool m_IsSheared; - int m_WoolColor; + + // Tick controlling behaviors + cBehaviorBreeder m_BehaviorBreeder; + cBehaviorItemFollower m_BehaviorItemFollower; + cBehaviorCoward m_BehaviorCoward; + cBehaviorWanderer m_BehaviorWanderer; + + // mobTodo transfer this to a behavior int m_TimeToStopEating; + // Behavior note: These are ship-specific things not transferrable to other mobs. + // Therefore they do not need a Behavior and can stay hardcoded in the sheep. + bool m_IsSheared; + int m_WoolColor; } ; diff --git a/src/Mobs/Silverfish.h b/src/Mobs/Silverfish.h index 90ef5ea5d..20b75474d 100644 --- a/src/Mobs/Silverfish.h +++ b/src/Mobs/Silverfish.h @@ -1,16 +1,16 @@ #pragma once -#include "AggressiveMonster.h" +#include "Monster.h" class cSilverfish : - public cAggressiveMonster + public cMonster { - typedef cAggressiveMonster super; + typedef cMonster super; public: cSilverfish(void) : diff --git a/src/Mobs/Skeleton.cpp b/src/Mobs/Skeleton.cpp index e48991a06..15be6c790 100644 --- a/src/Mobs/Skeleton.cpp +++ b/src/Mobs/Skeleton.cpp @@ -13,7 +13,7 @@ cSkeleton::cSkeleton(bool IsWither) : super("Skeleton", mtSkeleton, "entity.skeleton.hurt", "entity.skeleton.death", 0.6, 1.8), m_bIsWither(IsWither) { - SetBurnsInDaylight(true); + m_EMPersonality = AGGRESSIVE; } @@ -47,8 +47,8 @@ void cSkeleton::GetDrops(cItems & a_Drops, cEntity * a_Killer) - -bool cSkeleton::Attack(std::chrono::milliseconds a_Dt) +//mobTodo +/*bool cSkeleton::Attack(std::chrono::milliseconds a_Dt) { StopMovingToPosition(); // Todo handle this in a better way, the skeleton does some uneeded recalcs due to inStateChasing auto & Random = GetRandomProvider(); @@ -69,7 +69,7 @@ bool cSkeleton::Attack(std::chrono::milliseconds a_Dt) return true; } return false; -} +}*/ diff --git a/src/Mobs/Skeleton.h b/src/Mobs/Skeleton.h index 0316fb9b5..56e7339e0 100644 --- a/src/Mobs/Skeleton.h +++ b/src/Mobs/Skeleton.h @@ -1,16 +1,16 @@ #pragma once -#include "AggressiveMonster.h" +#include "Monster.h" class cSkeleton : - public cAggressiveMonster + public cMonster { - typedef cAggressiveMonster super; + typedef cMonster super; public: cSkeleton(bool IsWither); @@ -18,7 +18,7 @@ public: CLASS_PROTODEF(cSkeleton) virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = nullptr) override; - virtual bool Attack(std::chrono::milliseconds a_Dt) override; + /*virtual bool Attack(std::chrono::milliseconds a_Dt) override;*/ virtual void SpawnOn(cClientHandle & a_ClientHandle) override; virtual bool IsUndead(void) override { return true; } diff --git a/src/Mobs/Slime.cpp b/src/Mobs/Slime.cpp index 291a3a57f..d5409ec11 100644 --- a/src/Mobs/Slime.cpp +++ b/src/Mobs/Slime.cpp @@ -19,8 +19,9 @@ cSlime::cSlime(int a_Size) : ), m_Size(a_Size) { + m_EMPersonality = AGGRESSIVE; SetMaxHealth(a_Size * a_Size); - SetAttackDamage(a_Size); + // SetAttackDamage(a_Size); //mobTodo myBehavior.setaTTACKDamage } @@ -45,8 +46,8 @@ void cSlime::GetDrops(cItems & a_Drops, cEntity * a_Killer) - -bool cSlime::Attack(std::chrono::milliseconds a_Dt) +//mobTodo +/*bool cSlime::Attack(std::chrono::milliseconds a_Dt) { if (m_Size > 1) { @@ -55,7 +56,7 @@ bool cSlime::Attack(std::chrono::milliseconds a_Dt) } return false; -} +}*/ diff --git a/src/Mobs/Slime.h b/src/Mobs/Slime.h index c78461a02..f4f1aabd4 100644 --- a/src/Mobs/Slime.h +++ b/src/Mobs/Slime.h @@ -1,16 +1,15 @@ - #pragma once -#include "AggressiveMonster.h" +#include "Monster.h" class cSlime : - public cAggressiveMonster + public cMonster { - typedef cAggressiveMonster super; + typedef cMonster super; public: /** Creates a slime of the specified size; size can be 1, 2 or 4, with 1 is the smallest and 4 is the tallest. */ @@ -20,7 +19,7 @@ public: // cAggressiveMonster overrides: virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = nullptr) override; - virtual bool Attack(std::chrono::milliseconds a_Dt) override; + // virtual bool Attack(std::chrono::milliseconds a_Dt) override; virtual void KilledBy(TakeDamageInfo & a_TDI) override; int GetSize(void) const { return m_Size; } diff --git a/src/Mobs/SnowGolem.cpp b/src/Mobs/SnowGolem.cpp index c86577a1e..fd8ce1112 100644 --- a/src/Mobs/SnowGolem.cpp +++ b/src/Mobs/SnowGolem.cpp @@ -11,6 +11,7 @@ cSnowGolem::cSnowGolem(void) : super("SnowGolem", mtSnowGolem, "entity.snowman.hurt", "entity.snowman.death", 0.4, 1.8) { + m_EMPersonality = PASSIVE; } diff --git a/src/Mobs/SnowGolem.h b/src/Mobs/SnowGolem.h index 708ddbef9..59026b3ec 100644 --- a/src/Mobs/SnowGolem.h +++ b/src/Mobs/SnowGolem.h @@ -1,16 +1,16 @@ #pragma once -#include "PassiveAggressiveMonster.h" +#include "Monster.h" class cSnowGolem : - public cPassiveAggressiveMonster + public cMonster { - typedef cPassiveAggressiveMonster super; + typedef cMonster super; public: cSnowGolem(void); diff --git a/src/Mobs/Spider.cpp b/src/Mobs/Spider.cpp index 971ff22f6..e8d65157c 100644 --- a/src/Mobs/Spider.cpp +++ b/src/Mobs/Spider.cpp @@ -11,6 +11,7 @@ cSpider::cSpider(void) : super("Spider", mtSpider, "entity.spider.hurt", "entity.spider.death", 1.4, 0.9) { + m_EMPersonality = AGGRESSIVE; } @@ -35,32 +36,6 @@ void cSpider::GetDrops(cItems & a_Drops, cEntity * a_Killer) -void cSpider::EventSeePlayer(cPlayer * a_Player, cChunk & a_Chunk) -{ - if (!GetWorld()->IsChunkLighted(GetChunkX(), GetChunkZ())) - { - return; - } - - PREPARE_REL_AND_CHUNK(GetPosition(), a_Chunk); - if (!RelSuccess) - { - return; - } - - if ( - a_Player->CanMobsTarget() && - !((Chunk->GetSkyLightAltered(Rel.x, Rel.y, Rel.z) > 11) || (Chunk->GetBlockLight(Rel.x, Rel.y, Rel.z) > 11)) - ) - { - super::EventSeePlayer(a_Player, a_Chunk); - } -} - - - - - bool cSpider::DoTakeDamage(TakeDamageInfo & a_TDI) { if (!super::DoTakeDamage(a_TDI)) @@ -68,6 +43,7 @@ bool cSpider::DoTakeDamage(TakeDamageInfo & a_TDI) return false; } + /* mobTodo // If the source of the damage is not from an pawn entity, switch to idle if ((a_TDI.Attacker == nullptr) || !a_TDI.Attacker->IsPawn()) { @@ -77,7 +53,7 @@ bool cSpider::DoTakeDamage(TakeDamageInfo & a_TDI) { // If the source of the damage is from a pawn entity, chase that entity m_EMState = CHASING; - } + }*/ return true; } diff --git a/src/Mobs/Spider.h b/src/Mobs/Spider.h index af2753012..de2c8d533 100644 --- a/src/Mobs/Spider.h +++ b/src/Mobs/Spider.h @@ -1,16 +1,16 @@ #pragma once -#include "AggressiveMonster.h" +#include "Monster.h" class cSpider : - public cAggressiveMonster + public cMonster { - typedef cAggressiveMonster super; + typedef cMonster super; public: cSpider(void); @@ -18,7 +18,6 @@ public: CLASS_PROTODEF(cSpider) virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = nullptr) override; - virtual void EventSeePlayer(cPlayer *, cChunk & a_Chunk) override; virtual bool DoTakeDamage(TakeDamageInfo & a_TDI) override; } ; diff --git a/src/Mobs/Squid.cpp b/src/Mobs/Squid.cpp index 8ae688a1b..69f918935 100644 --- a/src/Mobs/Squid.cpp +++ b/src/Mobs/Squid.cpp @@ -11,6 +11,8 @@ cSquid::cSquid(void) : super("Squid", mtSquid, "entity.squid.hurt", "entity.squid.death", 0.95, 0.95) { + m_EMPersonality = PASSIVE; + m_BehaviorDoNothing.AttachToMonster(*this); } diff --git a/src/Mobs/Squid.h b/src/Mobs/Squid.h index 590c50495..20d87dbca 100644 --- a/src/Mobs/Squid.h +++ b/src/Mobs/Squid.h @@ -1,16 +1,17 @@ #pragma once -#include "PassiveMonster.h" +#include "Monster.h" +#include "Behaviors/BehaviorDoNothing.h" class cSquid : - public cPassiveMonster + public cMonster { - typedef cPassiveMonster super; + typedef cMonster super; public: cSquid(); @@ -24,6 +25,9 @@ public: // Squids do not drown (or float) virtual void HandleAir(void) override {} virtual void SetSwimState(cChunk & a_Chunk) override {} + +private: + cBehaviorDoNothing m_BehaviorDoNothing; } ; diff --git a/src/Mobs/Villager.cpp b/src/Mobs/Villager.cpp index 26462ba31..ded1bfbdb 100644 --- a/src/Mobs/Villager.cpp +++ b/src/Mobs/Villager.cpp @@ -17,6 +17,11 @@ cVillager::cVillager(eVillagerType VillagerType) : m_Type(VillagerType), m_VillagerAction(false) { + m_EMPersonality = PASSIVE; + m_BehaviorBreeder.AttachToMonster(*this); + m_BehaviorCoward.AttachToMonster(*this); + m_BehaviorItemFollower.AttachToMonster(*this); + m_BehaviorWanderer.AttachToMonster(*this); } diff --git a/src/Mobs/Villager.h b/src/Mobs/Villager.h index 6f3e7b4e8..141193212 100644 --- a/src/Mobs/Villager.h +++ b/src/Mobs/Villager.h @@ -1,16 +1,21 @@ #pragma once -#include "PassiveMonster.h" +#include "Monster.h" #include "Blocks/ChunkInterface.h" +#include "Behaviors/BehaviorBreeder.h" +#include "Behaviors/BehaviorItemFollower.h" +#include "Behaviors/BehaviorCoward.h" +#include "Behaviors/BehaviorWanderer.h" +#include "Monster.h" class cVillager : - public cPassiveMonster + public cMonster { - typedef cPassiveMonster super; + typedef cMonster super; public: @@ -53,6 +58,12 @@ public: bool DoesHaveActionActivated(void) const { return m_VillagerAction; } private: + // Tick controlling behaviors + cBehaviorBreeder m_BehaviorBreeder; + cBehaviorItemFollower m_BehaviorItemFollower; + cBehaviorCoward m_BehaviorCoward; + cBehaviorWanderer m_BehaviorWanderer; + int m_ActionCountDown; int m_Type; diff --git a/src/Mobs/Witch.cpp b/src/Mobs/Witch.cpp index 3f56108ae..e9baf5512 100644 --- a/src/Mobs/Witch.cpp +++ b/src/Mobs/Witch.cpp @@ -11,6 +11,7 @@ cWitch::cWitch(void) : super("Witch", mtWitch, "entity.witch.hurt", "entity.witch.death", 0.6, 1.8) { + m_EMPersonality = AGGRESSIVE; } diff --git a/src/Mobs/Witch.h b/src/Mobs/Witch.h index 706fcd9b3..7013f998a 100644 --- a/src/Mobs/Witch.h +++ b/src/Mobs/Witch.h @@ -1,16 +1,16 @@ #pragma once -#include "AggressiveMonster.h" +#include "Monster.h" class cWitch : - public cAggressiveMonster + public cMonster { - typedef cAggressiveMonster super; + typedef cMonster super; public: cWitch(); @@ -18,8 +18,7 @@ public: CLASS_PROTODEF(cWitch) virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = nullptr) override; - - bool IsAngry(void) const {return ((m_EMState == ATTACKING) || (m_EMState == CHASING)); } + bool IsAngry() const { return false; } } ; diff --git a/src/Mobs/Wither.cpp b/src/Mobs/Wither.cpp index dd85d7d2b..99b9a3ce8 100644 --- a/src/Mobs/Wither.cpp +++ b/src/Mobs/Wither.cpp @@ -16,6 +16,7 @@ cWither::cWither(void) : { SetMaxHealth(300); SetHealth(GetMaxHealth() / 3); + m_EMPersonality = AGGRESSIVE; } diff --git a/src/Mobs/Wither.h b/src/Mobs/Wither.h index 5f6ec607c..023fc773c 100644 --- a/src/Mobs/Wither.h +++ b/src/Mobs/Wither.h @@ -1,16 +1,16 @@ #pragma once -#include "AggressiveMonster.h" +#include "Monster.h" class cWither : - public cAggressiveMonster + public cMonster { - typedef cAggressiveMonster super; + typedef cMonster super; public: cWither(void); diff --git a/src/Mobs/Wolf.cpp b/src/Mobs/Wolf.cpp index f3b859c76..c08e572fb 100644 --- a/src/Mobs/Wolf.cpp +++ b/src/Mobs/Wolf.cpp @@ -22,6 +22,7 @@ cWolf::cWolf(void) : m_NotificationCooldown(0) { m_RelativeWalkSpeed = 2; + m_EMPersonality = PASSIVE; } @@ -30,6 +31,7 @@ cWolf::cWolf(void) : bool cWolf::DoTakeDamage(TakeDamageInfo & a_TDI) { + /* cPawn * PreviousTarget = GetTarget(); if (!super::DoTakeDamage(a_TDI)) { @@ -66,7 +68,7 @@ bool cWolf::DoTakeDamage(TakeDamageInfo & a_TDI) } m_World->BroadcastEntityMetadata(*this); // Broadcast health and possibly angry face - return true; + return true;*/ } @@ -75,6 +77,7 @@ bool cWolf::DoTakeDamage(TakeDamageInfo & a_TDI) void cWolf::NotifyAlliesOfFight(cPawn * a_Opponent) { + /* if (GetOwnerName() == "") { return; @@ -92,10 +95,10 @@ void cWolf::NotifyAlliesOfFight(cPawn * a_Opponent) } Callback; Callback.m_Opponent = a_Opponent; - m_World->DoWithPlayerByUUID(m_OwnerUUID, Callback); + m_World->DoWithPlayerByUUID(m_OwnerUUID, Callback);*/ } -bool cWolf::Attack(std::chrono::milliseconds a_Dt) +/*bool cWolf::Attack(std::chrono::milliseconds a_Dt) { UNUSED(a_Dt); @@ -111,7 +114,7 @@ bool cWolf::Attack(std::chrono::milliseconds a_Dt) NotifyAlliesOfFight(static_cast<cPawn*>(GetTarget())); return super::Attack(a_Dt); -} +}*/ @@ -119,6 +122,7 @@ bool cWolf::Attack(std::chrono::milliseconds a_Dt) void cWolf::ReceiveNearbyFightInfo(const cUUID & a_PlayerID, cPawn * a_Opponent, bool a_IsPlayerInvolved) { + /* if ( (a_Opponent == nullptr) || IsSitting() || (!IsTame()) || (!a_Opponent->IsPawn()) || (a_PlayerID != m_OwnerUUID) @@ -159,7 +163,7 @@ void cWolf::ReceiveNearbyFightInfo(const cUUID & a_PlayerID, cPawn * a_Opponent, } SetTarget(a_Opponent); - + */ } @@ -169,7 +173,7 @@ void cWolf::ReceiveNearbyFightInfo(const cUUID & a_PlayerID, cPawn * a_Opponent, void cWolf::OnRightClicked(cPlayer & a_Player) { - const cItem & EquippedItem = a_Player.GetEquippedItem(); + /*const cItem & EquippedItem = a_Player.GetEquippedItem(); const int EquippedItemType = EquippedItem.m_ItemType; if (!IsTame() && !IsAngry()) @@ -245,6 +249,7 @@ void cWolf::OnRightClicked(cPlayer & a_Player) } m_World->BroadcastEntityMetadata(*this); + */ } @@ -253,6 +258,9 @@ void cWolf::OnRightClicked(cPlayer & a_Player) void cWolf::Tick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) { + //mobTodo behaviors! + + /* if (!IsAngry()) { cMonster::Tick(a_Dt, a_Chunk); @@ -326,7 +334,7 @@ void cWolf::Tick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) MoveToPosition(GetTarget()->GetPosition()); if (TargetIsInRange()) { - Attack(a_Dt); + // Attack(a_Dt); mobTodo } } } @@ -339,6 +347,7 @@ void cWolf::Tick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) { StopMovingToPosition(); } + */ } @@ -347,6 +356,7 @@ void cWolf::Tick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) void cWolf::TickFollowPlayer() { + /* class cCallback : public cPlayerListCallback { @@ -392,16 +402,7 @@ void cWolf::TickFollowPlayer() } } } -} - - - -void cWolf::InStateIdle(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) -{ - if (!IsTame()) - { - cMonster::InStateIdle(a_Dt, a_Chunk); - } + */ } diff --git a/src/Mobs/Wolf.h b/src/Mobs/Wolf.h index 861419ba8..515cd33e8 100644 --- a/src/Mobs/Wolf.h +++ b/src/Mobs/Wolf.h @@ -1,7 +1,7 @@ #pragma once -#include "PassiveAggressiveMonster.h" +#include "Monster.h" #include "../UUID.h" @@ -10,9 +10,9 @@ class cEntity; class cWolf : - public cPassiveAggressiveMonster + public cMonster { - typedef cPassiveAggressiveMonster super; + typedef cMonster super; public: cWolf(void); @@ -24,7 +24,6 @@ public: virtual void OnRightClicked(cPlayer & a_Player) override; virtual void Tick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) override; virtual void TickFollowPlayer(); - virtual bool Attack(std::chrono::milliseconds a_Dt) override; // Get functions bool IsSitting (void) const override { return m_IsSitting; } @@ -56,8 +55,6 @@ public: @param a_IsPlayerInvolved Whether the fighter a player or a wolf. */ void ReceiveNearbyFightInfo(const cUUID & a_PlayerUUID, cPawn * a_Opponent, bool a_IsPlayerInvolved); - virtual void InStateIdle(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) override; - protected: bool m_IsSitting; diff --git a/src/Mobs/Zombie.cpp b/src/Mobs/Zombie.cpp index 882e98bf1..4f616c609 100644 --- a/src/Mobs/Zombie.cpp +++ b/src/Mobs/Zombie.cpp @@ -14,7 +14,14 @@ cZombie::cZombie(bool a_IsVillagerZombie) : m_IsVillagerZombie(a_IsVillagerZombie), m_IsConverting(false) { - SetBurnsInDaylight(true); + m_EMPersonality = AGGRESSIVE; + + m_BehaviorAttackerMelee.AttachToMonster(*this); + m_BehaviorWanderer.AttachToMonster(*this); + m_BehaviorAggressive.AttachToMonster(*this); + m_BehaviourDayLightBurner.AttachToMonster(*this); + GetMonsterConfig("Zombie"); + // Todo I need the config to load after attaching attackerMelee but this is not clean. } diff --git a/src/Mobs/Zombie.h b/src/Mobs/Zombie.h index 47a9f1904..1bb2ebd45 100644 --- a/src/Mobs/Zombie.h +++ b/src/Mobs/Zombie.h @@ -1,15 +1,20 @@ #pragma once -#include "AggressiveMonster.h" +#include "Monster.h" +#include "Behaviors/BehaviorAttackerMelee.h" +#include "Behaviors/BehaviorWanderer.h" + +#include "Behaviors/BehaviorAggressive.h" +#include "Behaviors/BehaviorDayLightBurner.h" class cZombie : - public cAggressiveMonster + public cMonster { - typedef cAggressiveMonster super; + typedef cMonster super; public: cZombie(bool a_IsVillagerZombie); @@ -21,12 +26,18 @@ public: bool IsVillagerZombie(void) const { return m_IsVillagerZombie; } bool IsConverting (void) const { return m_IsConverting; } - private: bool m_IsVillagerZombie; bool m_IsConverting; + // tick behaviors + cBehaviorAttackerMelee m_BehaviorAttackerMelee; + cBehaviorWanderer m_BehaviorWanderer; + + // other behaviors + cBehaviorAggressive m_BehaviorAggressive; + cBehaviorDayLightBurner m_BehaviourDayLightBurner; } ; diff --git a/src/Mobs/ZombiePigman.cpp b/src/Mobs/ZombiePigman.cpp index 2581d3751..07dbf4aa0 100644 --- a/src/Mobs/ZombiePigman.cpp +++ b/src/Mobs/ZombiePigman.cpp @@ -11,6 +11,7 @@ cZombiePigman::cZombiePigman(void) : super("ZombiePigman", mtZombiePigman, "entity.zombie_pig.hurt", "entity.zombie_pig.death", 0.6, 1.8) { + m_EMPersonality = PASSIVE; } diff --git a/src/Mobs/ZombiePigman.h b/src/Mobs/ZombiePigman.h index 23a7be8da..dad420da7 100644 --- a/src/Mobs/ZombiePigman.h +++ b/src/Mobs/ZombiePigman.h @@ -1,15 +1,15 @@ #pragma once -#include "PassiveAggressiveMonster.h" +#include "Monster.h" class cZombiePigman : - public cPassiveAggressiveMonster + public cMonster { - typedef cPassiveAggressiveMonster super; + typedef cMonster super; public: cZombiePigman(void); diff --git a/src/MonsterConfig.cpp b/src/MonsterConfig.cpp index 28132607e..fdd15e01e 100644 --- a/src/MonsterConfig.cpp +++ b/src/MonsterConfig.cpp @@ -3,6 +3,7 @@ #include "MonsterConfig.h" #include "Mobs/Monster.h" +#include "Mobs/Behaviors/BehaviorAttacker.h" #include "IniFile.h" @@ -90,11 +91,17 @@ void cMonsterConfig::AssignAttributes(cMonster * a_Monster, const AString & a_Na { if (itr->m_Name.compare(a_Name) == 0) { - a_Monster->SetAttackDamage (itr->m_AttackDamage); - a_Monster->SetAttackRange (itr->m_AttackRange); - a_Monster->SetSightDistance(itr->m_SightDistance); - a_Monster->SetAttackRate (static_cast<float>(itr->m_AttackRate)); + cBehaviorAttacker * Attacker = a_Monster->GetBehaviorAttacker(); + + if (Attacker != nullptr) + { + Attacker->SetAttackDamage (itr->m_AttackDamage); + Attacker->SetAttackRange (itr->m_AttackRange); + Attacker->SetAttackRate (static_cast<float>(itr->m_AttackRate)); + } + a_Monster->SetMaxHealth (itr->m_MaxHealth); + a_Monster->SetSightDistance(itr->m_SightDistance); a_Monster->SetIsFireproof (itr->m_IsFireproof); return; } diff --git a/src/Protocol/Protocol_1_10.cpp b/src/Protocol/Protocol_1_10.cpp index 7f86d4bdc..63b80dace 100644 --- a/src/Protocol/Protocol_1_10.cpp +++ b/src/Protocol/Protocol_1_10.cpp @@ -925,7 +925,8 @@ void cProtocol_1_10_0::WriteMobMetadata(cPacketizer & a_Pkt, const cMonster & a_ auto & Witch = reinterpret_cast<const cWitch &>(a_Mob); a_Pkt.WriteBEUInt8(WITCH_AGGRESIVE); a_Pkt.WriteBEUInt8(METADATA_TYPE_BOOL); - a_Pkt.WriteBool(Witch.IsAngry()); + // a_Pkt.WriteBool(Witch.IsAngry()); //mobTodo + a_Pkt.WriteBool(0); break; } // case mtWitch diff --git a/src/Protocol/Protocol_1_8.cpp b/src/Protocol/Protocol_1_8.cpp index b6e5b5a38..053aa75e5 100644 --- a/src/Protocol/Protocol_1_8.cpp +++ b/src/Protocol/Protocol_1_8.cpp @@ -3484,7 +3484,7 @@ void cProtocol_1_8_0::WriteMobMetadata(cPacketizer & a_Pkt, const cMonster & a_M a_Pkt.WriteBEUInt8(0x56); // Int at index 22 a_Pkt.WriteBEInt32(Horse.GetHorseArmour()); a_Pkt.WriteBEUInt8(0x0c); - a_Pkt.WriteBEInt8(Horse.IsBaby() ? -1 : (Horse.IsInLoveCooldown() ? 1 : 0)); + a_Pkt.WriteBEInt8(Horse.IsBaby() ? -1 : (Horse.GetBehaviorBreeder()->IsInLoveCooldown() ? 1 : 0)); break; } // case mtHorse @@ -3500,7 +3500,7 @@ void cProtocol_1_8_0::WriteMobMetadata(cPacketizer & a_Pkt, const cMonster & a_M { auto & Ocelot = reinterpret_cast<const cOcelot &>(a_Mob); a_Pkt.WriteBEUInt8(0x0c); - a_Pkt.WriteBEInt8(Ocelot.IsBaby() ? -1 : (Ocelot.IsInLoveCooldown() ? 1 : 0)); + a_Pkt.WriteBEInt8(Ocelot.IsBaby() ? -1 : (Ocelot.GetBehaviorBreeder()->IsInLoveCooldown() ? 1 : 0)); break; } // case mtOcelot @@ -3508,7 +3508,7 @@ void cProtocol_1_8_0::WriteMobMetadata(cPacketizer & a_Pkt, const cMonster & a_M { auto & Cow = reinterpret_cast<const cCow &>(a_Mob); a_Pkt.WriteBEUInt8(0x0c); - a_Pkt.WriteBEInt8(Cow.IsBaby() ? -1 : (Cow.IsInLoveCooldown() ? 1 : 0)); + a_Pkt.WriteBEInt8(Cow.IsBaby() ? -1 : (Cow.GetBehaviorBreeder()->IsInLoveCooldown() ? 1 : 0)); break; } // case mtCow @@ -3516,7 +3516,7 @@ void cProtocol_1_8_0::WriteMobMetadata(cPacketizer & a_Pkt, const cMonster & a_M { auto & Chicken = reinterpret_cast<const cChicken &>(a_Mob); a_Pkt.WriteBEUInt8(0x0c); - a_Pkt.WriteBEInt8(Chicken.IsBaby() ? -1 : (Chicken.IsInLoveCooldown() ? 1 : 0)); + a_Pkt.WriteBEInt8(Chicken.IsBaby() ? -1 : (Chicken.GetBehaviorBreeder()->IsInLoveCooldown() ? 1 : 0)); break; } // case mtChicken @@ -3524,7 +3524,7 @@ void cProtocol_1_8_0::WriteMobMetadata(cPacketizer & a_Pkt, const cMonster & a_M { auto & Pig = reinterpret_cast<const cPig &>(a_Mob); a_Pkt.WriteBEUInt8(0x0c); - a_Pkt.WriteBEInt8(Pig.IsBaby() ? -1 : (Pig.IsInLoveCooldown() ? 1 : 0)); + a_Pkt.WriteBEInt8(Pig.IsBaby() ? -1 : (Pig.GetBehaviorBreeder()->IsInLoveCooldown() ? 1 : 0)); a_Pkt.WriteBEUInt8(0x10); a_Pkt.WriteBEUInt8(Pig.IsSaddled() ? 1 : 0); break; @@ -3534,7 +3534,7 @@ void cProtocol_1_8_0::WriteMobMetadata(cPacketizer & a_Pkt, const cMonster & a_M { auto & Sheep = reinterpret_cast<const cSheep &>(a_Mob); a_Pkt.WriteBEUInt8(0x0c); - a_Pkt.WriteBEInt8(Sheep.IsBaby() ? -1 : (Sheep.IsInLoveCooldown() ? 1 : 0)); + a_Pkt.WriteBEInt8(Sheep.IsBaby() ? -1 : (Sheep.GetBehaviorBreeder()->IsInLoveCooldown() ? 1 : 0)); a_Pkt.WriteBEUInt8(0x10); Byte SheepMetadata = 0; @@ -3553,7 +3553,7 @@ void cProtocol_1_8_0::WriteMobMetadata(cPacketizer & a_Pkt, const cMonster & a_M a_Pkt.WriteBEUInt8(0x12); a_Pkt.WriteBEUInt8(static_cast<UInt8>(Rabbit.GetRabbitType())); a_Pkt.WriteBEUInt8(0x0c); - a_Pkt.WriteBEInt8(Rabbit.IsBaby() ? -1 : (Rabbit.IsInLoveCooldown() ? 1 : 0)); + a_Pkt.WriteBEInt8(Rabbit.IsBaby() ? -1 : (Rabbit.GetBehaviorBreeder()->IsInLoveCooldown() ? 1 : 0)); break; } // case mtRabbit @@ -3587,7 +3587,8 @@ void cProtocol_1_8_0::WriteMobMetadata(cPacketizer & a_Pkt, const cMonster & a_M { auto & Witch = reinterpret_cast<const cWitch &>(a_Mob); a_Pkt.WriteBEUInt8(0x15); - a_Pkt.WriteBEUInt8(Witch.IsAngry() ? 1 : 0); + // a_Pkt.WriteBEUInt8(Witch.IsAngry() ? 1 : 0); // mobTodo + a_Pkt.WriteBEUInt8(0); break; } // case mtWitch diff --git a/src/Protocol/Protocol_1_9.cpp b/src/Protocol/Protocol_1_9.cpp index 475047417..5267c7a8a 100644 --- a/src/Protocol/Protocol_1_9.cpp +++ b/src/Protocol/Protocol_1_9.cpp @@ -4053,7 +4053,8 @@ void cProtocol_1_9_0::WriteMobMetadata(cPacketizer & a_Pkt, const cMonster & a_M auto & Witch = reinterpret_cast<const cWitch &>(a_Mob); a_Pkt.WriteBEUInt8(11); // Index 11: Is angry a_Pkt.WriteBEUInt8(METADATA_TYPE_BOOL); - a_Pkt.WriteBool(Witch.IsAngry()); + // a_Pkt.WriteBool(Witch.IsAngry()); // mobTodo + a_Pkt.WriteBool(0); break; } // case mtWitch |