From 80d9c26c12a5be619a757d0251525664bf7065a6 Mon Sep 17 00:00:00 2001 From: LogicParrot Date: Tue, 22 Aug 2017 13:23:03 +0300 Subject: Initial copy of old files --- src/Mobs/Behaviors/BehaviorAggressive.cpp | 49 ++++++ src/Mobs/Behaviors/BehaviorAggressive.h | 31 ++++ src/Mobs/Behaviors/BehaviorBreeder.cpp | 233 ++++++++++++++++++++++++++ src/Mobs/Behaviors/BehaviorBreeder.h | 60 +++++++ src/Mobs/Behaviors/BehaviorChaser.cpp | 190 +++++++++++++++++++++ src/Mobs/Behaviors/BehaviorChaser.h | 62 +++++++ src/Mobs/Behaviors/BehaviorCoward.cpp | 53 ++++++ src/Mobs/Behaviors/BehaviorCoward.h | 24 +++ src/Mobs/Behaviors/BehaviorDayLightBurner.cpp | 85 ++++++++++ src/Mobs/Behaviors/BehaviorDayLightBurner.h | 5 + src/Mobs/Behaviors/BehaviorItemDropper.cpp | 1 + src/Mobs/Behaviors/BehaviorItemDropper.h | 1 + src/Mobs/Behaviors/BehaviorItemFollower.cpp | 44 +++++ src/Mobs/Behaviors/BehaviorItemFollower.h | 29 ++++ src/Mobs/Behaviors/BehaviorStriker.cpp | 7 + src/Mobs/Behaviors/BehaviorStriker.h | 13 ++ src/Mobs/Behaviors/BehaviorWanderer.cpp | 60 +++++++ src/Mobs/Behaviors/BehaviorWanderer.h | 23 +++ src/Mobs/Behaviors/CMakeLists.txt | 33 ++++ 19 files changed, 1003 insertions(+) create mode 100644 src/Mobs/Behaviors/BehaviorAggressive.cpp create mode 100644 src/Mobs/Behaviors/BehaviorAggressive.h create mode 100644 src/Mobs/Behaviors/BehaviorBreeder.cpp create mode 100644 src/Mobs/Behaviors/BehaviorBreeder.h create mode 100644 src/Mobs/Behaviors/BehaviorChaser.cpp create mode 100644 src/Mobs/Behaviors/BehaviorChaser.h create mode 100644 src/Mobs/Behaviors/BehaviorCoward.cpp create mode 100644 src/Mobs/Behaviors/BehaviorCoward.h create mode 100644 src/Mobs/Behaviors/BehaviorDayLightBurner.cpp create mode 100644 src/Mobs/Behaviors/BehaviorDayLightBurner.h create mode 100644 src/Mobs/Behaviors/BehaviorItemDropper.cpp create mode 100644 src/Mobs/Behaviors/BehaviorItemDropper.h create mode 100644 src/Mobs/Behaviors/BehaviorItemFollower.cpp create mode 100644 src/Mobs/Behaviors/BehaviorItemFollower.h create mode 100644 src/Mobs/Behaviors/BehaviorStriker.cpp create mode 100644 src/Mobs/Behaviors/BehaviorStriker.h create mode 100644 src/Mobs/Behaviors/BehaviorWanderer.cpp create mode 100644 src/Mobs/Behaviors/BehaviorWanderer.h create mode 100644 src/Mobs/Behaviors/CMakeLists.txt (limited to 'src') diff --git a/src/Mobs/Behaviors/BehaviorAggressive.cpp b/src/Mobs/Behaviors/BehaviorAggressive.cpp new file mode 100644 index 000000000..74eee0e17 --- /dev/null +++ b/src/Mobs/Behaviors/BehaviorAggressive.cpp @@ -0,0 +1,49 @@ +#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules + +#include "BehaviorAggressive.h" +#include "BehaviorChaser.h" +#include "../Monster.h" +#include "../../Chunk.h" +#include "../../Entities/Player.h" + + + +cBehaviorAggressive::cBehaviorAggressive(cMonster * a_Parent) : m_Parent(a_Parent) +{ + ASSERT(m_Parent != nullptr); + m_ParentChaser = m_Parent->GetBehaviorChaser(); + ASSERT(m_ParentChaser != nullptr); +} + + + + + +bool cBehaviorAggressive::ActiveTick() +{ + // Target something new if we have no target + if (m_ParentChaser->GetTarget() == nullptr) + { + m_ParentChaser->SetTarget(FindNewTarget()); + } + return false; +} + + + + + +void cBehaviorAggressive::Destroyed() +{ + m_Target = nullptr; +} + + + + + +bool cBehaviorAggressive::FindNewTarget() +{ + cPlayer * Closest = m_Parent->GetNearestPlayer(); + 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..43747d0e2 --- /dev/null +++ b/src/Mobs/Behaviors/BehaviorAggressive.h @@ -0,0 +1,31 @@ +// The mob is agressive toward specific mobtypes, or toward the player. +// This Behavior has a dependency on BehaviorChaser. +#pragma once +class cPawn; +class cMonster; +class cBehaviorChaser; + +class cBehaviorAggressive +{ + +public: + cBehaviorAggressive(cMonster * a_Parent, int a_MinimumLight); + + // 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: + bool ActiveTick(); + void Destroyed(); + +private: + cPawn * FindNewTarget(); + + // Our parent + cMonster * m_Parent; + cBehaviorChaser * m_ParentChaser; + + // The mob we want to attack + cPawn * m_Target; +}; diff --git a/src/Mobs/Behaviors/BehaviorBreeder.cpp b/src/Mobs/Behaviors/BehaviorBreeder.cpp new file mode 100644 index 000000000..ea3e10026 --- /dev/null +++ b/src/Mobs/Behaviors/BehaviorBreeder.cpp @@ -0,0 +1,233 @@ + +#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules + +#include "BehaviorBreeder.h" +#include "../PassiveMonster.h" +#include "../../World.h" +#include "../Monster.h" +#include "../../Entities/Player.h" +#include "../../Item.h" +#include "../../BoundingBox.h" + +iBehaviorBreeder::~iBehaviorBreeder() +{ + +} + + + + + +cBehaviorBreeder::cBehaviorBreeder(cMonster * a_Parent, cItems & a_BreedingItems) : + m_Parent(a_Parent), + m_LovePartner(nullptr), + m_LoveTimer(0), + m_LoveCooldown(0), + m_MatingTimer(0), + m_BreedingItems(a_BreedingItems) +{ + m_Parent = dynamic_cast(m_ParentInterface); + ASSERT(m_Parent != nullptr); +} + + + + + +bool cBehaviorBreeder::ActiveTick() +{ + 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(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.NextInt(6)); + + m_LovePartner->GetBehaviorBreeder()->ResetLoveMode(); + ResetLoveMode(); + } + return true; + } + + // If we are in love mode and we have no partner + 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(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::Tick() +{ + if (m_MatingTimer > 0) + { + m_MatingTimer--; + } + if (m_LoveCooldown > 0) + { + m_LoveCooldown--; + } + if (m_LoveTimer > 0) + { + m_LoveTimer--; + } +} + + + + + +void cBehaviorBreeder::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; + if (m_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..4d7dc1aa4 --- /dev/null +++ b/src/Mobs/Behaviors/BehaviorBreeder.h @@ -0,0 +1,60 @@ +#pragma once + +// Grants breeding capabilities to the mob + +class cBehaviorBreeder; + +class cWorld; +class cMonster; +class cPlayer; +class cItems; + + + + + +class cBehaviorBreeder +{ + +public: + cBehaviorBreeder(cMonster * a_Parent, cItems & a_BreedingItems); + + // Functions our host Monster should invoke: + void Tick(); + bool ActiveTick(); + void OnRightClicked(cPlayer & a_Player); + void Destroyed(); + + /** 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; + + cItems & m_BreedingItems; +}; diff --git a/src/Mobs/Behaviors/BehaviorChaser.cpp b/src/Mobs/Behaviors/BehaviorChaser.cpp new file mode 100644 index 000000000..22a95fe73 --- /dev/null +++ b/src/Mobs/Behaviors/BehaviorChaser.cpp @@ -0,0 +1,190 @@ + +#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules + +#include "BehaviorChaser.h" +#include "../Monster.h" +#include "../../Entities/Pawn.h" +#include "BehaviorStriker.h" + + +, m_AttackRate(3) +, m_AttackDamage(1) +, m_AttackRange(1) +, m_AttackCoolDownTicksLeft(0) +, m_TicksSinceLastDamaged(50) + +cBehaviorChaser::cBehaviorChaser(cMonster * a_Parent) : + m_Parent(a_Parent) +{ + ASSERT(m_Parent != nullptr); + m_StrikeBehavior = m_Parent->GetBehaviorStriker(); + ASSERT(m_StrikeBehavior != nullptr); // The monster that has an Attacker behavior must also have a Striker behavior +} + + + + + +bool cBehaviorChaser::ActiveTick() +{ + // Stop targeting out of range targets + if (GetTarget() != nullptr) + { + if (TargetOutOfSight()) + { + SetTarget(nullptr); + } + else + { + if (TargetIsInStrikeRange()) + { + StrikeTarget(); + } + else + { + ApproachTarget(); + } + return true; + } + } + return false; +} + + + + + +void cBehaviorChaser::Tick() +{ + ++m_TicksSinceLastDamaged; + if (m_AttackCoolDownTicksLeft > 0) + { + m_AttackCoolDownTicksLeft -= 1; + } +} + + + + + +void cBehaviorChaser::Destroyed() +{ + m_Target = nullptr; +} + + + + + +void cBehaviorChaser::SetAttackRate(float a_AttackRate) +{ + m_AttackRate = a_AttackRate; +} + + + + + +void cBehaviorChaser::SetAttackRange(int a_AttackRange) +{ + m_AttackRange = a_AttackRange; +} + + + + + +void cBehaviorChaser::SetAttackDamage(int a_AttackDamage) +{ + m_AttackDamage = a_AttackDamage; +} + + + + +cPawn * cBehaviorChaser::GetTarget() +{ + return m_Target; +} + + + + + +void cBehaviorChaser::SetTarget(cPawn * a_Target) +{ + m_Target = a_Target; +} + + + + + +cBehaviorChaser::~cBehaviorChaser() +{ + +} + + + + + +bool cBehaviorChaser::TargetIsInStrikeRange() +{ + ASSERT(m_Target != nullptr); + ASSERT(m_Parent != nullptr); + /* + #include "../../Tracer.h" + cTracer LineOfSight(m_Parent->GetWorld()); + Vector3d MyHeadPosition = m_Parent->GetPosition() + Vector3d(0, m_Parent->GetHeight(), 0); + Vector3d AttackDirection(m_ParentChaser->GetTarget()->GetPosition() + Vector3d(0, GetTarget()->GetHeight(), 0) - MyHeadPosition); + + + if (GetTarget() != nullptr) + { + MoveToPosition(GetTarget()->GetPosition()); + } + if (TargetIsInRange() && !LineOfSight.Trace(MyHeadPosition, AttackDirection, static_cast(AttackDirection.Length())) && (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); + } + */ + return ((m_Target->GetPosition() - m_Parent->GetPosition()).SqrLength() < (m_AttackRange * m_AttackRange)); +} + + + + + +bool cBehaviorChaser::TargetOutOfSight() +{ + ASSERT(m_Target != nullptr); + if ((GetTarget()->GetPosition() - m_Parent->GetPosition()).Length() > m_Parent->GetSightDistance()) + { + return true; + } + return false; +} + + + + + +void cBehaviorChaser::ResetStrikeCooldown() +{ + m_AttackCoolDownTicksLeft = static_cast(3 * 20 * m_AttackRate); // A second has 20 ticks, an attack rate of 1 means 1 hit every 3 seconds +} + + + + + +void cBehaviorChaser::StrikeTarget() +{ + if (m_AttackCoolDownTicksLeft != 0) + { + m_StrikeBehavior->Strike(m_Target); // LogicParrot Todo animations (via counter passing?) + ResetStrikeCooldown(); + } +} diff --git a/src/Mobs/Behaviors/BehaviorChaser.h b/src/Mobs/Behaviors/BehaviorChaser.h new file mode 100644 index 000000000..fff5ebfa3 --- /dev/null +++ b/src/Mobs/Behaviors/BehaviorChaser.h @@ -0,0 +1,62 @@ + +#pragma once + +class cMonster; +class cPawn; +class cBehaviorStriker; + + +/** 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 cBehaviorChaser +{ + +public: + cBehaviorChaser(cMonster * a_Parent); + + // Functions our host Monster should invoke: + bool ActiveTick(); + void Destroyed(); + void Tick(); + + // 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); + + /** Returns the target pointer, or a nullptr if we're not targeting anyone. */ + cPawn * GetTarget(); + + /** Sets the target. */ + void SetTarget(cPawn * a_Target); + + virtual ~cBehaviorChaser(); +protected: + virtual void ApproachTarget() = 0; +private: + + /** Our parent */ + cMonster * m_Parent; + cBehaviorStriker * m_StrikeBehavior; + + // The mob we want to attack + cPawn * m_Target; + + // Target stuff + bool TargetIsInStrikeRange(); + bool TargetOutOfSight(); + void StrikeTarget(); + + // 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? +}; diff --git a/src/Mobs/Behaviors/BehaviorCoward.cpp b/src/Mobs/Behaviors/BehaviorCoward.cpp new file mode 100644 index 000000000..017227340 --- /dev/null +++ b/src/Mobs/Behaviors/BehaviorCoward.cpp @@ -0,0 +1,53 @@ +#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(cMonster * a_Parent) : + m_Parent(a_Parent), + m_Attacker(nullptr) +{ + ASSERT(m_Parent != nullptr); +} + + + + + +bool cBehaviorCoward::ActiveTick() +{ + if (m_Attacker == nullptr) + { + return false; + } + + // 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 false; + } + + 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); + return true; +} + + + + + +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..227715c00 --- /dev/null +++ b/src/Mobs/Behaviors/BehaviorCoward.h @@ -0,0 +1,24 @@ +#pragma once + +// Makes the mob run away from any other mob that damages it + +//fwds +class cMonster; +class cItems; +class cEntity; +struct TakeDamageInfo; + +class cBehaviorCoward +{ +public: + cBehaviorCoward(cMonster * a_Parent); + + // Functions our host Monster should invoke: + bool ActiveTick(); + void DoTakeDamage(TakeDamageInfo & a_TDI); + + +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..f15247071 --- /dev/null +++ b/src/Mobs/Behaviors/BehaviorDayLightBurner.cpp @@ -0,0 +1,85 @@ +void cMonster::HandleDaylightBurning(cChunk & a_Chunk, bool WouldBurn) +{ + if (!m_BurnsInDaylight) + { + return; + } + + 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); + } +} + + + + +bool cMonster::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 + (GetWorld()->GetTimeOfDay() < 12000 + 1000) && // Daytime + GetWorld()->IsWeatherSunnyAt(POSX_TOINT, POSZ_TOINT) // Not raining + ) + { + int MobHeight = static_cast(a_Location.y) + round(GetHeight()) - 1; // The height of the mob head + if (MobHeight >= cChunkDef::Height) + { + return true; + } + // Start with the highest block and scan down to 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; +} diff --git a/src/Mobs/Behaviors/BehaviorDayLightBurner.h b/src/Mobs/Behaviors/BehaviorDayLightBurner.h new file mode 100644 index 000000000..9d4cbe874 --- /dev/null +++ b/src/Mobs/Behaviors/BehaviorDayLightBurner.h @@ -0,0 +1,5 @@ + +class cBehaviorDayLightBurner +{ + +}; diff --git a/src/Mobs/Behaviors/BehaviorItemDropper.cpp b/src/Mobs/Behaviors/BehaviorItemDropper.cpp new file mode 100644 index 000000000..8b1378917 --- /dev/null +++ b/src/Mobs/Behaviors/BehaviorItemDropper.cpp @@ -0,0 +1 @@ + diff --git a/src/Mobs/Behaviors/BehaviorItemDropper.h b/src/Mobs/Behaviors/BehaviorItemDropper.h new file mode 100644 index 000000000..8b1378917 --- /dev/null +++ b/src/Mobs/Behaviors/BehaviorItemDropper.h @@ -0,0 +1 @@ + diff --git a/src/Mobs/Behaviors/BehaviorItemFollower.cpp b/src/Mobs/Behaviors/BehaviorItemFollower.cpp new file mode 100644 index 000000000..7cc0f8dfc --- /dev/null +++ b/src/Mobs/Behaviors/BehaviorItemFollower.cpp @@ -0,0 +1,44 @@ +#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" + +iBehaviorItemFollower::~iBehaviorItemFollower() +{ + +} + +cBehaviorItemFollower::cBehaviorItemFollower(iBehaviorItemFollower * a_ParentInterface) : + m_ParentInterface(a_ParentInterface) +{ + m_Parent = dynamic_cast(m_ParentInterface); + ASSERT(m_Parent != nullptr); +} + + + + + +bool cBehaviorItemFollower::ActiveTick() +{ + cWorld * World = m_Parent->GetWorld(); + cItems FollowedItems; + m_ParentInterface->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); + return true; // We took control of the monster, prevent other Behaviors from doing so + } + } + } + return false; +} diff --git a/src/Mobs/Behaviors/BehaviorItemFollower.h b/src/Mobs/Behaviors/BehaviorItemFollower.h new file mode 100644 index 000000000..ed47dab04 --- /dev/null +++ b/src/Mobs/Behaviors/BehaviorItemFollower.h @@ -0,0 +1,29 @@ +#pragma once + +// Makes the mob follow specific held items + +class cBehaviorItemFollower; +class iBehaviorItemFollower; + +//fwds +class cMonster; +class cItems; + + + + + +class cBehaviorItemFollower +{ +public: + cBehaviorItemFollower(iBehaviorItemFollower * a_Parent); + + // Functions our host Monster should invoke: + bool ActiveTick(); + + +private: + /** Our parent */ + iBehaviorItemFollower * m_ParentInterface; + cMonster * m_Parent; +}; 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..53efd407c --- /dev/null +++ b/src/Mobs/Behaviors/BehaviorWanderer.cpp @@ -0,0 +1,60 @@ +#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(cMonster * a_Parent) + : m_Parent(a_Parent) + , m_IdleInterval(0) +{ + ASSERT(m_Parent != nullptr); +} + +bool cBehaviorWanderer::ActiveTick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk) +{ + if (m_Parent->IsPathFinderActivated()) + { + return true; // 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(m_Parent->GetWorld()->GetTickRandomNumber(10)) - 5.0; + Dist.z = static_cast(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(Destination.x), static_cast(Destination.z)); + if ((Chunk == nullptr) || !Chunk->IsValid()) + { + return true; + } + + BLOCKTYPE BlockType; + NIBBLETYPE BlockMeta; + int RelX = static_cast(Destination.x) - Chunk->GetPosX() * cChunkDef::Width; + int RelZ = static_cast(Destination.z) - Chunk->GetPosZ() * cChunkDef::Width; + int YBelowUs = static_cast(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); + } + } + } + } + return true; +} diff --git a/src/Mobs/Behaviors/BehaviorWanderer.h b/src/Mobs/Behaviors/BehaviorWanderer.h new file mode 100644 index 000000000..23d86f0d2 --- /dev/null +++ b/src/Mobs/Behaviors/BehaviorWanderer.h @@ -0,0 +1,23 @@ +#pragma once + +// The mob will wander around + +class cMonster; +class cEntity; +class cChunk; + +class cBehaviorWanderer +{ + +public: + cBehaviorWanderer(cMonster * a_Parent); + + // Functions our host Monster should invoke: + bool ActiveTick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk); + + +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..3e0a063d1 --- /dev/null +++ b/src/Mobs/Behaviors/CMakeLists.txt @@ -0,0 +1,33 @@ + +cmake_minimum_required (VERSION 2.6) +project (Cuberite) + +include_directories ("${PROJECT_SOURCE_DIR}/../") + +SET (SRCS + BehaviorAggressive.cpp + BehaviorChaser.cpp + BehaviorBreeder.cpp + BehaviorDayLightBurner.cpp + BehaviorCoward.cpp + BehaviorItemDropper.cpp + BehaviorItemFollower.cpp + BehaviorStriker.cpp + BehaviorWanderer.cpp +) + +SET (HDRS + BehaviorAggressive.h + BehaviorChaser.h + BehaviorBreeder.h + BehaviorDayLightBurner.h + BehaviorCoward.h + BehaviorItemDropper.h + BehaviorItemFollower.h + BehaviorStriker.h + BehaviorWanderer.h +) + +if(NOT MSVC) + add_library(Behaviors ${SRCS} ${HDRS}) +endif() -- cgit v1.2.3