1 files changed, 318 insertions, 39 deletions

diff --git a/source/Entities/ProjectileEntity.cpp b/source/Entities/ProjectileEntity.cpp
index 91b2c97a8..4c8e680d0 100644
--- a/source/Entities/ProjectileEntity.cpp
+++ b/source/Entities/ProjectileEntity.cpp
@@ -8,6 +8,16 @@
 #include "../ClientHandle.h"
 #include "Player.h"
 #include "../LineBlockTracer.h"
+#include "../BoundingBox.h"
+#include "../ChunkMap.h"
+#include "../Chunk.h"
+
+
+
+
+
+/// Converts an angle in radians into a byte representation used by the network protocol
+#define ANGLE_TO_PROTO(X) (Byte)(X * 255 / 360)
 
 
 
@@ -21,20 +31,49 @@ class cProjectileTracerCallback :
 {
 public:
 	cProjectileTracerCallback(cProjectileEntity * a_Projectile) :
-		m_Projectile(a_Projectile)
+		m_Projectile(a_Projectile),
+		m_SlowdownCoeff(0.99)  // Default slowdown when not in water
 	{
 	}
 	
+	double GetSlowdownCoeff(void) const { return m_SlowdownCoeff; }
+	
 protected:
 	cProjectileEntity * m_Projectile;
+	double m_SlowdownCoeff;
 	
+	// cCallbacks overrides:
 	virtual bool OnNextBlock(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta, char a_EntryFace) override
 	{
+		/*
+		// DEBUG:
+		LOGD("Hit block %d:%d at {%d, %d, %d} face %d, %s (%s)",
+			a_BlockType, a_BlockMeta,
+			a_BlockX, a_BlockY, a_BlockZ, a_EntryFace,
+			g_BlockIsSolid[a_BlockType] ? "solid" : "non-solid",
+			ItemToString(cItem(a_BlockType, 1, a_BlockMeta)).c_str()
+		);
+		*/
+		
 		if (g_BlockIsSolid[a_BlockType])
 		{
 			// The projectile hit a solid block
-			m_Projectile->OnHitSolidBlock(a_BlockX, a_BlockY, a_BlockZ, a_EntryFace);
-			return true;
+			// Calculate the exact hit coords:
+			cBoundingBox bb(a_BlockX, a_BlockX + 1, a_BlockY, a_BlockY + 1, a_BlockZ, a_BlockZ + 1);
+			Vector3d Line1 = m_Projectile->GetPosition();
+			Vector3d Line2 = Line1 + m_Projectile->GetSpeed();
+			double LineCoeff = 0;
+			char Face;
+			if (bb.CalcLineIntersection(Line1, Line2, LineCoeff, Face))
+			{
+				Vector3d Intersection = Line1 + m_Projectile->GetSpeed() * LineCoeff;
+				m_Projectile->OnHitSolidBlock(Intersection, Face);
+				return true;
+			}
+			else
+			{
+				LOGD("WEIRD! block tracer reports a hit, but BBox tracer doesn't. Ignoring the hit.");
+			}
 		}
 		
 		// Convey some special effects from special blocks:
@@ -44,12 +83,14 @@ protected:
 			case E_BLOCK_STATIONARY_LAVA:
 			{
 				m_Projectile->StartBurning(30);
+				m_SlowdownCoeff = std::min(m_SlowdownCoeff, 0.9);  // Slow down to 0.9* the speed each tick when moving through lava
 				break;
 			}
 			case E_BLOCK_WATER:
 			case E_BLOCK_STATIONARY_WATER:
 			{
 				m_Projectile->StopBurning();
+				m_SlowdownCoeff = std::min(m_SlowdownCoeff, 0.8);  // Slow down to 0.8* the speed each tick when moving through water
 				break;
 			}
 		}  // switch (a_BlockType)
@@ -64,6 +105,86 @@ protected:
 
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cProjectileEntityCollisionCallback:
+
+class cProjectileEntityCollisionCallback :
+	public cEntityCallback
+{
+public:
+	cProjectileEntityCollisionCallback(cProjectileEntity * a_Projectile, const Vector3d & a_Pos, const Vector3d & a_NextPos) :
+		m_Projectile(a_Projectile),
+		m_Pos(a_Pos),
+		m_NextPos(a_NextPos),
+		m_MinCoeff(1),
+		m_HitEntity(NULL)
+	{
+	}
+	
+	
+	virtual bool Item(cEntity * a_Entity) override
+	{
+		if (
+			(a_Entity == m_Projectile) ||          // Do not check collisions with self
+			(a_Entity == m_Projectile->GetCreator())  // Do not check whoever shot the projectile
+		)
+		{
+			// TODO: Don't check creator only for the first 5 ticks
+			// so that arrows stuck in ground and dug up can hurt the player
+			return false;
+		}
+		
+		cBoundingBox EntBox(a_Entity->GetPosition(), a_Entity->GetWidth() / 2, a_Entity->GetHeight());
+		
+		// Instead of colliding the bounding box with another bounding box in motion, we collide an enlarged bounding box with a hairline.
+		// The results should be good enough for our purposes
+		double LineCoeff;
+		char Face;
+		EntBox.Expand(m_Projectile->GetWidth() / 2, m_Projectile->GetHeight() / 2, m_Projectile->GetWidth() / 2);
+		if (!EntBox.CalcLineIntersection(m_Pos, m_NextPos, LineCoeff, Face))
+		{
+			// No intersection whatsoever
+			return false;
+		}
+
+		// TODO: Some entities don't interact with the projectiles (pickups, falling blocks)
+		// TODO: Allow plugins to interfere about which entities can be hit
+		
+		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 the line coeff where the hit was encountered, after the enumeration has been completed
+	double GetMinCoeff(void) const { return m_MinCoeff; }
+	
+	/// Returns true if the callback has encountered a true hit
+	bool HasHit(void) const { return (m_MinCoeff < 1); }
+	
+protected:
+	cProjectileEntity * m_Projectile;
+	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
+} ;
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // cProjectileEntity:
 
 cProjectileEntity::cProjectileEntity(eKind a_Kind, cEntity * a_Creator, double a_X, double a_Y, double a_Z, double a_Width, double a_Height) :
@@ -85,6 +206,8 @@ cProjectileEntity::cProjectileEntity(eKind a_Kind, cEntity * a_Creator, const Ve
 	m_IsInGround(false)
 {
 	SetSpeed(a_Speed);
+	SetRotationFromSpeed();
+	SetPitchFromSpeed();
 }
 
 
@@ -101,10 +224,12 @@ cProjectileEntity * cProjectileEntity::Create(eKind a_Kind, cEntity * a_Creator,
 
 	switch (a_Kind)
 	{
-		case pkArrow:      return new cArrowEntity           (a_Creator, a_X, a_Y, a_Z, Speed);
-		case pkEgg:        return new cThrownEggEntity       (a_Creator, a_X, a_Y, a_Z, Speed);
-		case pkEnderPearl: return new cThrownEnderPearlEntity(a_Creator, a_X, a_Y, a_Z, Speed);
-		case pkSnowball:   return new cThrownSnowballEntity  (a_Creator, a_X, a_Y, a_Z, Speed);
+		case pkArrow:         return new cArrowEntity           (a_Creator, a_X, a_Y, a_Z, Speed);
+		case pkEgg:           return new cThrownEggEntity       (a_Creator, a_X, a_Y, a_Z, Speed);
+		case pkEnderPearl:    return new cThrownEnderPearlEntity(a_Creator, a_X, a_Y, a_Z, Speed);
+		case pkSnowball:      return new cThrownSnowballEntity  (a_Creator, a_X, a_Y, a_Z, Speed);
+		case pkGhastFireball: return new cGhastFireballEntity   (a_Creator, a_X, a_Y, a_Z, Speed);
+		case pkFireCharge:    return new cFireChargeEntity      (a_Creator, a_X, a_Y, a_Z, Speed);
 		// TODO: the rest
 	}
 	
@@ -116,26 +241,17 @@ cProjectileEntity * cProjectileEntity::Create(eKind a_Kind, cEntity * a_Creator,
 
 
 
-void cProjectileEntity::OnHitSolidBlock(int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace)
+void cProjectileEntity::OnHitSolidBlock(const Vector3d & a_HitPos, char a_HitFace)
 {
-	// TODO: Set proper position based on what face was hit
-	switch (a_BlockFace)
-	{
-		case BLOCK_FACE_TOP:    SetPosition(0.5 + a_BlockX, 1.0 + a_BlockY, 0.5 + a_BlockZ); break;
-		case BLOCK_FACE_BOTTOM: SetPosition(0.5 + a_BlockX,       a_BlockY, 0.5 + a_BlockZ); break;
-		case BLOCK_FACE_EAST:   SetPosition(      a_BlockX, 0.5 + a_BlockY, 0.5 + a_BlockZ); break;
-		case BLOCK_FACE_WEST:   SetPosition(1.0 + a_BlockX, 0.5 + a_BlockY, 0.5 + a_BlockZ); break;
-		case BLOCK_FACE_NORTH:  SetPosition(0.5 + a_BlockX, 0.5 + a_BlockY, 1.0 + a_BlockZ); break;
-		case BLOCK_FACE_SOUTH:  SetPosition(0.5 + a_BlockX, 0.5 + a_BlockY,       a_BlockZ); break;
-		case BLOCK_FACE_NONE:   SetPosition(0.5 + a_BlockX, 0.5 + a_BlockY, 0.5 + a_BlockZ); break;
-	}
+	// Set the position based on what face was hit:
+	SetPosition(a_HitPos);
 	SetSpeed(0, 0, 0);
 
 	// DEBUG:
 	LOGD("Projectile %d: pos {%.02f, %.02f, %.02f}, hit solid block at face %d",
 		m_UniqueID,
-		GetPosX(), GetPosY(), GetPosZ(),
-		a_BlockFace
+		a_HitPos.x, a_HitPos.y, a_HitPos.z,
+		a_HitFace
 	);
 
 	m_IsInGround = true;
@@ -192,20 +308,51 @@ void cProjectileEntity::HandlePhysics(float a_Dt, cChunk & a_Chunk)
 	// Trace the tick's worth of movement as a line:
 	Vector3d NextPos = Pos + PerTickSpeed;
 	cProjectileTracerCallback TracerCallback(this);
-	if (cLineBlockTracer::Trace(*m_World, TracerCallback, Pos, NextPos))
+	if (!cLineBlockTracer::Trace(*m_World, TracerCallback, Pos, NextPos))
 	{
-		// Nothing in the way, update the position
-		SetPosition(NextPos);
+		// Something has been hit, abort all other processing
+		return;
+	}
+	// The tracer also checks the blocks for slowdown blocks - water and lava - and stores it for later in its SlowdownCoeff
+	
+	// Test for entity collisions:
+	cProjectileEntityCollisionCallback EntityCollisionCallback(this, Pos, NextPos);
+	a_Chunk.ForEachEntity(EntityCollisionCallback);
+	if (EntityCollisionCallback.HasHit())
+	{
+		// An entity was hit:
+		Vector3d HitPos = Pos + (NextPos - Pos) * EntityCollisionCallback.GetMinCoeff();
+
+		// DEBUG:
+		LOGD("Projectile %d has hit an entity %d (%s) at {%.02f, %.02f, %.02f} (coeff %.03f)",
+			m_UniqueID,
+			EntityCollisionCallback.GetHitEntity()->GetUniqueID(),
+			EntityCollisionCallback.GetHitEntity()->GetClass(),
+			HitPos.x, HitPos.y, HitPos.z,
+			EntityCollisionCallback.GetMinCoeff()
+		);
+		
+		OnHitEntity(*(EntityCollisionCallback.GetHitEntity()), HitPos);
 	}
+	// TODO: Test the entities in the neighboring chunks, too
+
+	// Update the position:
+	SetPosition(NextPos);
 	
-	// Add gravity effect to the vertical speed component:
-	SetSpeedY(GetSpeedY() + m_Gravity / 20);
+	// Add slowdown and gravity effect to the speed:
+	Vector3d NewSpeed(GetSpeed());
+	NewSpeed.y += m_Gravity / 20;
+	NewSpeed *= TracerCallback.GetSlowdownCoeff();
+	SetSpeed(NewSpeed);
+	SetRotationFromSpeed();
+	SetPitchFromSpeed();
 
 	// DEBUG:
-	LOGD("Arrow %d: pos {%.02f, %.02f, %.02f}, speed {%.02f, %.02f, %.02f}",
+	LOGD("Projectile %d: pos {%.02f, %.02f, %.02f}, speed {%.02f, %.02f, %.02f}, rot {%.02f, %.02f}",
 		m_UniqueID,
 		GetPosX(), GetPosY(), GetPosZ(),
-		GetSpeedX(), GetSpeedY(), GetSpeedZ()
+		GetSpeedX(), GetSpeedY(), GetSpeedZ(),
+		GetRotation(), GetPitch()
 	);
 }
 
@@ -216,7 +363,8 @@ void cProjectileEntity::HandlePhysics(float a_Dt, cChunk & a_Chunk)
 void cProjectileEntity::SpawnOn(cClientHandle & a_Client)
 {
 	// Default spawning - use the projectile kind to spawn an object:
-	a_Client.SendSpawnObject(*this, m_ProjectileKind, 0, 0, 0);
+	a_Client.SendSpawnObject(*this, m_ProjectileKind, 12, ANGLE_TO_PROTO(GetRotation()), ANGLE_TO_PROTO(GetPitch()));
+	a_Client.SendEntityMetadata(*this);
 }
 
 
@@ -229,12 +377,16 @@ void cProjectileEntity::SpawnOn(cClientHandle & a_Client)
 cArrowEntity::cArrowEntity(cEntity * a_Creator, double a_X, double a_Y, double a_Z, const Vector3d & a_Speed) :
 	super(pkArrow, a_Creator, a_X, a_Y, a_Z, 0.5, 0.5),
 	m_PickupState(psNoPickup),
-	m_DamageCoeff(2)
+	m_DamageCoeff(2),
+	m_IsCritical(false)
 {
 	SetSpeed(a_Speed);
 	SetMass(0.1);
-	LOGD("Created arrow %d with speed {%.02f, %.02f, %.02f}",
-		m_UniqueID, GetSpeedX(), GetSpeedY(), GetSpeedZ()
+	SetRotationFromSpeed();
+	SetPitchFromSpeed();
+	LOGD("Created arrow %d with speed {%.02f, %.02f, %.02f} and rot {%.02f, %.02f}",
+		m_UniqueID, GetSpeedX(), GetSpeedY(), GetSpeedZ(),
+		GetRotation(), GetPitch()
 	);
 }
 
@@ -245,7 +397,8 @@ cArrowEntity::cArrowEntity(cEntity * a_Creator, double a_X, double a_Y, double a
 cArrowEntity::cArrowEntity(cPlayer & a_Player, double a_Force) :
 	super(pkArrow, &a_Player, a_Player.GetThrowStartPos(), a_Player.GetThrowSpeed(a_Force * 1.5 * 20), 0.5, 0.5),
 	m_PickupState(psInSurvivalOrCreative),
-	m_DamageCoeff(2)
+	m_DamageCoeff(2),
+	m_IsCritical((a_Force >= 1))
 {
 }
 
@@ -269,14 +422,43 @@ bool cArrowEntity::CanPickup(const cPlayer & a_Player) const
 
 
 
-void cArrowEntity::SpawnOn(cClientHandle & a_Client)
+void cArrowEntity::OnHitSolidBlock(const Vector3d & a_HitPos, char a_HitFace)
+{
+	super::OnHitSolidBlock(a_HitPos, a_HitFace);
+	
+	// Broadcast the position and speed packets before teleporting:
+	BroadcastMovementUpdate();
+	
+	// Teleport the entity to the exact hit coords:
+	m_World->BroadcastTeleportEntity(*this);
+}
+
+
+
+
+
+void cArrowEntity::OnHitEntity(cEntity & a_EntityHit, const Vector3d & a_HitPos)
 {
-	a_Client.SendSpawnObject(*this, pkArrow, 0, 0, 0);
+	if (!a_EntityHit.IsMob() && !a_EntityHit.IsMinecart() && !a_EntityHit.IsPlayer())
+	{
+		// Not an entity that interacts with an arrow
+		return;
+	}
+	
+	int Damage = (int)(GetSpeed().Length() / 20 * m_DamageCoeff + 0.5);
+	if (m_IsCritical)
+	{
+		Damage += m_World->GetTickRandomNumber(Damage / 2 + 2);
+	}
+	a_EntityHit.TakeDamage(dtRangedAttack, this, Damage, 1);
+	
+	Destroy();
 }
 
 
 
 
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // cThrownEggEntity:
 
@@ -290,7 +472,7 @@ cThrownEggEntity::cThrownEggEntity(cEntity * a_Creator, double a_X, double a_Y,
 
 
 
-void cThrownEggEntity::OnHitSolidBlock(int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace)
+void cThrownEggEntity::OnHitSolidBlock(const Vector3d & a_HitPos, char a_HitFace)
 {
 	// TODO: Random-spawn a chicken or four
 	
@@ -314,9 +496,15 @@ cThrownEnderPearlEntity::cThrownEnderPearlEntity(cEntity * a_Creator, double a_X
 
 
 
-void cThrownEnderPearlEntity::OnHitSolidBlock(int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace)
+void cThrownEnderPearlEntity::OnHitSolidBlock(const Vector3d & a_HitPos, char a_HitFace)
 {
-	// TODO: Teleport the creator here, make them take 5 damage
+	// Teleport the creator here, make them take 5 damage:
+	if (m_Creator != NULL)
+	{
+		// TODO: The coords might need some tweaking based on the block face
+		m_Creator->TeleportToCoords(a_HitPos.x + 0.5, a_HitPos.y + 1.7, a_HitPos.z + 0.5);
+		m_Creator->TakeDamage(dtEnderPearl, this, 5, 0);
+	}
 	
 	Destroy();
 }
@@ -338,7 +526,7 @@ cThrownSnowballEntity::cThrownSnowballEntity(cEntity * a_Creator, double a_X, do
 
 
 
-void cThrownSnowballEntity::OnHitSolidBlock(int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace)
+void cThrownSnowballEntity::OnHitSolidBlock(const Vector3d & a_HitPos, char a_HitFace)
 {
 	// TODO: Apply damage to certain mobs (blaze etc.) and anger all mobs
 	
@@ -349,3 +537,94 @@ void cThrownSnowballEntity::OnHitSolidBlock(int a_BlockX, int a_BlockY, int a_Bl
 
 
 
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cGhastFireballEntity :
+
+cGhastFireballEntity::cGhastFireballEntity(cEntity * a_Creator, double a_X, double a_Y, double a_Z, const Vector3d & a_Speed) :
+	super(pkGhastFireball, a_Creator, a_X, a_Y, a_Z, 1, 1)
+{
+	SetSpeed(a_Speed);
+	SetGravity(0);
+}
+
+
+
+
+
+void cGhastFireballEntity::Explode(int a_BlockX, int a_BlockY, int a_BlockZ)
+{
+	m_World->DoExplosionAt(1, a_BlockX, a_BlockY, a_BlockZ, true, esGhastFireball, this);
+}
+
+
+
+
+
+void cGhastFireballEntity::OnHitSolidBlock(const Vector3d & a_HitPos, char a_HitFace)
+{
+	Destroy();
+	Explode((int)floor(a_HitPos.x), (int)floor(a_HitPos.y), (int)floor(a_HitPos.z));
+}
+
+
+
+
+
+void cGhastFireballEntity::OnHitEntity(cEntity & a_EntityHit, const Vector3d & a_HitPos)
+{
+	Destroy();
+	Explode((int)floor(a_HitPos.x), (int)floor(a_HitPos.y), (int)floor(a_HitPos.z));
+}
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cFireChargeEntity :
+
+cFireChargeEntity::cFireChargeEntity(cEntity * a_Creator, double a_X, double a_Y, double a_Z, const Vector3d & a_Speed) :
+	super(pkFireCharge, a_Creator, a_X, a_Y, a_Z, 0.3125, 0.3125)
+{
+	SetSpeed(a_Speed);
+	SetGravity(0);
+}
+
+
+
+
+
+void cFireChargeEntity::Explode(int a_BlockX, int a_BlockY, int a_BlockZ)
+{
+	if (m_World->GetBlock(a_BlockX, a_BlockY, a_BlockZ) == E_BLOCK_AIR)
+	{
+		m_World->SetBlock(a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_FIRE, 1);
+	}
+}
+
+
+
+
+
+void cFireChargeEntity::OnHitSolidBlock(const Vector3d & a_HitPos, char a_HitFace)
+{
+	Destroy();
+	Explode((int)floor(a_HitPos.x), (int)floor(a_HitPos.y), (int)floor(a_HitPos.z));
+}
+
+
+
+
+
+void cFireChargeEntity::OnHitEntity(cEntity & a_EntityHit, const Vector3d & a_HitPos)
+{
+	Destroy();
+	Explode((int)floor(a_HitPos.x), (int)floor(a_HitPos.y), (int)floor(a_HitPos.z));
+	
+	// TODO: Some entities are immune to hits
+	a_EntityHit.StartBurning(5 * 20);  // 5 seconds of burning
+}
+
+
+
+