You are now able to sweep mobs to your position using fishing rods.

src/Entities/Floater.cpp

@@ -1,6 +1,8 @@
 
 #include "Globals.h"
 
+#include "../BoundingBox.h"
+#include "../Chunk.h"
 #include "Floater.h"
 #include "Player.h"
 #include "../ClientHandle.h"
@@ -9,12 +11,103 @@
 
 
 
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cFloaterEntityCollisionCallback
+class cFloaterEntityCollisionCallback :
+	public cEntityCallback
+{
+public:
+	cFloaterEntityCollisionCallback(cFloater * a_Floater, const Vector3d & a_Pos, const Vector3d & a_NextPos) :
+		m_Floater(a_Floater),
+		m_Pos(a_Pos),
+		m_NextPos(a_NextPos),
+		m_MinCoeff(1),
+		m_HitEntity(NULL)
+	{
+	}
+	virtual bool Item(cEntity * a_Entity) override
+	{
+		if (!a_Entity->IsMob())  // Floaters can only pull mobs not other entities.
+		{
+			return false;
+		}
+
+		cBoundingBox EntBox(a_Entity->GetPosition(), a_Entity->GetWidth() / 2, a_Entity->GetHeight());
+
+		double LineCoeff;
+		char Face;
+		EntBox.Expand(m_Floater->GetWidth() / 2, m_Floater->GetHeight() / 2, m_Floater->GetWidth() / 2);
+		if (!EntBox.CalcLineIntersection(m_Pos, m_NextPos, LineCoeff, Face))
+		{
+			// No intersection whatsoever
+			return false;
+		}
+
+		if (LineCoeff < m_MinCoeff)
+		{
+			// The entity is closer than anything we've stored so far, replace it as the potential victim
+			m_MinCoeff = LineCoeff;
+			m_HitEntity = a_Entity;
+		}
+		
+		// Don't break the enumeration, we want all the entities
+		return false;
+	}
+
+	/// Returns the nearest entity that was hit, after the enumeration has been completed
+	cEntity * GetHitEntity(void) const { return m_HitEntity; }
+
+	/// Returns true if the callback has encountered a true hit
+	bool HasHit(void) const { return (m_MinCoeff < 1); }
+
+protected:
+	cFloater * m_Floater;
+	const Vector3d & m_Pos;
+	const Vector3d & m_NextPos;
+	double m_MinCoeff;  // The coefficient of the nearest hit on the Pos line
+
+	// Although it's bad(tm) to store entity ptrs from a callback, we can afford it here, because the entire callback
+	// is processed inside the tick thread, so the entities won't be removed in between the calls and the final processing
+	cEntity * m_HitEntity;  // The nearest hit entity
+} ;
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cFloaterCheckEntityExist
+class cFloaterCheckEntityExist :
+	public cEntityCallback
+{
+public:
+	cFloaterCheckEntityExist(void) :
+		m_EntityExists(false)
+	{
+	}
+
+	bool Item(cEntity * a_Entity) override
+	{
+		m_EntityExists = true;
+		return false;
+	}
+	
+	bool DoesExist(void) const { return m_EntityExists; }
+protected:
+	bool m_EntityExists;
+} ;
+
+
+
+
+
 cFloater::cFloater(double a_X, double a_Y, double a_Z, Vector3d a_Speed, int a_PlayerID, int a_CountDownTime) :
-	cEntity(etFloater, a_X, a_Y, a_Z, 0.98, 0.98),
+	cEntity(etFloater, a_X, a_Y, a_Z, 0.2, 0.2),
 	m_PickupCountDown(0),
 	m_PlayerID(a_PlayerID),
 	m_CanPickupItem(false),
-	m_CountDownTime(a_CountDownTime)
+	m_CountDownTime(a_CountDownTime),
+	m_AttachedMobID(-1)
 {
 	SetSpeed(a_Speed);
 }
@@ -37,7 +130,7 @@ void cFloater::Tick(float a_Dt, cChunk & a_Chunk)
 	HandlePhysics(a_Dt, a_Chunk);
 	if (IsBlockWater(m_World->GetBlock((int) GetPosX(), (int) GetPosY(), (int) GetPosZ())) && m_World->GetBlockMeta((int) GetPosX(), (int) GetPosY(), (int) GetPosZ()) == 0)
 	{
-		if (!m_CanPickupItem)
+		if (!m_CanPickupItem && m_AttachedMobID == -1) // Check if you can't already pickup a fish and if the floater isn't attached to a mob.
 		{
 			if (m_CountDownTime <= 0)
 			{
@@ -78,9 +171,8 @@ void cFloater::Tick(float a_Dt, cChunk & a_Chunk)
 		}
 		SetSpeedY(0.7);
 	}
-	SetSpeedX(GetSpeedX() * 0.95);
+
-	SetSpeedZ(GetSpeedZ() * 0.95);
+	if (CanPickup())  // Make sure the floater "loses its fish"
-	if (CanPickup())
 	{
 		m_PickupCountDown--;
 		if (m_PickupCountDown == 0)
@@ -89,9 +181,38 @@ void cFloater::Tick(float a_Dt, cChunk & a_Chunk)
 			LOGD("The fish is gone. Floater %i can not pick an item up.", GetUniqueID());
 		}
 	}
+
+	if (GetSpeed().Length() > 4 && m_AttachedMobID == -1)
+	{
+		cFloaterEntityCollisionCallback Callback(this, GetPosition(), GetPosition() + GetSpeed() / 20);
+		
+		a_Chunk.ForEachEntity(Callback);
+		if (Callback.HasHit())
+		{
+			AttachTo(Callback.GetHitEntity());
+			Callback.GetHitEntity()->TakeDamage(*this); // TODO: the player attacked the mob not the floater.
+			m_AttachedMobID = Callback.GetHitEntity()->GetUniqueID();
+		}
+	}
+
+	cFloaterCheckEntityExist EntityCallback;
+	m_World->DoWithEntityByID(m_PlayerID, EntityCallback);
+	if (!EntityCallback.DoesExist()) // The owner doesn't exist anymore. Destroy the floater entity.
+	{
+		Destroy(true);
+	}
+
+	if (m_AttachedMobID != -1)
+	{
+		m_World->DoWithEntityByID(m_AttachedMobID, EntityCallback); // The mob the floater was attached to doesn't exist anymore.
+		if (!EntityCallback.DoesExist())
+		{
+			m_AttachedMobID = -1;
+		}
+	}
+
+	SetSpeedX(GetSpeedX() * 0.95);
+	SetSpeedZ(GetSpeedZ() * 0.95);
+
 	BroadcastMovementUpdate();
 }
-
-
-
-

src/Entities/Floater.h

@@ -20,12 +20,21 @@ public:
 	virtual void Tick(float a_Dt, cChunk & a_Chunk) override;
 
 	bool CanPickup(void)       const { return m_CanPickupItem; }
+	int GetOwnerID(void)       const { return m_PlayerID; }
+	int GetAttachedMobID(void) const { return m_AttachedMobID; }
 
 protected:
-	Vector3d m_Speed;
+	// Position
 	Vector3d m_ParticlePos;
-	int m_PickupCountDown;
+
-	int m_PlayerID;
+	// Bool needed to check if you can get a fish.
-	int m_CountDownTime;
 	bool m_CanPickupItem;
+
+	// Countdown times
+	int m_PickupCountDown;
+	int m_CountDownTime;
+
+	// Entity IDs
+	int m_PlayerID;
+	int m_AttachedMobID;
 } ;

src/Items/ItemFishingRod.h

@@ -15,6 +15,61 @@
 
 
 
+/////////////////////////////////////////////////////////////////////////////////////
+// cFloaterCallback
+class cFloaterCallback :
+	public cEntityCallback
+{
+public:
+	cFloaterCallback(void) : 
+		m_CanPickup(false),
+		m_AttachedMobID(-1)
+	{
+	}
+
+	virtual bool Item(cEntity * a_Entity) override
+	{
+		m_CanPickup = ((cFloater *)a_Entity)->CanPickup();
+		m_Pos = Vector3d(a_Entity->GetPosX(), a_Entity->GetPosY(), a_Entity->GetPosZ());
+		m_AttachedMobID = ((cFloater *)a_Entity)->GetAttachedMobID();
+		a_Entity->Destroy(true);
+		return true;
+	}
+
+	bool CanPickup(void)       const { return m_CanPickup; }
+	bool IsAttached(void)      const { return (m_AttachedMobID != -1); }
+	int GetAttachedMobID(void) const { return m_AttachedMobID; }
+	Vector3d GetPos(void)      const { return m_Pos; }
+
+protected:
+	bool m_CanPickup;
+	int m_AttachedMobID;
+	Vector3d m_Pos;
+} ;
+
+////////////////////////////////////////////////////////////////////////////
+// cSweepEntityCallback
+class cSweepEntityCallback :
+	public cEntityCallback
+{
+public:
+	cSweepEntityCallback(Vector3d a_PlayerPos) :
+	  m_PlayerPos(a_PlayerPos)
+	{
+	}
+
+	virtual bool Item(cEntity * a_Entity) override
+	{
+		Vector3d Speed = m_PlayerPos - a_Entity->GetPosition();
+		a_Entity->AddSpeed(Speed);
+		return true;
+	}
+
+protected:
+	Vector3d m_PlayerPos;
+} ;
+
+
 
 class cItemFishingRodHandler :
 	public cItemHandler
@@ -36,33 +91,16 @@ public:
 
 		if (a_Player->IsFishing())
 		{
-			class cFloaterCallback :
+			cFloaterCallback FloaterInfo;
-				public cEntityCallback
+			a_World->DoWithEntityByID(a_Player->GetFloaterID(), FloaterInfo);
-			{
-			public:
-				cFloaterCallback(void) : 
-					m_CanPickup(false) 
-				{
-				}
-
-				bool CanPickup(void) const { return m_CanPickup; }
-				Vector3d GetPos(void) const { return m_Pos; }
-
-				virtual bool Item(cEntity * a_Entity) override
-				{
-					m_CanPickup = ((cFloater *)a_Entity)->CanPickup();
-					m_Pos = Vector3d(a_Entity->GetPosX(), a_Entity->GetPosY(), a_Entity->GetPosZ());
-					a_Entity->Destroy(true);
-					return true;
-				}
-			protected:
-				bool m_CanPickup;
-				Vector3d m_Pos;
-			} Callbacks;
-			a_World->DoWithEntityByID(a_Player->GetFloaterID(), Callbacks);
 			a_Player->SetIsFishing(false);
 
-			if (Callbacks.CanPickup())
+			if (FloaterInfo.IsAttached())
+			{
+				cSweepEntityCallback SweepEntity(a_Player->GetPosition());
+				a_World->DoWithEntityByID(FloaterInfo.GetAttachedMobID(), SweepEntity);
+			}
+			else if (FloaterInfo.CanPickup())
 			{
 				cItems Drops;
 				int ItemCategory = a_World->GetTickRandomNumber(99);
@@ -173,7 +211,7 @@ public:
 				}
 
 				
-				Vector3d FloaterPos = Callbacks.GetPos();
+				Vector3d FloaterPos = FloaterInfo.GetPos();
 				Vector3d FlyDirection = a_Player->GetEyePosition() - FloaterPos;
 				a_World->SpawnItemPickups(Drops, FloaterPos.x, FloaterPos.y, FloaterPos.z, FlyDirection.x, FlyDirection.y + 1, FlyDirection.z);
 			}