28 files changed, 763 insertions, 293 deletions

diff --git a/src/Mobs/AggressiveMonster.cpp b/src/Mobs/AggressiveMonster.cpp
index cc7e7da2b..f2f0c404c 100644
--- a/src/Mobs/AggressiveMonster.cpp
+++ b/src/Mobs/AggressiveMonster.cpp
@@ -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)
+	{
+		CheckEventLostPlayer();
+	}
+	else
 	{
-		int rem = m_World->GetTickRandomNumber(3) + 1;  // Check most of the time but miss occasionally
+		CheckEventSeePlayer();
+	}
+}
 
-		m_SeePlayerInterval = 0.0;
-		if (rem >= 2)
-		{
-			if (m_EMState == CHASING)
-			{
-				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);
 	}
 }
 
 
+
+
diff --git a/src/Mobs/AggressiveMonster.h b/src/Mobs/AggressiveMonster.h
index 5a0d93f3d..9cee4e7a7 100644
--- a/src/Mobs/AggressiveMonster.h
+++ b/src/Mobs/AggressiveMonster.h
@@ -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;
 } ;
 
 
diff --git a/src/Mobs/Chicken.cpp b/src/Mobs/Chicken.cpp
index 087fd088a..fab92ce49 100644
--- a/src/Mobs/Chicken.cpp
+++ b/src/Mobs/Chicken.cpp
@@ -9,7 +9,6 @@
 
 
 
-
 cChicken::cChicken(void) :
 	super("Chicken", mtChicken, "mob.chicken.hurt", "mob.chicken.hurt", 0.3, 0.4),
 	m_EggDropTimer(0)
diff --git a/src/Mobs/Chicken.h b/src/Mobs/Chicken.h
index 979c4d8a0..a4c1d6b9e 100644
--- a/src/Mobs/Chicken.h
+++ b/src/Mobs/Chicken.h
@@ -19,8 +19,9 @@ public:
 	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override;
 	virtual void Tick(float a_Dt, cChunk & a_Chunk) override;
 
-private:
+	virtual const cItem GetFollowedItem(void) const override { return cItem(E_ITEM_SEEDS); }
 
+private:
 
 	int m_EggDropTimer;
 } ;
diff --git a/src/Mobs/Cow.cpp b/src/Mobs/Cow.cpp
index 9eb74dac2..d8e905217 100644
--- a/src/Mobs/Cow.cpp
+++ b/src/Mobs/Cow.cpp
@@ -41,5 +41,3 @@ void cCow::OnRightClicked(cPlayer & a_Player)
 	}
 }
 
-
-
diff --git a/src/Mobs/Cow.h b/src/Mobs/Cow.h
index 0391d4a31..973171ab5 100644
--- a/src/Mobs/Cow.h
+++ b/src/Mobs/Cow.h
@@ -19,6 +19,9 @@ public:
 
 	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override;
 	virtual void OnRightClicked(cPlayer & a_Player) override;
+
+	virtual const cItem GetFollowedItem(void) const override { return cItem(E_ITEM_WHEAT); }
+
 } ;
 
 
diff --git a/src/Mobs/Creeper.cpp b/src/Mobs/Creeper.cpp
index 4e11ae13e..2e1ece865 100644
--- a/src/Mobs/Creeper.cpp
+++ b/src/Mobs/Creeper.cpp
@@ -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();
+	}
+}
+
+
+
+
diff --git a/src/Mobs/Creeper.h b/src/Mobs/Creeper.h
index c3d4edeae..0f71e5ad2 100644
--- a/src/Mobs/Creeper.h
+++ b/src/Mobs/Creeper.h
@@ -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;
 
 } ;
 
diff --git a/src/Mobs/IronGolem.h b/src/Mobs/IronGolem.h
index d49ff4cab..41c60438c 100644
--- a/src/Mobs/IronGolem.h
+++ b/src/Mobs/IronGolem.h
@@ -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 {}
 } ;
 
 
diff --git a/src/Mobs/Monster.cpp b/src/Mobs/Monster.cpp
index 76df76633..42c7d2899 100644
--- a/src/Mobs/Monster.cpp
+++ b/src/Mobs/Monster.cpp
@@ -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()
 {
+	int PosX = (int)floor(GetPosX());
+	int PosY = (int)floor(GetPosY());
+	int PosZ = (int)floor(GetPosZ());
+
+	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();
+}
+
+
 
-	m_Destination = a_Position;
+
+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,10 +210,24 @@ 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;
+}
+
 
+
+
+bool cMonster::ReachedFinalDestination()
+{
+	if ((GetPosition() - m_FinalDestination).Length() <= m_AttackRange)
+	{
+		return true;
+	}
+	
 	return false;
 }
 
@@ -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
+			{
+				FinishPathFinding();
+			}
+			else
 			{
-				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!!
-				}
+				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);
-		SetRotation( 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
diff --git a/src/Mobs/Monster.h b/src/Mobs/Monster.h
index dafb33574..1dd302cdc 100644
--- a/src/Mobs/Monster.h
+++ b/src/Mobs/Monster.h
@@ -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:
 	
-	cEntity * m_Target;
-	float m_AttackRate;
-	float m_IdleInterval;
+	/* ======= PATHFINDING ======= */
 
-	Vector3f m_Destination;
+	/** A pointer to the entity this mobile is aiming to reach */
+	cEntity * m_Target;
+	/** 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);
+
+	/** 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));
+	}
+
+	/** 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 ========= */
 
-	float m_DestinationTime;
+	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;
+	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);
-	
-	void HandleDaylightBurning(cChunk & a_Chunk);
+	void AddRandomDropItem(cItems & a_Drops, unsigned int a_Min, unsigned int a_Max, short a_Item, short a_ItemHealth = 0);	
 
 } ; // tolua_export
 
diff --git a/src/Mobs/Mooshroom.cpp b/src/Mobs/Mooshroom.cpp
index 940e2db44..88101cd83 100644
--- a/src/Mobs/Mooshroom.cpp
+++ b/src/Mobs/Mooshroom.cpp
@@ -6,7 +6,6 @@
 
 
 
-
 // TODO: Milk Cow
 
 
@@ -30,4 +29,3 @@ void cMooshroom::GetDrops(cItems & a_Drops, cEntity * a_Killer)
 
 
 
-
diff --git a/src/Mobs/Mooshroom.h b/src/Mobs/Mooshroom.h
index 73f6348b6..c94301098 100644
--- a/src/Mobs/Mooshroom.h
+++ b/src/Mobs/Mooshroom.h
@@ -18,6 +18,8 @@ public:
 	CLASS_PROTODEF(cMooshroom);
 
 	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override;
+
+	virtual const cItem GetFollowedItem(void) const override { return cItem(E_ITEM_WHEAT); }
 } ;
 
 
diff --git a/src/Mobs/PassiveAggressiveMonster.cpp b/src/Mobs/PassiveAggressiveMonster.cpp
index 28de65905..4b45f9a2a 100644
--- a/src/Mobs/PassiveAggressiveMonster.cpp
+++ b/src/Mobs/PassiveAggressiveMonster.cpp
@@ -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;
 		}
diff --git a/src/Mobs/PassiveMonster.cpp b/src/Mobs/PassiveMonster.cpp
index 91ceb5a53..904cd63cc 100644
--- a/src/Mobs/PassiveMonster.cpp
+++ b/src/Mobs/PassiveMonster.cpp
@@ -2,9 +2,8 @@
 #include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules
 
 #include "PassiveMonster.h"
-#include "../MersenneTwister.h"
 #include "../World.h"
-
+#include "../Entities/Player.h"
 
 
 
@@ -36,19 +35,22 @@ 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)
+		CheckEventLostPlayer();
+	}
+	cItem FollowedItem = GetFollowedItem();
+	if (FollowedItem.IsEmpty())
+	{
+		return;
+	}
+	cPlayer * a_Closest_Player = m_World->FindClosestPlayer(GetPosition(), (float)m_SightDistance);
+	if (a_Closest_Player != NULL)
+	{
+		if (a_Closest_Player->GetEquippedItem().IsEqual(FollowedItem))
 		{
-			if (m_EMState == ESCAPING)
-			{
-				CheckEventLostPlayer();
-			} 
+			Vector3d PlayerPos = a_Closest_Player->GetPosition();
+			MoveToPosition(PlayerPos);
 		}
 	}
 }
diff --git a/src/Mobs/PassiveMonster.h b/src/Mobs/PassiveMonster.h
index 14a6be6b1..0b3c155da 100644
--- a/src/Mobs/PassiveMonster.h
+++ b/src/Mobs/PassiveMonster.h
@@ -19,6 +19,9 @@ public:
 
 	/// When hit by someone, run away
 	virtual void DoTakeDamage(TakeDamageInfo & a_TDI) override;
+	/** Returns the item that the animal of this class follows when a player holds it in hand
+	Return an empty item not to follow (default). */
+	virtual const cItem GetFollowedItem(void) const { return cItem(); }
 
 } ;
 
diff --git a/src/Mobs/Pig.cpp b/src/Mobs/Pig.cpp
index 0871a38a9..d8f3dda37 100644
--- a/src/Mobs/Pig.cpp
+++ b/src/Mobs/Pig.cpp
@@ -73,5 +73,3 @@ void cPig::OnRightClicked(cPlayer & a_Player)
 
 
 
-
-
diff --git a/src/Mobs/Pig.h b/src/Mobs/Pig.h
index 4fd0d8db8..d434324c1 100644
--- a/src/Mobs/Pig.h
+++ b/src/Mobs/Pig.h
@@ -19,6 +19,9 @@ public:
 
 	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override;
 	virtual void OnRightClicked(cPlayer & a_Player) override;
+
+	virtual const cItem GetFollowedItem(void) const override { return cItem(E_ITEM_CARROT); }
+
 	bool IsSaddled(void) const { return m_bIsSaddled; }
 
 private:
diff --git a/src/Mobs/Sheep.cpp b/src/Mobs/Sheep.cpp
index bda4ccff8..4761103e5 100644
--- a/src/Mobs/Sheep.cpp
+++ b/src/Mobs/Sheep.cpp
@@ -13,7 +13,8 @@
 cSheep::cSheep(int a_Color) :
 	super("Sheep", mtSheep, "mob.sheep.say", "mob.sheep.say", 0.6, 1.3),
 	m_IsSheared(false),
-	m_WoolColor(a_Color)
+	m_WoolColor(a_Color),
+	m_TimeToStopEating(-1)
 {
 }
 
@@ -60,3 +61,40 @@ void cSheep::OnRightClicked(cPlayer & a_Player)
 		m_World->BroadcastEntityMetadata(*this);
 	}
 }
+
+
+
+
+
+void cSheep::Tick(float a_Dt, cChunk & a_Chunk)
+{
+	// The sheep should not move when he's eating so only handle the physics.
+	if (m_TimeToStopEating > 0)
+	{
+		HandlePhysics(a_Dt, a_Chunk);
+		m_TimeToStopEating--;
+		if (m_TimeToStopEating == 0)
+		{
+			if (m_World->GetBlock((int) GetPosX(), (int) GetPosY() - 1, (int) GetPosZ()) == E_BLOCK_GRASS)
+			{
+				// The sheep ate the grass so we change it to dirt.
+				m_World->SetBlock((int) GetPosX(), (int) GetPosY() - 1, (int) GetPosZ(), E_BLOCK_DIRT, 0);
+				m_IsSheared = false;
+				m_World->BroadcastEntityMetadata(*this);
+			}
+		}
+	}
+	else
+	{
+		super::Tick(a_Dt, a_Chunk);
+		if (m_World->GetTickRandomNumber(600) == 1)
+		{
+			if (m_World->GetBlock((int) GetPosX(), (int) GetPosY() - 1, (int) GetPosZ()) == E_BLOCK_GRASS)
+			{
+				m_World->BroadcastEntityStatus(*this, 10);
+				m_TimeToStopEating = 40;
+			}
+		}
+	}
+}
+
diff --git a/src/Mobs/Sheep.h b/src/Mobs/Sheep.h
index 8293a2c05..402e8e61c 100644
--- a/src/Mobs/Sheep.h
+++ b/src/Mobs/Sheep.h
@@ -19,6 +19,10 @@ public:
 	
 	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override;
 	virtual void OnRightClicked(cPlayer & a_Player) override;
+	virtual void Tick(float a_Dt, cChunk & a_Chunk) override;
+
+	virtual const cItem GetFollowedItem(void) const override { return cItem(E_ITEM_WHEAT); }
+
 	bool IsSheared(void) const { return m_IsSheared; }
 	int GetFurColor(void) const { return m_WoolColor; }
 
@@ -26,6 +30,7 @@ private:
 	
 	bool m_IsSheared;
 	int m_WoolColor;
+	int m_TimeToStopEating;
 
 } ;
 
diff --git a/src/Mobs/Skeleton.cpp b/src/Mobs/Skeleton.cpp
index 509c2191e..4c8e78988 100644
--- a/src/Mobs/Skeleton.cpp
+++ b/src/Mobs/Skeleton.cpp
@@ -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);
 }
 
 
diff --git a/src/Mobs/Squid.cpp b/src/Mobs/Squid.cpp
index a311108ae..5a27762ff 100644
--- a/src/Mobs/Squid.cpp
+++ b/src/Mobs/Squid.cpp
@@ -43,7 +43,8 @@ void cSquid::Tick(float a_Dt, cChunk & a_Chunk)
 	}
 	int RelX = (int)floor(Pos.x) - a_Chunk.GetPosX() * cChunkDef::Width;
 	int RelZ = (int)floor(Pos.z) - a_Chunk.GetPosZ() * cChunkDef::Width;
-	if (!IsBlockWater(a_Chunk.GetBlock(RelX, RelY, RelZ)) && !IsOnFire())
+	BLOCKTYPE BlockType;
+	if (a_Chunk.UnboundedRelGetBlockType(RelX, RelY, RelZ, BlockType) && !IsBlockWater(BlockType) && !IsOnFire())
 	{
 		// Burn for 10 ticks, then decide again
 		StartBurning(10);
diff --git a/src/Mobs/Squid.h b/src/Mobs/Squid.h
index ad299b95c..a9dba8b70 100644
--- a/src/Mobs/Squid.h
+++ b/src/Mobs/Squid.h
@@ -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 {}
 } ;
 
 
diff --git a/src/Mobs/Villager.cpp b/src/Mobs/Villager.cpp
index 7f89fb6cc..44ec14295 100644
--- a/src/Mobs/Villager.cpp
+++ b/src/Mobs/Villager.cpp
@@ -3,6 +3,8 @@
 
 #include "Villager.h"
 #include "../World.h"
+#include "../BlockArea.h"
+#include "../Blocks/BlockHandler.h"
 
 
 
@@ -10,7 +12,9 @@
 
 cVillager::cVillager(eVillagerType VillagerType) :
 	super("Villager", mtVillager, "", "", 0.6, 1.8),
-	m_Type(VillagerType)
+	m_Type(VillagerType),
+	m_VillagerAction(false),
+	m_ActionCountDown(-1)
 {
 }
 
@@ -21,7 +25,7 @@ cVillager::cVillager(eVillagerType VillagerType) :
 void cVillager::DoTakeDamage(TakeDamageInfo & a_TDI)
 {
 	super::DoTakeDamage(a_TDI);
-	if (a_TDI.Attacker->IsPlayer())
+	if ((a_TDI.Attacker != NULL) && a_TDI.Attacker->IsPlayer())
 	{
 		if (m_World->GetTickRandomNumber(5) == 3)
 		{
@@ -33,3 +37,153 @@ void cVillager::DoTakeDamage(TakeDamageInfo & a_TDI)
 
 
 
+
+void cVillager::Tick(float a_Dt, cChunk & a_Chunk)
+{
+	super::Tick(a_Dt, a_Chunk);
+
+	if (m_ActionCountDown > -1)
+	{
+		m_ActionCountDown--;
+		if (m_ActionCountDown == 0)
+		{
+			switch (m_Type)
+			{
+				case vtFarmer: 
+				{
+					HandleFarmerPlaceCrops();
+				}
+			}
+		}
+		return;
+	}
+
+	if (m_VillagerAction)
+	{
+		switch (m_Type)
+		{
+			case vtFarmer:
+			{
+				HandleFarmerTryHarvestCrops();
+			}
+		}
+		m_VillagerAction = false;
+		return;
+	}
+
+	// Don't always try to do a special action. Each tick has 1% to do a special action.
+	if (m_World->GetTickRandomNumber(99) != 0)
+	{
+		return;
+	}
+
+	switch (m_Type)
+	{
+		case vtFarmer:
+		{
+			HandleFarmerPrepareFarmCrops();
+		}
+	}
+}
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Farmer functions.
+void cVillager::HandleFarmerPrepareFarmCrops()
+{
+	if (!m_World->VillagersShouldHarvestCrops())
+	{
+		return;
+	}
+
+	cBlockArea Surrounding;
+	/// Read a 11x7x11 area.
+	Surrounding.Read(
+		m_World,
+		(int) GetPosX() - 5,
+		(int) GetPosX() + 5,
+		(int) GetPosY() - 3,
+		(int) GetPosY() + 3,
+		(int) GetPosZ() - 5,
+		(int) GetPosZ() + 5
+	);
+
+	for (int I = 0; I < 5; I++)
+	{
+		for (int Y = 0; Y < 6; Y++)
+		{
+			// Pick random coordinates and check for crops.
+			int X = m_World->GetTickRandomNumber(11);
+			int Z = m_World->GetTickRandomNumber(11);
+
+			// A villager can't farm this.
+			if (!IsBlockFarmable(Surrounding.GetRelBlockType(X, Y, Z)))
+			{
+				continue;
+			}
+			if (Surrounding.GetRelBlockMeta(X, Y, Z) != 0x7)
+			{
+				continue;
+			}
+
+			m_VillagerAction = true;
+			m_CropsPos = Vector3i((int) GetPosX() + X - 5, (int) GetPosY() + Y - 3, (int) GetPosZ() + Z - 5);
+			MoveToPosition(Vector3f((float) (m_CropsPos.x + 0.5), (float) m_CropsPos.y, (float) (m_CropsPos.z + 0.5)));
+			return;
+		} // for Y loop.
+	} // Repeat the procces 5 times.
+}
+
+
+
+
+
+void cVillager::HandleFarmerTryHarvestCrops()
+{
+	// Harvest the crops if the villager isn't moving and if the crops are closer then 2 blocks.
+	if (!m_bMovingToDestination && (GetPosition() - m_CropsPos).Length() < 2)
+	{
+		// Check if the blocks didn't change while the villager was walking to the coordinates.
+		BLOCKTYPE CropBlock = m_World->GetBlock(m_CropsPos.x, m_CropsPos.y, m_CropsPos.z);
+		if (IsBlockFarmable(CropBlock) && m_World->GetBlockMeta(m_CropsPos.x, m_CropsPos.y, m_CropsPos.z) == 0x7)
+		{
+			cBlockHandler * Handler = cBlockHandler::GetBlockHandler(CropBlock);
+			Handler->DropBlock(m_World, this, m_CropsPos.x, m_CropsPos.y, m_CropsPos.z);
+			m_World->SetBlock(m_CropsPos.x, m_CropsPos.y, m_CropsPos.z, E_BLOCK_AIR, 0);
+			m_ActionCountDown = 20;
+		}
+	}
+}
+
+
+
+
+void cVillager::HandleFarmerPlaceCrops()
+{
+	// Check if there is still farmland at the spot where the crops were.
+	if (m_World->GetBlock(m_CropsPos.x, m_CropsPos.y - 1, m_CropsPos.z) == E_BLOCK_FARMLAND)
+	{
+		m_World->SetBlock(m_CropsPos.x, m_CropsPos.y, m_CropsPos.z, E_BLOCK_CROPS, 0);
+	}
+}
+
+
+
+
+
+bool cVillager::IsBlockFarmable(BLOCKTYPE a_BlockType)
+{
+	switch (a_BlockType)
+	{
+		case E_BLOCK_CROPS:
+		case E_BLOCK_POTATOES:
+		case E_BLOCK_CARROTS:
+		{
+			return true;
+		}
+	}
+	return false;
+}
+
diff --git a/src/Mobs/Villager.h b/src/Mobs/Villager.h
index 4cd9aaa8e..b99ae876f 100644
--- a/src/Mobs/Villager.h
+++ b/src/Mobs/Villager.h
@@ -29,12 +29,36 @@ public:
 
 	CLASS_PROTODEF(cVillager);
 
+	// Override functions
 	virtual void DoTakeDamage(TakeDamageInfo & a_TDI) override;
-	int GetVilType(void) const { return m_Type; }	
+	virtual void Tick        (float a_Dt, cChunk & a_Chunk) override;
+
+	// cVillager functions
+	/** return true if the given blocktype are: crops, potatoes or carrots.*/
+	bool IsBlockFarmable(BLOCKTYPE a_BlockType);
+
+	//////////////////////////////////////////////////////////////////
+	// Farmer functions
+	/** It searches in a 11x7x11 area for crops. If it found some it will navigate to them.*/
+	void HandleFarmerPrepareFarmCrops();
+
+	/** Looks if the farmer has reached it's destination, and if it's still crops and the destination is closer then 2 blocks it will harvest them.*/
+	void HandleFarmerTryHarvestCrops();
+
+	/** Replaces the crops he harvested.*/
+	void HandleFarmerPlaceCrops();
+
+	// Get and set functions.
+	int      GetVilType(void)              const { return m_Type; }	
+	Vector3i GetCropsPos(void)             const { return m_CropsPos; }
+	bool     DoesHaveActionActivated(void) const { return m_VillagerAction; }
 
 private:
 
+	int m_ActionCountDown;
 	int m_Type;
+	bool m_VillagerAction;
+	Vector3i m_CropsPos;
 
 } ;
 
diff --git a/src/Mobs/Wolf.cpp b/src/Mobs/Wolf.cpp
index 3d4e97c80..c0c7892e3 100644
--- a/src/Mobs/Wolf.cpp
+++ b/src/Mobs/Wolf.cpp
@@ -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)
 {
@@ -55,10 +75,12 @@ void cWolf::OnRightClicked(cPlayer & a_Player)
 				SetIsTame(true);
 				SetOwner(a_Player.GetName());
 				m_World->BroadcastEntityStatus(*this, ENTITY_STATUS_WOLF_TAMED);
+				m_World->BroadcastParticleEffect("heart", (float) GetPosX(), (float) GetPosY(), (float) GetPosZ(), 0, 0, 0, 0, 5);
 			}
 			else
 			{
 				m_World->BroadcastEntityStatus(*this, ENTITY_STATUS_WOLF_TAMING);
+				m_World->BroadcastParticleEffect("smoke", (float) GetPosX(), (float) GetPosY(), (float) GetPosZ(), 0, 0, 0, 0, 5);
 			}
 		}
 	}
@@ -102,13 +124,14 @@ void cWolf::Tick(float a_Dt, cChunk & a_Chunk)
 	{
 		super::Tick(a_Dt, a_Chunk);
 	}
-
+	
+	// The wolf is sitting so don't move him at all.
 	if (IsSitting())
 	{
 		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,10 +148,18 @@ 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_bMovingToDestination = false;
+				// Don't move to the player if the wolf is sitting.
+				if (IsSitting())
+				{
+					m_bMovingToDestination = false;
+				}
+				else
+				{
+					m_bMovingToDestination = true;
+				}
+				Vector3d PlayerPos = a_Closest_Player->GetPosition();
+				PlayerPos.y++;
+				m_FinalDestination = PlayerPos;
 				break;
 			}
 			default:
@@ -163,23 +194,30 @@ 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:
+		// The player is present in the world, follow him:
 		double Distance = (Callback.OwnerPos - GetPosition()).Length();
-		if (Distance < 3)
-		{
-			m_bMovingToDestination = false;
-		}
-		else if ((Distance > 30) && (!IsSitting()))
+		if (Distance > 30)
 		{
-			TeleportToCoords(Callback.OwnerPos.x, Callback.OwnerPos.y, Callback.OwnerPos.z);
+			if (!IsSitting())
+			{
+				TeleportToCoords(Callback.OwnerPos.x, Callback.OwnerPos.y, Callback.OwnerPos.z);
+			}
 		}
 		else
 		{
-			m_Destination = Callback.OwnerPos;
+			m_FinalDestination = Callback.OwnerPos;
+			if (IsSitting())
+			{
+				m_bMovingToDestination = false;
+			}
+			else
+			{
+				m_bMovingToDestination = true;
+			}
 		}
 	}
 }
diff --git a/src/Mobs/Wolf.h b/src/Mobs/Wolf.h
index 040e2cf7a..9e5ad03c7 100644
--- a/src/Mobs/Wolf.h
+++ b/src/Mobs/Wolf.h
@@ -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; }
diff --git a/src/Mobs/Zombie.cpp b/src/Mobs/Zombie.cpp
index a046fcc92..27e8ed5fb 100644
--- a/src/Mobs/Zombie.cpp
+++ b/src/Mobs/Zombie.cpp
@@ -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);
 }