flewkey/cuberite-2a
1
0
Fork 0
Code Releases Activity

Merge pull request #587 from mc-server/mobimprovements

Browse Source 
Mob improvements & rudimentary artificial intelligence
This commit is contained in:
Mattes D 2014-01-25 13:36:32 -08:00
commit cdcad2237a
29 changed files with 721 additions and 568 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
MCServer/monsters.ini
View File

@ -62,7 +62,7 @@ SightDistance=25.0
MaxHealth=12
[Creeper]
AttackRange=5.0
AttackRange=3.0
AttackRate=1
AttackDamage=0.0
SightDistance=25.0

2
src/ClientHandle.cpp
View File

@ -611,7 +611,7 @@ void cClientHandle::HandleCommandBlockMessage(const char* a_Data, unsigned int a
}
else
{
SendChat(Printf("%s[INFO]%s Command blocks are not enabled on this server", cChatColor::Green.c_str(), cChatColor::White.c_str()));
SendChat(Printf("%s[INFO]%s Command blocks are not enabled on this server", cChatColor::Yellow.c_str(), cChatColor::White.c_str()));
}
}

131
src/Entities/Entity.cpp
View File

@ -4,9 +4,7 @@
#include "../World.h"
#include "../Server.h"
#include "../Root.h"
#include "../Vector3d.h"
#include "../Matrix4f.h"
#include "../ReferenceManager.h"
#include "../ClientHandle.h"
#include "../Chunk.h"
#include "../Simulator/FluidSimulator.h"
@ -32,8 +30,6 @@ cEntity::cEntity(eEntityType a_EntityType, double a_X, double a_Y, double a_Z, d
, m_MaxHealth(1)
, m_AttachedTo(NULL)
, m_Attachee(NULL)
, m_Referencers(new cReferenceManager(cReferenceManager::RFMNGR_REFERENCERS))
, m_References(new cReferenceManager(cReferenceManager::RFMNGR_REFERENCES))
, m_bDirtyHead(true)
, m_bDirtyOrientation(true)
, m_bDirtyPosition(true)
@ -61,6 +57,8 @@ cEntity::cEntity(eEntityType a_EntityType, double a_X, double a_Y, double a_Z, d
, m_Mass (0.001) // Default 1g
, m_Width(a_Width)
, m_Height(a_Height)
, m_IsSubmerged(false)
, m_IsSwimming(false)
{
cCSLock Lock(m_CSCount);
m_EntityCount++;
@ -100,8 +98,6 @@ cEntity::~cEntity()
LOGWARNING("ERROR: Entity deallocated without being destroyed");
ASSERT(!"Entity deallocated without being destroyed or unlinked");
}
delete m_Referencers;
delete m_References;
}
@ -535,7 +531,17 @@ void cEntity::Tick(float a_Dt, cChunk & a_Chunk)
{
TickInVoid(a_Chunk);
}
else { m_TicksSinceLastVoidDamage = 0; }
else
m_TicksSinceLastVoidDamage = 0;
if (IsMob() || IsPlayer())
{
// Set swimming state
SetSwimState(a_Chunk);
// Handle drowning
HandleAir();
}
}
@ -913,6 +919,87 @@ void cEntity::TickInVoid(cChunk & a_Chunk)
void cEntity::SetSwimState(cChunk & a_Chunk)
{
int RelY = (int)floor(m_LastPosY + 0.1);
if ((RelY < 0) || (RelY >= cChunkDef::Height - 1))
{
m_IsSwimming = false;
m_IsSubmerged = false;
return;
}
BLOCKTYPE BlockIn;
int RelX = (int)floor(m_LastPosX) - a_Chunk.GetPosX() * cChunkDef::Width;
int RelZ = (int)floor(m_LastPosZ) - a_Chunk.GetPosZ() * cChunkDef::Width;
// Check if the player is swimming:
// Use Unbounded, because we're being called *after* processing super::Tick(), which could have changed our chunk
if (!a_Chunk.UnboundedRelGetBlockType(RelX, RelY, RelZ, BlockIn))
{
// This sometimes happens on Linux machines
// Ref.: http://forum.mc-server.org/showthread.php?tid=1244
LOGD("SetSwimState failure: RelX = %d, RelZ = %d, LastPos = {%.02f, %.02f}, Pos = %.02f, %.02f}",
RelX, RelY, m_LastPosX, m_LastPosZ, GetPosX(), GetPosZ()
);
m_IsSwimming = false;
m_IsSubmerged = false;
return;
}
m_IsSwimming = IsBlockWater(BlockIn);
// Check if the player is submerged:
VERIFY(a_Chunk.UnboundedRelGetBlockType(RelX, RelY + 1, RelZ, BlockIn));
m_IsSubmerged = IsBlockWater(BlockIn);
}
void cEntity::HandleAir(void)
{
// Ref.: http://www.minecraftwiki.net/wiki/Chunk_format
// See if the entity is /submerged/ water (block above is water)
// Get the type of block the entity is standing in:
if (IsSubmerged())
{
SetSpeedY(1); // Float in the water
// Either reduce air level or damage player
if (m_AirLevel < 1)
{
if (m_AirTickTimer < 1)
{
// Damage player
TakeDamage(dtDrowning, NULL, 1, 1, 0);
// Reset timer
m_AirTickTimer = DROWNING_TICKS;
}
else
{
m_AirTickTimer -= 1;
}
}
else
{
// Reduce air supply
m_AirLevel -= 1;
}
}
else
{
// Set the air back to maximum
m_AirLevel = MAX_AIR_LEVEL;
m_AirTickTimer = DROWNING_TICKS;
}
}
/// Called when the entity starts burning
void cEntity::OnStartedBurning(void)
{
@ -1430,33 +1517,3 @@ void cEntity::SetPosZ(double a_PosZ)
//////////////////////////////////////////////////////////////////////////
// Reference stuffs
void cEntity::AddReference(cEntity * & a_EntityPtr)
{
m_References->AddReference(a_EntityPtr);
a_EntityPtr->ReferencedBy(a_EntityPtr);
}
void cEntity::ReferencedBy(cEntity * & a_EntityPtr)
{
m_Referencers->AddReference(a_EntityPtr);
}
void cEntity::Dereference(cEntity * & a_EntityPtr)
{
m_Referencers->Dereference(a_EntityPtr);
}

38
src/Entities/Entity.h
View File

@ -4,6 +4,7 @@
#include "../Item.h"
#include "../Vector3d.h"
#include "../Vector3f.h"
#include "../Vector3i.h"
@ -28,12 +29,16 @@
return super::GetClass(); \
}
#define POSX_TOINT (int)floor(GetPosX())
#define POSY_TOINT (int)floor(GetPosY())
#define POSZ_TOINT (int)floor(GetPosZ())
#define POS_TOINT Vector3i(POSXTOINT, POSYTOINT, POSZTOINT)
class cWorld;
class cReferenceManager;
class cClientHandle;
class cPlayer;
class cChunk;
@ -110,6 +115,8 @@ public:
BURN_TICKS_PER_DAMAGE = 20, ///< How many ticks to wait between damaging an entity when it is burning
BURN_DAMAGE = 1, ///< How much damage to deal when the entity is burning
BURN_TICKS = 200, ///< How long to keep an entity burning after it has stood in lava / fire
MAX_AIR_LEVEL = 300, ///< Maximum air an entity can have
DROWNING_TICKS = 20, ///< Number of ticks per heart of damage
} ;
cEntity(eEntityType a_EntityType, double a_X, double a_Y, double a_Z, double a_Width, double a_Height);
@ -344,7 +351,14 @@ public:
virtual bool IsRiding (void) const {return false; }
virtual bool IsSprinting(void) const {return false; }
virtual bool IsRclking (void) const {return false; }
virtual bool IsInvisible(void) const {return false; }
virtual bool IsInvisible(void) const { return false; }
/** Returns whether the player is swimming or not */
virtual bool IsSwimming(void) const{ return m_IsSwimming; }
/** Return whether the player is under water or not */
virtual bool IsSubmerged(void) const{ return m_IsSubmerged; }
/** Gets remaining air of a monster */
int GetAirLevel(void) const { return m_AirLevel; }
// tolua_end
@ -373,9 +387,6 @@ protected:
/// The entity which is attached to this entity (rider), NULL if none
cEntity * m_Attachee;
cReferenceManager* m_Referencers;
cReferenceManager* m_References;
// Flags that signal that we haven't updated the clients with the latest.
bool m_bDirtyHead;
bool m_bDirtyOrientation;
@ -415,11 +426,18 @@ protected:
virtual void Destroyed(void) {} // Called after the entity has been destroyed
void SetWorld(cWorld * a_World) { m_World = a_World; }
friend class cReferenceManager;
void AddReference( cEntity*& a_EntityPtr );
void ReferencedBy( cEntity*& a_EntityPtr );
void Dereference( cEntity*& a_EntityPtr );
/** Called in each tick to handle air-related processing i.e. drowning */
virtual void HandleAir();
/** Called once per tick to set IsSwimming and IsSubmerged */
virtual void SetSwimState(cChunk & a_Chunk);
/** If an entity is currently swimming in or submerged under water */
bool m_IsSwimming, m_IsSubmerged;
/** Air level of a mobile */
int m_AirLevel;
int m_AirTickTimer;
private:
// Measured in degrees, [-180, +180)

71
src/Entities/Pickup.cpp
View File

@ -6,19 +6,58 @@
#endif
#include "Pickup.h"
#include "../ClientHandle.h"
#include "../Inventory.h"
#include "../World.h"
#include "../Simulator/FluidSimulator.h"
#include "../Server.h"
#include "Player.h"
#include "../ClientHandle.h"
#include "../World.h"
#include "../Server.h"
#include "../Bindings/PluginManager.h"
#include "../Item.h"
#include "../Root.h"
#include "../Chunk.h"
#include "../Vector3d.h"
#include "../Vector3f.h"
class cPickupCombiningCallback :
public cEntityCallback
{
public:
cPickupCombiningCallback(Vector3d a_Position, cPickup * a_Pickup) :
m_Position(a_Position),
m_Pickup(a_Pickup),
m_FoundMatchingPickup(false)
{
}
virtual bool Item(cEntity * a_Entity) override
{
if (!a_Entity->IsPickup() || (a_Entity->GetUniqueID() == m_Pickup->GetUniqueID()) || a_Entity->IsDestroyed())
{
return false;
}
Vector3d EntityPos = a_Entity->GetPosition();
double Distance = (EntityPos - m_Position).Length();
if ((Distance < 1.2) && ((cPickup *)a_Entity)->GetItem().IsEqual(m_Pickup->GetItem()))
{
m_Pickup->GetItem().AddCount(((cPickup *)a_Entity)->GetItem().m_ItemCount);
a_Entity->Destroy();
m_FoundMatchingPickup = true;
}
return false;
}
inline bool FoundMatchingPickup()
{
return m_FoundMatchingPickup;
}
protected:
bool m_FoundMatchingPickup;
Vector3d m_Position;
cPickup * m_Pickup;
};
@ -26,10 +65,10 @@
cPickup::cPickup(double a_PosX, double a_PosY, double a_PosZ, const cItem & a_Item, bool IsPlayerCreated, float a_SpeedX /* = 0.f */, float a_SpeedY /* = 0.f */, float a_SpeedZ /* = 0.f */)
: cEntity(etPickup, a_PosX, a_PosY, a_PosZ, 0.2, 0.2)
, m_Timer( 0.f )
, m_Timer(0.f)
, m_Item(a_Item)
, m_bCollected( false )
, m_bIsPlayerCreated( IsPlayerCreated )
, m_bCollected(false)
, m_bIsPlayerCreated(IsPlayerCreated)
{
SetGravity(-10.5f);
SetMaxHealth(5);
@ -89,6 +128,16 @@ void cPickup::Tick(float a_Dt, cChunk & a_Chunk)
return;
}
}
if (!IsDestroyed()) // Don't try to combine if someone has tried to combine me
{
cPickupCombiningCallback PickupCombiningCallback(GetPosition(), this);
m_World->ForEachEntity(PickupCombiningCallback); // Not ForEachEntityInChunk, otherwise pickups don't combine across chunk boundaries
if (PickupCombiningCallback.FoundMatchingPickup())
{
m_World->BroadcastEntityMetadata(*this);
}
}
}
}
}

131
src/Entities/Player.cpp
View File

@ -7,7 +7,6 @@
#include "../UI/Window.h"
#include "../UI/WindowOwner.h"
#include "../World.h"
#include "Pickup.h"
#include "../Bindings/PluginManager.h"
#include "../BlockEntities/BlockEntity.h"
#include "../GroupManager.h"
@ -27,8 +26,6 @@
#include "inifile/iniFile.h"
#include "json/json.h"
#define float2int(x) ((x)<0 ? ((int)(x))-1 : (int)(x))
@ -36,8 +33,6 @@
cPlayer::cPlayer(cClientHandle* a_Client, const AString & a_PlayerName)
: super(etPlayer, 0.6, 1.8)
, m_AirLevel( MAX_AIR_LEVEL )
, m_AirTickTimer(DROWNING_TICKS)
, m_bVisible(true)
, m_FoodLevel(MAX_FOOD_LEVEL)
, m_FoodSaturationLevel(5)
@ -108,9 +103,23 @@ cPlayer::cPlayer(cClientHandle* a_Client, const AString & a_PlayerName)
a_PlayerName.c_str(), GetPosX(), GetPosY(), GetPosZ()
);
}
m_LastJumpHeight = (float)(GetPosY());
m_LastGroundHeight = (float)(GetPosY());
m_Stance = GetPosY() + 1.62;
if (m_GameMode == gmNotSet)
{
cWorld * World = cRoot::Get()->GetWorld(GetLoadedWorldName());
if (World == NULL)
{
World = cRoot::Get()->GetDefaultWorld();
}
if (World->IsGameModeCreative())
{
m_CanFly = true;
}
}
cRoot::Get()->GetServer()->PlayerCreated(this);
}
@ -197,12 +206,6 @@ void cPlayer::Tick(float a_Dt, cChunk & a_Chunk)
super::Tick(a_Dt, a_Chunk);
// Set player swimming state
SetSwimState(a_Chunk);
// Handle air drowning stuff
HandleAir();
// Handle charging the bow:
if (m_IsChargingBow)
{
@ -435,7 +438,7 @@ void cPlayer::SetTouchGround(bool a_bTouchGround)
cWorld * World = GetWorld();
if ((GetPosY() >= 0) && (GetPosY() < cChunkDef::Height))
{
BLOCKTYPE BlockType = World->GetBlock(float2int(GetPosX()), float2int(GetPosY()), float2int(GetPosZ()));
BLOCKTYPE BlockType = World->GetBlock((int)floor(GetPosX()), (int)floor(GetPosY()), (int)floor(GetPosZ()));
if (BlockType != E_BLOCK_AIR)
{
m_bTouchGround = true;
@ -460,12 +463,10 @@ void cPlayer::SetTouchGround(bool a_bTouchGround)
if (Damage > 0)
{
if (!IsGameModeCreative())
{
TakeDamage(dtFalling, NULL, Damage, Damage, 0);
}
// cPlayer makes sure damage isn't applied in creative, no need to check here
TakeDamage(dtFalling, NULL, Damage, Damage, 0);
// Mojang uses floor() to get X and Z positions, instead of just casting it to an (int)
// Fall particles
GetWorld()->BroadcastSoundParticleEffect(2006, (int)floor(GetPosX()), (int)GetPosY() - 1, (int)floor(GetPosZ()), Damage /* Used as particle effect speed modifier */);
}
@ -787,7 +788,7 @@ void cPlayer::DoTakeDamage(TakeDamageInfo & a_TDI)
{
if (IsGameModeCreative())
{
// No damage / health in creative mode
// No damage / health in creative mode if not void damage
return;
}
}
@ -1630,27 +1631,12 @@ bool cPlayer::LoadFromDisk()
m_CurrentXp = (short) root.get("xpCurrent", 0).asInt();
m_IsFlying = root.get("isflying", 0).asBool();
//SetExperience(root.get("experience", 0).asInt());
m_GameMode = (eGameMode) root.get("gamemode", eGameMode_NotSet).asInt();
if (m_GameMode == eGameMode_Creative)
{
m_CanFly = true;
}
else if (m_GameMode == eGameMode_NotSet)
{
cWorld * World = cRoot::Get()->GetWorld(GetLoadedWorldName());
if (World == NULL)
{
World = cRoot::Get()->GetDefaultWorld();
}
if (World->GetGameMode() == eGameMode_Creative)
{
m_CanFly = true;
}
}
m_Inventory.LoadFromJson(root["inventory"]);
@ -1767,85 +1753,6 @@ void cPlayer::UseEquippedItem(void)
void cPlayer::SetSwimState(cChunk & a_Chunk)
{
int RelY = (int)floor(m_LastPosY + 0.1);
if ((RelY < 0) || (RelY >= cChunkDef::Height - 1))
{
m_IsSwimming = false;
m_IsSubmerged = false;
return;
}
BLOCKTYPE BlockIn;
int RelX = (int)floor(m_LastPosX) - a_Chunk.GetPosX() * cChunkDef::Width;
int RelZ = (int)floor(m_LastPosZ) - a_Chunk.GetPosZ() * cChunkDef::Width;
// Check if the player is swimming:
// Use Unbounded, because we're being called *after* processing super::Tick(), which could have changed our chunk
if (!a_Chunk.UnboundedRelGetBlockType(RelX, RelY, RelZ, BlockIn))
{
// This sometimes happens on Linux machines
// Ref.: http://forum.mc-server.org/showthread.php?tid=1244
LOGD("SetSwimState failure: RelX = %d, RelZ = %d, LastPos = {%.02f, %.02f}, Pos = %.02f, %.02f}",
RelX, RelY, m_LastPosX, m_LastPosZ, GetPosX(), GetPosZ()
);
m_IsSwimming = false;
m_IsSubmerged = false;
return;
}
m_IsSwimming = IsBlockWater(BlockIn);
// Check if the player is submerged:
VERIFY(a_Chunk.UnboundedRelGetBlockType(RelX, RelY + 1, RelZ, BlockIn));
m_IsSubmerged = IsBlockWater(BlockIn);
}
void cPlayer::HandleAir(void)
{
// Ref.: http://www.minecraftwiki.net/wiki/Chunk_format
// see if the player is /submerged/ water (block above is water)
// Get the type of block the player's standing in:
if (IsSubmerged())
{
// either reduce air level or damage player
if (m_AirLevel < 1)
{
if (m_AirTickTimer < 1)
{
// damage player
TakeDamage(dtDrowning, NULL, 1, 1, 0);
// reset timer
m_AirTickTimer = DROWNING_TICKS;
}
else
{
m_AirTickTimer -= 1;
}
}
else
{
// reduce air supply
m_AirLevel -= 1;
}
}
else
{
// set the air back to maximum
m_AirLevel = MAX_AIR_LEVEL;
m_AirTickTimer = DROWNING_TICKS;
}
}
void cPlayer::HandleFood(void)
{
// Ref.: http://www.minecraftwiki.net/wiki/Hunger

24
src/Entities/Player.h
View File

@ -31,8 +31,6 @@ public:
MAX_HEALTH = 20,
MAX_FOOD_LEVEL = 20,
EATING_TICKS = 30, ///< Number of ticks it takes to eat an item
MAX_AIR_LEVEL = 300,
DROWNING_TICKS = 10, //number of ticks per heart of damage
} ;
// tolua_end
@ -241,8 +239,6 @@ public:
int GetFoodTickTimer (void) const { return m_FoodTickTimer; }
double GetFoodExhaustionLevel (void) const { return m_FoodExhaustionLevel; }
int GetFoodPoisonedTicksRemaining(void) const { return m_FoodPoisonedTicksRemaining; }
int GetAirLevel (void) const { return m_AirLevel; }
/// Returns true if the player is satiated, i. e. their foodlevel is at the max and they cannot eat anymore
bool IsSatiated(void) const { return (m_FoodLevel >= MAX_FOOD_LEVEL); }
@ -353,12 +349,6 @@ public:
/// If true the player can fly even when he's not in creative.
void SetCanFly(bool a_CanFly);
/// Returns whether the player is swimming or not
virtual bool IsSwimming(void) const{ return m_IsSwimming; }
/// Return whether the player is under water or not
virtual bool IsSubmerged(void) const{ return m_IsSubmerged; }
/// Returns wheter the player can fly or not.
virtual bool CanFly(void) const { return m_CanFly; }
// tolua_end
@ -389,12 +379,6 @@ protected:
XP_TO_LEVEL30 = 825
} ;
/// Player's air level (for swimming)
int m_AirLevel;
/// used to time ticks between damage taken via drowning/suffocation
int m_AirTickTimer;
bool m_bVisible;
// Food-related variables:
@ -431,7 +415,7 @@ protected:
float m_LastBlockActionTime;
int m_LastBlockActionCnt;
eGameMode m_GameMode;
std::string m_IP;
AString m_IP;
/// The item being dragged by the cursor while in a UI window
cItem m_DraggingItem;
@ -490,12 +474,6 @@ protected:
/// Called in each tick if the player is fishing to make sure the floater dissapears when the player doesn't have a fishing rod as equipped item.
void HandleFloater(void);
/// Called in each tick to handle air-related processing i.e. drowning
void HandleAir();
/// Called once per tick to set IsSwimming and IsSubmerged
void SetSwimState(cChunk & a_Chunk);
/// Adds food exhaustion based on the difference between Pos and LastPos, sprinting status and swimming (in water block)
void ApplyFoodExhaustionFromMovement();

9
src/Generating/ChunkGenerator.cpp
View File

@ -201,7 +201,7 @@ void cChunkGenerator::Execute(void)
while (!m_ShouldTerminate)
{
cCSLock Lock(m_CS);
while (m_Queue.size() == 0)
while (m_Queue.empty())
{
if ((NumChunksGenerated > 16) && (clock() - LastReportTick > CLOCKS_PER_SEC))
{
@ -221,6 +221,13 @@ void cChunkGenerator::Execute(void)
LastReportTick = clock();
}
if (m_Queue.empty())
{
// Sometimes the queue remains empty
// If so, we can't do any front() operations on it!
continue;
}
cChunkCoords coords = m_Queue.front(); // Get next coord from queue
m_Queue.erase( m_Queue.begin() ); // Remove coordinate from queue
bool SkipEnabled = (m_Queue.size() > QUEUE_SKIP_LIMIT);

4
src/MobProximityCounter.cpp
View File

@ -59,7 +59,7 @@ cMobProximityCounter::sIterablePair cMobProximityCounter::getMobWithinThosesDist
{
if (toReturn.m_Begin == m_DistanceToMonster.end())
{
if (a_DistanceMin == -1 || itr->first > a_DistanceMin)
if ((a_DistanceMin == 1) || (itr->first > a_DistanceMin))
{
toReturn.m_Begin = itr; // this is the first one with distance > a_DistanceMin;
}
@ -67,7 +67,7 @@ cMobProximityCounter::sIterablePair cMobProximityCounter::getMobWithinThosesDist
if (toReturn.m_Begin != m_DistanceToMonster.end())
{
if (a_DistanceMax != -1 && itr->first > a_DistanceMax)
if ((a_DistanceMax != 1) && (itr->first > a_DistanceMax))
{
toReturn.m_End = itr; // this is just after the last one with distance < a_DistanceMax
// Note : if we are not going through this, it's ok, toReturn.m_End will be end();

69
src/Mobs/AggressiveMonster.cpp
View File

@ -4,7 +4,6 @@
#include "AggressiveMonster.h"
#include "../World.h"
#include "../Vector3f.h"
#include "../Entities/Player.h"
#include "../MersenneTwister.h"
@ -13,8 +12,7 @@
cAggressiveMonster::cAggressiveMonster(const AString & a_ConfigName, eType 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_ChaseTime(999999)
super(a_ConfigName, a_MobType, a_SoundHurt, a_SoundDeath, a_Width, a_Height)
{
m_EMPersonality = AGGRESSIVE;
}
@ -27,32 +25,23 @@ cAggressiveMonster::cAggressiveMonster(const AString & a_ConfigName, eType a_Mob
void cAggressiveMonster::InStateChasing(float a_Dt)
{
super::InStateChasing(a_Dt);
m_ChaseTime += a_Dt;
if (m_Target != NULL)
{
if (m_Target->IsPlayer())
{
cPlayer * Player = (cPlayer *) m_Target;
if (Player->IsGameModeCreative())
if (((cPlayer *)m_Target)->IsGameModeCreative())
{
m_EMState = IDLE;
return;
}
}
Vector3f Pos = Vector3f( GetPosition() );
Vector3f Their = Vector3f( m_Target->GetPosition() );
if ((Their - Pos).Length() <= m_AttackRange)
if (((float)m_FinalDestination.x != (float)m_Target->GetPosX()) || ((float)m_FinalDestination.z != (float)m_Target->GetPosZ()))
{
Attack(a_Dt);
MoveToPosition(m_Target->GetPosition());
}
MoveToPosition(Their + Vector3f(0, 0.65f, 0));
}
else if (m_ChaseTime > 5.f)
{
m_ChaseTime = 0;
m_EMState = IDLE;
}
}
@ -61,8 +50,11 @@ void cAggressiveMonster::InStateChasing(float a_Dt)
void cAggressiveMonster::EventSeePlayer(cEntity * a_Entity)
{
super::EventSeePlayer(a_Entity);
m_EMState = CHASING;
if (!((cPlayer *)a_Entity)->IsGameModeCreative())
{
super::EventSeePlayer(a_Entity);
m_EMState = CHASING;
}
}
@ -73,25 +65,32 @@ void cAggressiveMonster::Tick(float a_Dt, cChunk & a_Chunk)
{
super::Tick(a_Dt, a_Chunk);
m_SeePlayerInterval += a_Dt;
if (m_SeePlayerInterval > 1)
if (m_EMState == CHASING)
{
int rem = m_World->GetTickRandomNumber(3) + 1; // Check most of the time but miss occasionally
m_SeePlayerInterval = 0.0;
if (rem >= 2)
{
if (m_EMState == CHASING)
{
CheckEventLostPlayer();
}
else
{
CheckEventSeePlayer();
}
}
CheckEventLostPlayer();
}
else
{
CheckEventSeePlayer();
}
}
void cAggressiveMonster::Attack(float a_Dt)
{
super::Attack(a_Dt);
if ((m_Target != NULL) && (m_AttackInterval > 3.0))
{
// Setting this higher gives us more wiggle room for attackrate
m_AttackInterval = 0.0;
m_Target->TakeDamage(dtMobAttack, this, m_AttackDamage, 0);
}
}

5
src/Mobs/AggressiveMonster.h
View File

@ -13,16 +13,15 @@ class cAggressiveMonster :
typedef cMonster super;
public:
cAggressiveMonster(const AString & a_ConfigName, eType a_MobType, const AString & a_SoundHurt, const AString & a_SoundDeath, double a_Width, double a_Height);
virtual void Tick (float a_Dt, cChunk & a_Chunk) override;
virtual void InStateChasing(float a_Dt) override;
virtual void EventSeePlayer(cEntity *) override;
virtual void Attack(float a_Dt) override;
protected:
float m_ChaseTime;
} ;

53
src/Mobs/Creeper.cpp
View File

@ -3,6 +3,7 @@
#include "Creeper.h"
#include "../World.h"
#include "../Entities/ProjectileEntity.h"
@ -11,7 +12,8 @@
cCreeper::cCreeper(void) :
super("Creeper", mtCreeper, "mob.creeper.say", "mob.creeper.say", 0.6, 1.8),
m_bIsBlowing(false),
m_bIsCharged(false)
m_bIsCharged(false),
m_ExplodingTimer(0)
{
}
@ -19,11 +21,34 @@ cCreeper::cCreeper(void) :
void cCreeper::Tick(float a_Dt, cChunk & a_Chunk)
{
super::Tick(a_Dt, a_Chunk);
if (!ReachedFinalDestination())
{
m_ExplodingTimer = 0;
m_bIsBlowing = false;
m_World->BroadcastEntityMetadata(*this);
}
}
void cCreeper::GetDrops(cItems & a_Drops, cEntity * a_Killer)
{
AddRandomDropItem(a_Drops, 0, 2, E_ITEM_GUNPOWDER);
// TODO Check if killed by a skeleton, then drop random music disk
if ((a_Killer != NULL) && (a_Killer->IsProjectile()))
{
if (((cMonster *)((cProjectileEntity *)a_Killer)->GetCreator())->GetMobType() == mtSkeleton)
{
// 12 music discs. TickRand starts from 0, so range = 11. Disk IDs start at 2256, so add that. There.
AddRandomDropItem(a_Drops, 1, 1, (short)m_World->GetTickRandomNumber(11) + 2256);
}
}
}
@ -45,3 +70,27 @@ void cCreeper::DoTakeDamage(TakeDamageInfo & a_TDI)
void cCreeper::Attack(float a_Dt)
{
UNUSED(a_Dt);
m_ExplodingTimer += 1;
if (!m_bIsBlowing)
{
m_World->BroadcastSoundEffect("random.fuse", (int)GetPosX() * 8, (int)GetPosY() * 8, (int)GetPosZ() * 8, 1.f, (float)(0.75 + ((float)((GetUniqueID() * 23) % 32)) / 64));
m_bIsBlowing = true;
m_World->BroadcastEntityMetadata(*this);
}
if (m_ExplodingTimer == 20)
{
m_World->DoExplosionAt((m_bIsCharged ? 5 : 3), GetPosX(), GetPosY(), GetPosZ(), false, esMonster, this);
Destroy();
}
}

3
src/Mobs/Creeper.h
View File

@ -19,6 +19,8 @@ public:
virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override;
virtual void DoTakeDamage(TakeDamageInfo & a_TDI) override;
virtual void Attack(float a_Dt) override;
virtual void Tick(float a_Dt, cChunk & a_Chunk) override;
bool IsBlowing(void) const {return m_bIsBlowing; }
bool IsCharged(void) const {return m_bIsCharged; }
@ -26,6 +28,7 @@ public:
private:
bool m_bIsBlowing, m_bIsCharged;
int m_ExplodingTimer;
} ;

4
src/Mobs/IronGolem.h
View File

@ -18,6 +18,10 @@ public:
CLASS_PROTODEF(cIronGolem);
virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override;
// Iron golems do not drown
virtual void HandleAir(void) override {}
virtual void SetSwimState(cChunk & a_Chunk) override {}
} ;

456
src/Mobs/Monster.cpp
View File

@ -8,14 +8,9 @@
#include "../World.h"
#include "../Entities/Player.h"
#include "../Entities/ExpOrb.h"
#include "../Defines.h"
#include "../MonsterConfig.h"
#include "../MersenneTwister.h"
#include "../Vector3f.h"
#include "../Vector3i.h"
#include "../Vector3d.h"
#include "../Tracer.h"
#include "../Chunk.h"
#include "../FastRandom.h"
@ -79,17 +74,15 @@ cMonster::cMonster(const AString & a_ConfigName, eType a_MobType, const AString
, m_AttackRate(3)
, m_IdleInterval(0)
, m_bMovingToDestination(false)
, m_DestinationTime( 0 )
, m_DestroyTimer( 0 )
, m_Jump(0)
, m_DestroyTimer(0)
, m_MobType(a_MobType)
, m_SoundHurt(a_SoundHurt)
, m_SoundDeath(a_SoundDeath)
, m_SeePlayerInterval (0)
, m_AttackDamage(1.0f)
, m_AttackRange(2.0f)
, m_AttackDamage(1)
, m_AttackRange(2)
, m_AttackInterval(0)
, m_BurnsInDaylight(false)
, m_LastGroundHeight(POSY_TOINT)
{
if (!a_ConfigName.empty())
{
@ -110,11 +103,105 @@ void cMonster::SpawnOn(cClientHandle & a_Client)
void cMonster::MoveToPosition( const Vector3f & a_Position )
void cMonster::TickPathFinding()
{
m_bMovingToDestination = true;
int PosX = (int)floor(GetPosX());
int PosY = (int)floor(GetPosY());
int PosZ = (int)floor(GetPosZ());
m_Destination = a_Position;
m_FinalDestination.y = (double)FindFirstNonAirBlockPosition(m_FinalDestination.x, m_FinalDestination.z);
std::vector<Vector3d> m_PotentialCoordinates;
m_TraversedCoordinates.push_back(Vector3i(PosX, PosY, PosZ));
static const struct // Define which directions to try to move to
{
int x, z;
} gCrossCoords[] =
{
{ 1, 0},
{-1, 0},
{ 0, 1},
{ 0,-1},
} ;
for (size_t i = 0; i < ARRAYCOUNT(gCrossCoords); i++)
{
if ((gCrossCoords[i].x + PosX == PosX) && (gCrossCoords[i].z + PosZ == PosZ))
{
continue;
}
if (IsCoordinateInTraversedList(Vector3i(gCrossCoords[i].x + PosX, PosY, gCrossCoords[i].z + PosZ)))
{
continue;
}
BLOCKTYPE BlockAtY = m_World->GetBlock(gCrossCoords[i].x + PosX, PosY, gCrossCoords[i].z + PosZ);
BLOCKTYPE BlockAtYP = m_World->GetBlock(gCrossCoords[i].x + PosX, PosY + 1, gCrossCoords[i].z + PosZ);
BLOCKTYPE BlockAtYPP = m_World->GetBlock(gCrossCoords[i].x + PosX, PosY + 2, gCrossCoords[i].z + PosZ);
BLOCKTYPE BlockAtYM = m_World->GetBlock(gCrossCoords[i].x + PosX, PosY - 1, gCrossCoords[i].z + PosZ);
if (!g_BlockIsSolid[BlockAtY] && !g_BlockIsSolid[BlockAtYP] && !IsBlockLava(BlockAtYM))
{
m_PotentialCoordinates.push_back(Vector3d((gCrossCoords[i].x + PosX), PosY, gCrossCoords[i].z + PosZ));
}
else if (g_BlockIsSolid[BlockAtY] && !g_BlockIsSolid[BlockAtYP] && !g_BlockIsSolid[BlockAtYPP] && !IsBlockLava(BlockAtYM))
{
m_PotentialCoordinates.push_back(Vector3d((gCrossCoords[i].x + PosX), PosY + 1, gCrossCoords[i].z + PosZ));
}
}
if (!m_PotentialCoordinates.empty())
{
Vector3f ShortestCoords = m_PotentialCoordinates.front();
for (std::vector<Vector3d>::const_iterator itr = m_PotentialCoordinates.begin(); itr != m_PotentialCoordinates.end(); ++itr)
{
Vector3f Distance = m_FinalDestination - ShortestCoords;
Vector3f Distance2 = m_FinalDestination - *itr;
if (Distance.SqrLength() > Distance2.SqrLength())
{
ShortestCoords = *itr;
}
}
m_Destination = ShortestCoords;
m_Destination.z += 0.5f;
m_Destination.x += 0.5f;
}
else
{
FinishPathFinding();
}
}
void cMonster::MoveToPosition(const Vector3f & a_Position)
{
FinishPathFinding();
m_FinalDestination = a_Position;
m_bMovingToDestination = true;
TickPathFinding();
}
bool cMonster::IsCoordinateInTraversedList(Vector3i a_Coords)
{
for (std::vector<Vector3i>::const_iterator itr = m_TraversedCoordinates.begin(); itr != m_TraversedCoordinates.end(); ++itr)
{
if (itr->Equals(a_Coords))
{
return true;
}
}
return false;
}
@ -123,9 +210,10 @@ void cMonster::MoveToPosition( const Vector3f & a_Position )
bool cMonster::ReachedDestination()
{
Vector3f Distance = (m_Destination) - GetPosition();
if( Distance.SqrLength() < 2.f )
if ((m_Destination - GetPosition()).Length() < 0.5f)
{
return true;
}
return false;
}
@ -133,6 +221,19 @@ bool cMonster::ReachedDestination()
bool cMonster::ReachedFinalDestination()
{
if ((GetPosition() - m_FinalDestination).Length() <= m_AttackRange)
{
return true;
}
return false;
}
void cMonster::Tick(float a_Dt, cChunk & a_Chunk)
{
@ -149,25 +250,35 @@ void cMonster::Tick(float a_Dt, cChunk & a_Chunk)
return;
}
if ((m_Target != NULL) && m_Target->IsDestroyed())
m_Target = NULL;
// Burning in daylight
HandleDaylightBurning(a_Chunk);
HandlePhysics(a_Dt,a_Chunk);
BroadcastMovementUpdate();
a_Dt /= 1000;
if (m_bMovingToDestination)
{
Vector3f Pos( GetPosition() );
Vector3f Distance = m_Destination - Pos;
if( !ReachedDestination() )
if (m_bOnGround)
{
m_Destination.y = FindFirstNonAirBlockPosition(m_Destination.x, m_Destination.z);
if (DoesPosYRequireJump(m_Destination.y))
{
m_bOnGround = false;
AddPosY(1.5); // Jump!!
}
}
Vector3f Distance = m_Destination - GetPosition();
if(!ReachedDestination() && !ReachedFinalDestination()) // If we haven't reached any sort of destination, move
{
Distance.y = 0;
Distance.Normalize();
Distance *= 3;
SetSpeedX( Distance.x );
SetSpeedZ( Distance.z );
SetSpeedX(Distance.x);
SetSpeedZ(Distance.z);
if (m_EMState == ESCAPING)
{ //Runs Faster when escaping :D otherwise they just walk away
@ -177,40 +288,22 @@ void cMonster::Tick(float a_Dt, cChunk & a_Chunk)
}
else
{
m_bMovingToDestination = false;
}
if( GetSpeed().SqrLength() > 0.f )
{
if( m_bOnGround )
if (ReachedFinalDestination()) // If we have reached the ultimate, final destination, stop pathfinding and attack if appropriate
{
Vector3f NormSpeed = Vector3f(GetSpeed()).NormalizeCopy();
Vector3f NextBlock = Vector3f( GetPosition() ) + NormSpeed;
int NextHeight;
if (!m_World->TryGetHeight((int)NextBlock.x, (int)NextBlock.z, NextHeight))
{
// The chunk at NextBlock is not loaded
return;
}
if( NextHeight > (GetPosY() - 1.0) && (NextHeight - GetPosY()) < 2.5 )
{
m_bOnGround = false;
SetSpeedY(5.f); // Jump!!
}
FinishPathFinding();
}
else
{
TickPathFinding(); // We have reached the next point in our path, calculate another point
}
}
}
Vector3d Distance = m_Destination - GetPosition();
if (Distance.SqrLength() > 0.1f)
{
double Rotation, Pitch;
Distance.Normalize();
VectorToEuler( Distance.x, Distance.y, Distance.z, Rotation, Pitch );
SetHeadYaw (Rotation);
SetYaw( Rotation );
SetPitch( -Pitch );
}
if (ReachedFinalDestination() && (m_Target != NULL))
Attack(a_Dt);
SetPitchAndYawFromDestination();
HandleFalling();
switch (m_EMState)
{
@ -219,21 +312,113 @@ void cMonster::Tick(float a_Dt, cChunk & a_Chunk)
// If enemy passive we ignore checks for player visibility
InStateIdle(a_Dt);
break;
}
}
case CHASING:
{
// If we do not see a player anymore skip chasing action
InStateChasing(a_Dt);
break;
}
}
case ESCAPING:
{
InStateEscaping(a_Dt);
break;
}
} // switch (m_EMState)
BroadcastMovementUpdate();
}
void cMonster::SetPitchAndYawFromDestination()
{
Vector3d FinalDestination = m_FinalDestination;
if (m_Target != NULL)
{
if (m_Target->IsPlayer())
{
FinalDestination.y = ((cPlayer *)m_Target)->GetStance();
}
else
{
FinalDestination.y = GetHeight();
}
}
Vector3d Distance = FinalDestination - GetPosition();
if (Distance.SqrLength() > 0.1f)
{
{
double Rotation, Pitch;
Distance.Normalize();
VectorToEuler(Distance.x, Distance.y, Distance.z, Rotation, Pitch);
SetHeadYaw(Rotation);
SetPitch(-Pitch);
}
{
Vector3d BodyDistance = m_Destination - GetPosition();
double Rotation, Pitch;
Distance.Normalize();
VectorToEuler(BodyDistance.x, BodyDistance.y, BodyDistance.z, Rotation, Pitch);
SetYaw(Rotation);
}
}
}
void cMonster::HandleFalling()
{
if (m_bOnGround)
{
int Damage = (m_LastGroundHeight - POSY_TOINT) - 3;
if (Damage > 0)
{
TakeDamage(dtFalling, NULL, Damage, Damage, 0);
// Fall particles
GetWorld()->BroadcastSoundParticleEffect(2006, POSX_TOINT, POSY_TOINT - 1, POSZ_TOINT, Damage /* Used as particle effect speed modifier */);
}
m_LastGroundHeight = (int)floor(GetPosY());
}
}
int cMonster::FindFirstNonAirBlockPosition(double a_PosX, double a_PosZ)
{
int PosY = (int)floor(GetPosY());
if (PosY < 0)
PosY = 0;
else if (PosY > cChunkDef::Height)
PosY = cChunkDef::Height;
if (!g_BlockIsSolid[m_World->GetBlock((int)floor(a_PosX), PosY, (int)floor(a_PosZ))])
{
while (!g_BlockIsSolid[m_World->GetBlock((int)floor(a_PosX), PosY, (int)floor(a_PosZ))] && (PosY > 0))
{
PosY--;
}
return PosY + 1;
}
else
{
while (g_BlockIsSolid[m_World->GetBlock((int)floor(a_PosX), PosY, (int)floor(a_PosZ))] && (PosY < cChunkDef::Height))
{
PosY++;
}
return PosY;
}
}
@ -244,11 +429,13 @@ void cMonster::Tick(float a_Dt, cChunk & a_Chunk)
void cMonster::DoTakeDamage(TakeDamageInfo & a_TDI)
{
super::DoTakeDamage(a_TDI);
if((m_SoundHurt != "") && (m_Health > 0)) m_World->BroadcastSoundEffect(m_SoundHurt, (int)(GetPosX() * 8), (int)(GetPosY() * 8), (int)(GetPosZ() * 8), 1.0f, 0.8f);
if((m_SoundHurt != "") && (m_Health > 0))
m_World->BroadcastSoundEffect(m_SoundHurt, (int)(GetPosX() * 8), (int)(GetPosY() * 8), (int)(GetPosZ() * 8), 1.0f, 0.8f);
if (a_TDI.Attacker != NULL)
{
m_Target = a_TDI.Attacker;
AddReference(m_Target);
}
}
@ -330,55 +517,12 @@ void cMonster::KilledBy(cEntity * a_Killer)
//----State Logic
const char *cMonster::GetState()
{
switch(m_EMState)
{
case IDLE: return "Idle";
case ATTACKING: return "Attacking";
case CHASING: return "Chasing";
default: return "Unknown";
}
}
// for debugging
void cMonster::SetState(const AString & a_State)
{
if (a_State.compare("Idle") == 0)
{
m_EMState = IDLE;
}
else if (a_State.compare("Attacking") == 0)
{
m_EMState = ATTACKING;
}
else if (a_State.compare("Chasing") == 0)
{
m_EMState = CHASING;
}
else
{
LOGD("cMonster::SetState(): Invalid state");
ASSERT(!"Invalid state");
}
}
//Checks to see if EventSeePlayer should be fired
//monster sez: Do I see the player
void cMonster::CheckEventSeePlayer(void)
{
// TODO: Rewrite this to use cWorld's DoWithPlayers()
cPlayer * Closest = FindClosestPlayer();
cPlayer * Closest = m_World->FindClosestPlayer(GetPosition(), (float)m_SightDistance, false);
if (Closest != NULL)
{
@ -391,14 +535,10 @@ void cMonster::CheckEventSeePlayer(void)
void cMonster::CheckEventLostPlayer(void)
{
Vector3f pos;
cTracer LineOfSight(GetWorld());
{
if (m_Target != NULL)
{
pos = m_Target->GetPosition();
if ((pos - GetPosition()).Length() > m_SightDistance || LineOfSight.Trace(GetPosition(),(pos - GetPosition()), (int)(pos - GetPosition()).Length()))
if ((m_Target->GetPosition() - GetPosition()).Length() > m_SightDistance)
{
EventLosePlayer();
}
@ -418,7 +558,6 @@ void cMonster::CheckEventLostPlayer(void)
void cMonster::EventSeePlayer(cEntity * a_SeenPlayer)
{
m_Target = a_SeenPlayer;
AddReference(m_Target);
}
@ -427,7 +566,6 @@ void cMonster::EventSeePlayer(cEntity * a_SeenPlayer)
void cMonster::EventLosePlayer(void)
{
Dereference(m_Target);
m_Target = NULL;
m_EMState = IDLE;
}
@ -436,28 +574,35 @@ void cMonster::EventLosePlayer(void)
// What to do if in Idle State
void cMonster::InStateIdle(float a_Dt)
{
if (m_bMovingToDestination)
{
return; // Still getting there
}
m_IdleInterval += a_Dt;
if (m_IdleInterval > 1)
{
// at this interval the results are predictable
// At this interval the results are predictable
int rem = m_World->GetTickRandomNumber(6) + 1;
// LOGD("Moving: int: %3.3f rem: %i",idle_interval,rem);
m_IdleInterval -= 1; // So nothing gets dropped when the server hangs for a few seconds
Vector3f Dist;
Dist.x = (float)(m_World->GetTickRandomNumber(10) - 5);
Dist.z = (float)(m_World->GetTickRandomNumber(10) - 5);
m_IdleInterval -= 1; // So nothing gets dropped when the server hangs for a few seconds
Vector3d Dist;
Dist.x = (double)m_World->GetTickRandomNumber(10) - 5;
Dist.z = (double)m_World->GetTickRandomNumber(10) - 5;
if ((Dist.SqrLength() > 2) && (rem >= 3))
{
m_Destination.x = (float)(GetPosX() + Dist.x);
m_Destination.z = (float)(GetPosZ() + Dist.z);
int PosY;
if (m_World->TryGetHeight((int)m_Destination.x, (int)m_Destination.z, PosY))
Vector3d Destination(GetPosX() + Dist.x, 0, GetPosZ() + Dist.z);
int NextHeight = FindFirstNonAirBlockPosition(Destination.x, Destination.z);
if (IsNextYPosReachable(NextHeight))
{
m_Destination.y = (float)PosY + 1.2f;
MoveToPosition(m_Destination);
Destination.y = NextHeight;
MoveToPosition(Destination);
}
}
}
@ -505,22 +650,6 @@ void cMonster::InStateEscaping(float a_Dt)
void cMonster::Attack(float a_Dt)
{
m_AttackInterval += a_Dt * m_AttackRate;
if ((m_Target != NULL) && (m_AttackInterval > 3.0))
{
// Setting this higher gives us more wiggle room for attackrate
m_AttackInterval = 0.0;
((cPawn *)m_Target)->TakeDamage(*this);
}
}
// Checks for Players close by and if they are visible return the closest
cPlayer * cMonster::FindClosestPlayer(void)
{
return m_World->FindClosestPlayer(GetPosition(), m_SightDistance);
}
@ -536,42 +665,6 @@ void cMonster::GetMonsterConfig(const AString & a_Name)
void cMonster::SetAttackRate(int ar)
{
m_AttackRate = (float)ar;
}
void cMonster::SetAttackRange(float ar)
{
m_AttackRange = ar;
}
void cMonster::SetAttackDamage(float ad)
{
m_AttackDamage = ad;
}
void cMonster::SetSightDistance(float sd)
{
m_SightDistance = sd;
}
AString cMonster::MobTypeToString(cMonster::eType a_MobType)
{
// Mob types aren't sorted, so we need to search linearly:
@ -635,6 +728,8 @@ cMonster::eType cMonster::StringToMobType(const AString & a_Name)
cMonster::eFamily cMonster::FamilyFromType(eType a_Type)
{
// Passive-agressive mobs are counted in mob spawning code as passive
switch (a_Type)
{
case mtBat: return mfAmbient;
@ -699,7 +794,7 @@ cMonster * cMonster::NewMonsterFromType(cMonster::eType a_MobType)
case mtMagmaCube:
case mtSlime:
{
toReturn = new cSlime (Random.NextInt(2) + 1);
toReturn = new cSlime(Random.NextInt(2) + 1);
break;
}
case mtSkeleton:
@ -803,6 +898,13 @@ void cMonster::HandleDaylightBurning(cChunk & a_Chunk)
int RelX = (int)floor(GetPosX()) - GetChunkX() * cChunkDef::Width;
int RelZ = (int)floor(GetPosZ()) - GetChunkZ() * cChunkDef::Width;
if (!a_Chunk.IsLightValid())
{
m_World->QueueLightChunk(GetChunkX(), GetChunkZ());
return;
}
if (
(a_Chunk.GetSkyLight(RelX, RelY, RelZ) == 15) && // In the daylight
(a_Chunk.GetBlock(RelX, RelY, RelZ) != E_BLOCK_SOULSAND) && // Not on soulsand

90
src/Mobs/Monster.h
View File

@ -10,7 +10,6 @@
class Vector3f;
class cClientHandle;
class cWorld;
@ -74,8 +73,6 @@ public:
enum MState{ATTACKING, IDLE, CHASING, ESCAPING} m_EMState;
enum MPersonality{PASSIVE,AGGRESSIVE,COWARDLY} m_EMPersonality;
float m_SightDistance;
/** Creates the mob object.
* If a_ConfigName is not empty, the configuration is loaded using GetMonsterConfig()
* a_MobType is the type of the mob (also used in the protocol ( http://wiki.vg/Entities#Mobs , 2012_12_22))
@ -100,14 +97,9 @@ public:
eType GetMobType(void) const {return m_MobType; }
eFamily GetMobFamily(void) const;
// tolua_end
const char * GetState();
void SetState(const AString & str);
virtual void CheckEventSeePlayer(void);
virtual void EventSeePlayer(cEntity * a_Player);
virtual cPlayer * FindClosestPlayer(); // non static is easier. also virtual so other mobs can implement their own searching algo
/// Reads the monster configuration for the specified monster name and assigns it to this object.
void GetMonsterConfig(const AString & a_Name);
@ -121,11 +113,11 @@ public:
virtual void Attack(float a_Dt);
int GetAttackRate(){return (int)m_AttackRate;}
void SetAttackRate(int ar);
void SetAttackRange(float ar);
void SetAttackDamage(float ad);
void SetSightDistance(float sd);
int GetAttackRate() { return (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; }
/// Sets whether the mob burns in daylight. Only evaluated at next burn-decision tick
void SetBurnsInDaylight(bool a_BurnsInDaylight) { m_BurnsInDaylight = a_BurnsInDaylight; }
@ -159,34 +151,80 @@ public:
protected:
/* ======= PATHFINDING ======= */
/** A pointer to the entity this mobile is aiming to reach */
cEntity * m_Target;
float m_AttackRate;
float m_IdleInterval;
/** Coordinates of the next position that should be reached */
Vector3d m_Destination;
/** Coordinates for the ultimate, final destination. */
Vector3d m_FinalDestination;
/** Returns if the ultimate, final destination has been reached */
bool ReachedFinalDestination(void);
Vector3f m_Destination;
/** Stores if mobile is currently moving towards the ultimate, final destination */
bool m_bMovingToDestination;
bool m_bPassiveAggressive;
/** Finds the first non-air block position (not the highest, as cWorld::GetHeight does)
If current Y is nonsolid, goes down to try to find a solid block, then returns that + 1
If current Y is solid, goes up to find first nonsolid block, and returns that */
int FindFirstNonAirBlockPosition(double a_PosX, double a_PosZ);
/** Returns if a monster can actually reach a given height by jumping or walking */
inline bool IsNextYPosReachable(int a_PosY)
{
return (
(a_PosY <= (int)floor(GetPosY())) ||
DoesPosYRequireJump(a_PosY)
);
}
/** Returns if a monster can reach a given height by jumping */
inline bool DoesPosYRequireJump(int a_PosY)
{
return ((a_PosY > (int)floor(GetPosY())) && (a_PosY == (int)floor(GetPosY()) + 1));
}
float m_DestinationTime;
/** A semi-temporary list to store the traversed coordinates during active pathfinding so we don't visit them again */
std::vector<Vector3i> m_TraversedCoordinates;
/** Returns if coordinate is in the traversed list */
bool IsCoordinateInTraversedList(Vector3i a_Coords);
/** Finds the next place to go
This is based on the ultimate, final destination and the current position, as well as the traversed coordinates, and any environmental hazards */
void TickPathFinding(void);
/** Finishes a pathfinding task, be it due to failure or something else */
inline void FinishPathFinding(void)
{
m_TraversedCoordinates.clear();
m_bMovingToDestination = false;
}
/** Sets the body yaw and head yaw/pitch based on next/ultimate destinations */
void SetPitchAndYawFromDestination(void);
/* =========================== */
/* ========= FALLING ========= */
virtual void HandleFalling(void);
int m_LastGroundHeight;
/* =========================== */
float m_IdleInterval;
float m_DestroyTimer;
float m_Jump;
eType m_MobType;
AString m_SoundHurt;
AString m_SoundDeath;
float m_SeePlayerInterval;
float m_AttackDamage;
float m_AttackRange;
float m_AttackRate;
int m_AttackDamage;
int m_AttackRange;
float m_AttackInterval;
bool m_BurnsInDaylight;
void AddRandomDropItem(cItems & a_Drops, unsigned int a_Min, unsigned int a_Max, short a_Item, short a_ItemHealth = 0);
int m_SightDistance;
void HandleDaylightBurning(cChunk & a_Chunk);
bool m_BurnsInDaylight;
void AddRandomDropItem(cItems & a_Drops, unsigned int a_Min, unsigned int a_Max, short a_Item, short a_ItemHealth = 0);
} ; // tolua_export

3
src/Mobs/PassiveAggressiveMonster.cpp
View File

@ -25,8 +25,7 @@ void cPassiveAggressiveMonster::DoTakeDamage(TakeDamageInfo & a_TDI)
if ((m_Target != NULL) && (m_Target->IsPlayer()))
{
cPlayer * Player = (cPlayer *) m_Target;
if (Player->GetGameMode() != 1)
if (!((cPlayer *)m_Target)->IsGameModeCreative())
{
m_EMState = CHASING;
}

16
src/Mobs/PassiveMonster.cpp
View File

@ -2,7 +2,6 @@
#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules
#include "PassiveMonster.h"
#include "../MersenneTwister.h"
#include "../World.h"
@ -36,20 +35,9 @@ void cPassiveMonster::Tick(float a_Dt, cChunk & a_Chunk)
{
super::Tick(a_Dt, a_Chunk);
m_SeePlayerInterval += a_Dt;
if (m_SeePlayerInterval > 1) // Check every second
if (m_EMState == ESCAPING)
{
int rem = m_World->GetTickRandomNumber(3) + 1; // Check most of the time but miss occasionally
m_SeePlayerInterval = 0.0;
if (rem >= 2)
{
if (m_EMState == ESCAPING)
{
CheckEventLostPlayer();
}
}
CheckEventLostPlayer();
}
}

11
src/Mobs/Skeleton.cpp
View File

@ -30,15 +30,18 @@ void cSkeleton::GetDrops(cItems & a_Drops, cEntity * a_Killer)
void cSkeleton::MoveToPosition(const Vector3f & a_Position)
{
m_Destination = a_Position;
// If the destination is in the sun and if it is not night AND the skeleton isn't on fire then block the movement.
if (!IsOnFire() && m_World->GetTimeOfDay() < 13187 && m_World->GetBlockSkyLight((int) a_Position.x, (int) a_Position.y, (int) a_Position.z) == 15)
if (
!IsOnFire() &&
(m_World->GetTimeOfDay() < 13187) &&
(m_World->GetBlockSkyLight((int) a_Position.x, (int) a_Position.y, (int) a_Position.z) == 15)
)
{
m_bMovingToDestination = false;
return;
}
m_bMovingToDestination = true;
super::MoveToPosition(a_Position);
}

3
src/Mobs/Squid.h
View File

@ -21,6 +21,9 @@ public:
virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override;
// Squids do not drown (or float)
virtual void HandleAir(void) override {}
virtual void SetSwimState(cChunk & a_Chunk) override {}
} ;

36
src/Mobs/Wolf.cpp
View File

@ -37,6 +37,26 @@ void cWolf::DoTakeDamage(TakeDamageInfo & a_TDI)
void cWolf::Attack(float a_Dt)
{
UNUSED(a_Dt);
if ((m_Target != NULL) && (m_Target->IsPlayer()))
{
if (((cPlayer *)m_Target)->GetName() != m_OwnerName)
{
super::Attack(a_Dt);
}
}
else
{
super::Attack(a_Dt);
}
}
void cWolf::OnRightClicked(cPlayer & a_Player)
{
@ -108,7 +128,7 @@ void cWolf::Tick(float a_Dt, cChunk & a_Chunk)
m_bMovingToDestination = false;
}
cPlayer * a_Closest_Player = FindClosestPlayer();
cPlayer * a_Closest_Player = m_World->FindClosestPlayer(GetPosition(), (float)m_SightDistance);
if (a_Closest_Player != NULL)
{
switch (a_Closest_Player->GetEquippedItem().m_ItemType)
@ -125,9 +145,7 @@ void cWolf::Tick(float a_Dt, cChunk & a_Chunk)
SetIsBegging(true);
m_World->BroadcastEntityMetadata(*this);
}
Vector3f a_NewDestination = a_Closest_Player->GetPosition();
a_NewDestination.y = a_NewDestination.y + 1; // Look at the head of the player, not his feet.
m_Destination = Vector3f(a_NewDestination);
m_FinalDestination = a_Closest_Player->GetPosition();;
m_bMovingToDestination = false;
break;
}
@ -163,23 +181,19 @@ void cWolf::TickFollowPlayer()
return false;
}
public:
Vector3f OwnerPos;
Vector3d OwnerPos;
} Callback;
if (m_World->DoWithPlayer(m_OwnerName, Callback))
{
// The player is present in the world, follow them:
double Distance = (Callback.OwnerPos - GetPosition()).Length();
if (Distance < 3)
{
m_bMovingToDestination = false;
}
else if ((Distance > 30) && (!IsSitting()))
if ((Distance > 30) && (!IsSitting()))
{
TeleportToCoords(Callback.OwnerPos.x, Callback.OwnerPos.y, Callback.OwnerPos.z);
}
else
{
m_Destination = Callback.OwnerPos;
MoveToPosition(Callback.OwnerPos);
}
}
}

1
src/Mobs/Wolf.h
View File

@ -22,6 +22,7 @@ public:
virtual void OnRightClicked(cPlayer & a_Player) override;
virtual void Tick(float a_Dt, cChunk & a_Chunk) override;
virtual void TickFollowPlayer();
virtual void Attack(float a_Dt) override;
// Get functions
bool IsSitting (void) const { return m_IsSitting; }

13
src/Mobs/Zombie.cpp
View File

@ -34,15 +34,18 @@ void cZombie::GetDrops(cItems & a_Drops, cEntity * a_Killer)
void cZombie::MoveToPosition(const Vector3f & a_Position)
{
m_Destination = a_Position;
// If the destination is in the sun and if it is not night AND the skeleton isn't on fire then block the movement.
if ((m_World->GetBlockSkyLight((int) a_Position.x, (int) a_Position.y, (int) a_Position.z) == 15) && (m_World->GetTimeOfDay() < 13187) && !IsOnFire())
// If the destination is in the sun and if it is not night AND the zombie isn't on fire then block the movement.
if (
!IsOnFire() &&
(m_World->GetTimeOfDay() < 13187) &&
(m_World->GetBlockSkyLight((int)a_Position.x, (int)a_Position.y, (int)a_Position.z) == 15)
)
{
m_bMovingToDestination = false;
return;
}
m_bMovingToDestination = true;
super::MoveToPosition(a_Position);
}

20
src/MonsterConfig.cpp
View File

@ -12,9 +12,9 @@
struct cMonsterConfig::sAttributesStruct
{
AString m_Name;
double m_SightDistance;
double m_AttackDamage;
double m_AttackRange;
int m_SightDistance;
int m_AttackDamage;
int m_AttackRange;
double m_AttackRate;
int m_MaxHealth;
};
@ -67,9 +67,9 @@ void cMonsterConfig::Initialize()
sAttributesStruct Attributes;
AString Name = MonstersIniFile.GetKeyName(i);
Attributes.m_Name = Name;
Attributes.m_AttackDamage = MonstersIniFile.GetValueF(Name, "AttackDamage", 0);
Attributes.m_AttackRange = MonstersIniFile.GetValueF(Name, "AttackRange", 0);
Attributes.m_SightDistance = MonstersIniFile.GetValueF(Name, "SightDistance", 0);
Attributes.m_AttackDamage = MonstersIniFile.GetValueI(Name, "AttackDamage", 0);
Attributes.m_AttackRange = MonstersIniFile.GetValueI(Name, "AttackRange", 0);
Attributes.m_SightDistance = MonstersIniFile.GetValueI(Name, "SightDistance", 0);
Attributes.m_AttackRate = MonstersIniFile.GetValueF(Name, "AttackRate", 0);
Attributes.m_MaxHealth = MonstersIniFile.GetValueI(Name, "MaxHealth", 1);
m_pState->AttributesList.push_front(Attributes);
@ -87,10 +87,10 @@ void cMonsterConfig::AssignAttributes(cMonster * a_Monster, const AString & a_Na
{
if (itr->m_Name.compare(a_Name) == 0)
{
a_Monster->SetAttackDamage ((float)itr->m_AttackDamage);
a_Monster->SetAttackRange ((float)itr->m_AttackRange);
a_Monster->SetSightDistance((float)itr->m_SightDistance);
a_Monster->SetAttackRate ((int)itr->m_AttackRate);
a_Monster->SetAttackDamage (itr->m_AttackDamage);
a_Monster->SetAttackRange (itr->m_AttackRange);
a_Monster->SetSightDistance(itr->m_SightDistance);
a_Monster->SetAttackRate ((float)itr->m_AttackRate);
a_Monster->SetMaxHealth (itr->m_MaxHealth);
return;
}

43
src/ReferenceManager.cpp
View File

@ -1,43 +0,0 @@
#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules
#include "ReferenceManager.h"
#include "Entities/Entity.h"
cReferenceManager::cReferenceManager( ENUM_REFERENCE_MANAGER_TYPE a_Type )
: m_Type( a_Type )
{
}
cReferenceManager::~cReferenceManager()
{
if( m_Type == RFMNGR_REFERENCERS )
{
for( std::list< cEntity** >::iterator itr = m_References.begin(); itr != m_References.end(); ++itr )
{
*(*itr) = 0; // Set referenced pointer to 0
}
}
else
{
for( std::list< cEntity** >::iterator itr = m_References.begin(); itr != m_References.end(); ++itr )
{
cEntity* Ptr = (*(*itr));
if( Ptr ) Ptr->Dereference( *(*itr) );
}
}
}
void cReferenceManager::AddReference( cEntity*& a_EntityPtr )
{
m_References.push_back( &a_EntityPtr );
}
void cReferenceManager::Dereference( cEntity*& a_EntityPtr )
{
m_References.remove( &a_EntityPtr );
}

34
src/ReferenceManager.h
View File

@ -1,34 +0,0 @@
#pragma once
class cEntity;
class cReferenceManager
{
public:
enum ENUM_REFERENCE_MANAGER_TYPE
{
RFMNGR_REFERENCERS,
RFMNGR_REFERENCES,
};
cReferenceManager( ENUM_REFERENCE_MANAGER_TYPE a_Type );
~cReferenceManager();
void AddReference( cEntity*& a_EntityPtr );
void Dereference( cEntity*& a_EntityPtr );
private:
ENUM_REFERENCE_MANAGER_TYPE m_Type;
std::list< cEntity** > m_References;
};

2
src/Server.cpp
View File

@ -194,7 +194,7 @@ bool cServer::InitServer(cIniFile & a_SettingsIni)
m_PlayerCount = 0;
m_PlayerCountDiff = 0;
m_FaviconData = Base64Encode(cFile::ReadWholeFile("favicon.png")); // Will return empty string if file nonexistant; client doesn't mind
m_FaviconData = Base64Encode(cFile::ReadWholeFile(FILE_IO_PREFIX + AString("favicon.png"))); // Will return empty string if file nonexistant; client doesn't mind
if (m_bIsConnected)
{

13
src/World.cpp
View File

@ -234,7 +234,11 @@ cWorld::cWorld(const AString & a_WorldName) :
m_WorldName(a_WorldName),
m_IniFileName(m_WorldName + "/world.ini"),
m_StorageSchema("Default"),
#ifdef _arm_
m_StorageCompressionFactor(0),
#else
m_StorageCompressionFactor(6),
#endif
m_IsSpawnExplicitlySet(false),
m_WorldAgeSecs(0),
m_TimeOfDaySecs(0),
@ -2419,7 +2423,7 @@ bool cWorld::FindAndDoWithPlayer(const AString & a_PlayerNameHint, cPlayerListCa
// TODO: This interface is dangerous!
cPlayer * cWorld::FindClosestPlayer(const Vector3f & a_Pos, float a_SightLimit)
cPlayer * cWorld::FindClosestPlayer(const Vector3f & a_Pos, float a_SightLimit, bool a_CheckLineOfSight)
{
cTracer LineOfSight(this);
@ -2434,7 +2438,12 @@ cPlayer * cWorld::FindClosestPlayer(const Vector3f & a_Pos, float a_SightLimit)
if (Distance < ClosestDistance)
{
if (!LineOfSight.Trace(a_Pos,(Pos - a_Pos),(int)(Pos - a_Pos).Length()))
if (a_CheckLineOfSight && !LineOfSight.Trace(a_Pos,(Pos - a_Pos),(int)(Pos - a_Pos).Length()))
{
ClosestDistance = Distance;
ClosestPlayer = *itr;
}
else
{
ClosestDistance = Distance;
ClosestPlayer = *itr;

2
src/World.h
View File

@ -239,7 +239,7 @@ public:
bool FindAndDoWithPlayer(const AString & a_PlayerNameHint, cPlayerListCallback & a_Callback); // >> EXPORTED IN MANUALBINDINGS <<
// TODO: This interface is dangerous - rewrite to DoWithClosestPlayer(pos, sight, action)
cPlayer * FindClosestPlayer(const Vector3f & a_Pos, float a_SightLimit);
cPlayer * FindClosestPlayer(const Vector3f & a_Pos, float a_SightLimit, bool a_CheckLineOfSight = true);
void SendPlayerList(cPlayer * a_DestPlayer); // Sends playerlist to the player