8 files changed, 430 insertions, 146 deletions

diff --git a/source/Bindings.cpp b/source/Bindings.cpp
index af3e83dda..cbe728cbf 100644
--- a/source/Bindings.cpp
+++ b/source/Bindings.cpp
@@ -1,6 +1,6 @@
 /*
 ** Lua binding: AllToLua
-** Generated automatically by tolua++-1.0.92 on 08/30/13 14:30:24.
+** Generated automatically by tolua++-1.0.92 on 08/30/13 18:03:04.
 */
 
 #ifndef __cplusplus
@@ -203,63 +203,66 @@ static int tolua_collect_Vector3d (lua_State* tolua_S)
 /* function to register type */
 static void tolua_reg_types (lua_State* tolua_S)
 {
+ tolua_usertype(tolua_S,"cThrownEnderPearlEntity");
  tolua_usertype(tolua_S,"TakeDamageInfo");
- tolua_usertype(tolua_S,"cServer");
+ tolua_usertype(tolua_S,"cPluginManager");
+ tolua_usertype(tolua_S,"cMonster");
+ tolua_usertype(tolua_S,"cCraftingGrid");
  tolua_usertype(tolua_S,"cCraftingRecipe");
  tolua_usertype(tolua_S,"cPlugin");
- tolua_usertype(tolua_S,"cMonster");
+ tolua_usertype(tolua_S,"cWindow");
  tolua_usertype(tolua_S,"cStringMap");
  tolua_usertype(tolua_S,"cItemGrid");
  tolua_usertype(tolua_S,"cBlockArea");
  tolua_usertype(tolua_S,"cEnchantments");
  tolua_usertype(tolua_S,"cLuaWindow");
- tolua_usertype(tolua_S,"cInventory");
+ tolua_usertype(tolua_S,"cServer");
  tolua_usertype(tolua_S,"cRoot");
- tolua_usertype(tolua_S,"cWindow");
+ tolua_usertype(tolua_S,"cCuboid");
  tolua_usertype(tolua_S,"std::vector<cIniFile::key>");
- tolua_usertype(tolua_S,"cCraftingGrid");
+ tolua_usertype(tolua_S,"cGroup");
  tolua_usertype(tolua_S,"cPickup");
  tolua_usertype(tolua_S,"std::vector<std::string>");
- tolua_usertype(tolua_S,"cGroup");
+ tolua_usertype(tolua_S,"cTracer");
  tolua_usertype(tolua_S,"cClientHandle");
  tolua_usertype(tolua_S,"cChunkDesc");
  tolua_usertype(tolua_S,"cFurnaceRecipe");
- tolua_usertype(tolua_S,"cTracer");
- tolua_usertype(tolua_S,"cChatColor");
- tolua_usertype(tolua_S,"cCuboid");
  tolua_usertype(tolua_S,"Vector3i");
- tolua_usertype(tolua_S,"cWorld");
- tolua_usertype(tolua_S,"cEntity");
+ tolua_usertype(tolua_S,"cChatColor");
+ tolua_usertype(tolua_S,"cThrownSnowballEntity");
+ tolua_usertype(tolua_S,"cWebAdmin");
  tolua_usertype(tolua_S,"cCraftingRecipes");
+ tolua_usertype(tolua_S,"cItems");
+ tolua_usertype(tolua_S,"cWebPlugin");
  tolua_usertype(tolua_S,"cItem");
  tolua_usertype(tolua_S,"Vector3f");
  tolua_usertype(tolua_S,"cArrowEntity");
  tolua_usertype(tolua_S,"cDropSpenserEntity");
- tolua_usertype(tolua_S,"cWebPlugin");
- tolua_usertype(tolua_S,"cWebAdmin");
+ tolua_usertype(tolua_S,"sWebAdminPage");
+ tolua_usertype(tolua_S,"HTTPFormData");
  tolua_usertype(tolua_S,"cChestEntity");
  tolua_usertype(tolua_S,"cDispenserEntity");
- tolua_usertype(tolua_S,"sWebAdminPage");
+ tolua_usertype(tolua_S,"HTTPRequest");
  tolua_usertype(tolua_S,"cBlockEntity");
  tolua_usertype(tolua_S,"cItemGrid::cListener");
  tolua_usertype(tolua_S,"HTTPTemplateRequest");
- tolua_usertype(tolua_S,"HTTPRequest");
- tolua_usertype(tolua_S,"HTTPFormData");
  tolua_usertype(tolua_S,"cFurnaceEntity");
  tolua_usertype(tolua_S,"cDropperEntity");
+ tolua_usertype(tolua_S,"cPluginLua");
+ tolua_usertype(tolua_S,"cBlockEntityWithItems");
  tolua_usertype(tolua_S,"cLineBlockTracer");
- tolua_usertype(tolua_S,"cPluginManager");
+ tolua_usertype(tolua_S,"cCriticalSection");
  tolua_usertype(tolua_S,"cIniFile");
- tolua_usertype(tolua_S,"cBlockEntityWithItems");
+ tolua_usertype(tolua_S,"cEntity");
  tolua_usertype(tolua_S,"cListeners");
  tolua_usertype(tolua_S,"cPawn");
- tolua_usertype(tolua_S,"cPlayer");
+ tolua_usertype(tolua_S,"cThrownEggEntity");
  tolua_usertype(tolua_S,"cGroupManager");
  tolua_usertype(tolua_S,"cBlockEntityWindowOwner");
- tolua_usertype(tolua_S,"cCriticalSection");
+ tolua_usertype(tolua_S,"cInventory");
  tolua_usertype(tolua_S,"cProjectileEntity");
- tolua_usertype(tolua_S,"cPluginLua");
- tolua_usertype(tolua_S,"cItems");
+ tolua_usertype(tolua_S,"cWorld");
+ tolua_usertype(tolua_S,"cPlayer");
  tolua_usertype(tolua_S,"Vector3d");
 }
 
@@ -7650,6 +7653,92 @@ static int tolua_AllToLua_cPlayer_GetEquippedItem00(lua_State* tolua_S)
 }
 #endif //#ifndef TOLUA_DISABLE
 
+/* method: GetThrowStartPos of class  cPlayer */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_GetThrowStartPos00
+static int tolua_AllToLua_cPlayer_GetThrowStartPos00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+     !tolua_isusertype(tolua_S,1,"const cPlayer",0,&tolua_err) ||
+     !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+  goto tolua_lerror;
+ else
+#endif
+ {
+  const cPlayer* self = (const cPlayer*)  tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetThrowStartPos'", NULL);
+#endif
+  {
+   Vector3d tolua_ret = (Vector3d)  self->GetThrowStartPos();
+   {
+#ifdef __cplusplus
+    void* tolua_obj = Mtolua_new((Vector3d)(tolua_ret));
+     tolua_pushusertype(tolua_S,tolua_obj,"Vector3d");
+    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+#else
+    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3d));
+     tolua_pushusertype(tolua_S,tolua_obj,"Vector3d");
+    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+#endif
+   }
+  }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetThrowStartPos'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetThrowSpeed of class  cPlayer */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_GetThrowSpeed00
+static int tolua_AllToLua_cPlayer_GetThrowSpeed00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+     !tolua_isusertype(tolua_S,1,"const cPlayer",0,&tolua_err) ||
+     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+     !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+  goto tolua_lerror;
+ else
+#endif
+ {
+  const cPlayer* self = (const cPlayer*)  tolua_tousertype(tolua_S,1,0);
+  double a_SpeedCoeff = ((double)  tolua_tonumber(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetThrowSpeed'", NULL);
+#endif
+  {
+   Vector3d tolua_ret = (Vector3d)  self->GetThrowSpeed(a_SpeedCoeff);
+   {
+#ifdef __cplusplus
+    void* tolua_obj = Mtolua_new((Vector3d)(tolua_ret));
+     tolua_pushusertype(tolua_S,tolua_obj,"Vector3d");
+    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+#else
+    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3d));
+     tolua_pushusertype(tolua_S,tolua_obj,"Vector3d");
+    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+#endif
+   }
+  }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetThrowSpeed'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
 /* method: GetGameMode of class  cPlayer */
 #ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_GetGameMode00
 static int tolua_AllToLua_cPlayer_GetGameMode00(lua_State* tolua_S)
@@ -9704,88 +9793,6 @@ static int tolua_AllToLua_cProjectileEntity_IsInGround00(lua_State* tolua_S)
 }
 #endif //#ifndef TOLUA_DISABLE
 
-/* method: PosFromPlayerPos of class  cArrowEntity */
-#ifndef TOLUA_DISABLE_tolua_AllToLua_cArrowEntity_PosFromPlayerPos00
-static int tolua_AllToLua_cArrowEntity_PosFromPlayerPos00(lua_State* tolua_S)
-{
-#ifndef TOLUA_RELEASE
- tolua_Error tolua_err;
- if (
-     !tolua_isusertable(tolua_S,1,"cArrowEntity",0,&tolua_err) ||
-     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cPlayer",0,&tolua_err)) ||
-     !tolua_isnoobj(tolua_S,3,&tolua_err)
- )
-  goto tolua_lerror;
- else
-#endif
- {
-  const cPlayer* a_Player = ((const cPlayer*)  tolua_tousertype(tolua_S,2,0));
-  {
-   Vector3d tolua_ret = (Vector3d)  cArrowEntity::PosFromPlayerPos(*a_Player);
-   {
-#ifdef __cplusplus
-    void* tolua_obj = Mtolua_new((Vector3d)(tolua_ret));
-     tolua_pushusertype(tolua_S,tolua_obj,"Vector3d");
-    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
-#else
-    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3d));
-     tolua_pushusertype(tolua_S,tolua_obj,"Vector3d");
-    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
-#endif
-   }
-  }
- }
- return 1;
-#ifndef TOLUA_RELEASE
- tolua_lerror:
- tolua_error(tolua_S,"#ferror in function 'PosFromPlayerPos'.",&tolua_err);
- return 0;
-#endif
-}
-#endif //#ifndef TOLUA_DISABLE
-
-/* method: SpeedFromPlayerLook of class  cArrowEntity */
-#ifndef TOLUA_DISABLE_tolua_AllToLua_cArrowEntity_SpeedFromPlayerLook00
-static int tolua_AllToLua_cArrowEntity_SpeedFromPlayerLook00(lua_State* tolua_S)
-{
-#ifndef TOLUA_RELEASE
- tolua_Error tolua_err;
- if (
-     !tolua_isusertable(tolua_S,1,"cArrowEntity",0,&tolua_err) ||
-     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cPlayer",0,&tolua_err)) ||
-     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
-     !tolua_isnoobj(tolua_S,4,&tolua_err)
- )
-  goto tolua_lerror;
- else
-#endif
- {
-  const cPlayer* a_Player = ((const cPlayer*)  tolua_tousertype(tolua_S,2,0));
-  double a_Force = ((double)  tolua_tonumber(tolua_S,3,0));
-  {
-   Vector3d tolua_ret = (Vector3d)  cArrowEntity::SpeedFromPlayerLook(*a_Player,a_Force);
-   {
-#ifdef __cplusplus
-    void* tolua_obj = Mtolua_new((Vector3d)(tolua_ret));
-     tolua_pushusertype(tolua_S,tolua_obj,"Vector3d");
-    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
-#else
-    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3d));
-     tolua_pushusertype(tolua_S,tolua_obj,"Vector3d");
-    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
-#endif
-   }
-  }
- }
- return 1;
-#ifndef TOLUA_RELEASE
- tolua_lerror:
- tolua_error(tolua_S,"#ferror in function 'SpeedFromPlayerLook'.",&tolua_err);
- return 0;
-#endif
-}
-#endif //#ifndef TOLUA_DISABLE
-
 /* method: GetPickupState of class  cArrowEntity */
 #ifndef TOLUA_DISABLE_tolua_AllToLua_cArrowEntity_GetPickupState00
 static int tolua_AllToLua_cArrowEntity_GetPickupState00(lua_State* tolua_S)
@@ -28588,6 +28595,8 @@ TOLUA_API int tolua_AllToLua_open (lua_State* tolua_S)
    tolua_function(tolua_S,"GetStance",tolua_AllToLua_cPlayer_GetStance00);
    tolua_function(tolua_S,"GetInventory",tolua_AllToLua_cPlayer_GetInventory00);
    tolua_function(tolua_S,"GetEquippedItem",tolua_AllToLua_cPlayer_GetEquippedItem00);
+   tolua_function(tolua_S,"GetThrowStartPos",tolua_AllToLua_cPlayer_GetThrowStartPos00);
+   tolua_function(tolua_S,"GetThrowSpeed",tolua_AllToLua_cPlayer_GetThrowSpeed00);
    tolua_function(tolua_S,"GetGameMode",tolua_AllToLua_cPlayer_GetGameMode00);
    tolua_function(tolua_S,"SetGameMode",tolua_AllToLua_cPlayer_SetGameMode00);
    tolua_function(tolua_S,"IsGameModeCreative",tolua_AllToLua_cPlayer_IsGameModeCreative00);
@@ -28677,14 +28686,21 @@ TOLUA_API int tolua_AllToLua_open (lua_State* tolua_S)
    tolua_constant(tolua_S,"psNoPickup",cArrowEntity::psNoPickup);
    tolua_constant(tolua_S,"psInSurvivalOrCreative",cArrowEntity::psInSurvivalOrCreative);
    tolua_constant(tolua_S,"psInCreative",cArrowEntity::psInCreative);
-   tolua_function(tolua_S,"PosFromPlayerPos",tolua_AllToLua_cArrowEntity_PosFromPlayerPos00);
-   tolua_function(tolua_S,"SpeedFromPlayerLook",tolua_AllToLua_cArrowEntity_SpeedFromPlayerLook00);
    tolua_function(tolua_S,"GetPickupState",tolua_AllToLua_cArrowEntity_GetPickupState00);
    tolua_function(tolua_S,"SetPickupState",tolua_AllToLua_cArrowEntity_SetPickupState00);
    tolua_function(tolua_S,"GetDamageCoeff",tolua_AllToLua_cArrowEntity_GetDamageCoeff00);
    tolua_function(tolua_S,"SetDamageCoeff",tolua_AllToLua_cArrowEntity_SetDamageCoeff00);
    tolua_function(tolua_S,"CanPickup",tolua_AllToLua_cArrowEntity_CanPickup00);
   tolua_endmodule(tolua_S);
+  tolua_cclass(tolua_S,"cThrownEggEntity","cThrownEggEntity","cProjectileEntity",NULL);
+  tolua_beginmodule(tolua_S,"cThrownEggEntity");
+  tolua_endmodule(tolua_S);
+  tolua_cclass(tolua_S,"cThrownEnderPearlEntity","cThrownEnderPearlEntity","cProjectileEntity",NULL);
+  tolua_beginmodule(tolua_S,"cThrownEnderPearlEntity");
+  tolua_endmodule(tolua_S);
+  tolua_cclass(tolua_S,"cThrownSnowballEntity","cThrownSnowballEntity","cProjectileEntity",NULL);
+  tolua_beginmodule(tolua_S,"cThrownSnowballEntity");
+  tolua_endmodule(tolua_S);
   tolua_cclass(tolua_S,"cPluginManager","cPluginManager","",NULL);
   tolua_beginmodule(tolua_S,"cPluginManager");
    tolua_constant(tolua_S,"HOOK_BLOCK_TO_PICKUPS",cPluginManager::HOOK_BLOCK_TO_PICKUPS);
diff --git a/source/Bindings.h b/source/Bindings.h
index e5b7e0f76..faa81e4c8 100644
--- a/source/Bindings.h
+++ b/source/Bindings.h
@@ -1,6 +1,6 @@
 /*
 ** Lua binding: AllToLua
-** Generated automatically by tolua++-1.0.92 on 08/30/13 14:30:25.
+** Generated automatically by tolua++-1.0.92 on 08/30/13 18:03:05.
 */
 
 /* Exported function */
diff --git a/source/Entities/Player.cpp b/source/Entities/Player.cpp
index 0cb047933..0943f61ff 100644
--- a/source/Entities/Player.cpp
+++ b/source/Entities/Player.cpp
@@ -857,6 +857,36 @@ void cPlayer::TeleportToCoords(double a_PosX, double a_PosY, double a_PosZ)
 
 
 
+Vector3d cPlayer::GetThrowStartPos(void) const
+{
+	Vector3d res = GetEyePosition();
+	
+	// Adjust the position to be just outside the player's bounding box:
+	res.x += 0.16 * cos(GetPitch());
+	res.y += -0.1;
+	res.z += 0.16 * sin(GetPitch());
+	
+	return res;
+}
+
+
+
+
+
+Vector3d cPlayer::GetThrowSpeed(double a_SpeedCoeff) const
+{
+	Vector3d res = GetLookVector();
+	res.Normalize();
+	
+	// TODO: Add a slight random change (+-0.0075 in each direction)
+	
+	return res * a_SpeedCoeff;
+}	
+
+
+
+
+
 void cPlayer::MoveTo( const Vector3d & a_NewPos )
 {
 	if ((a_NewPos.y < -990) && (GetPosY() > -100))
diff --git a/source/Entities/Player.h b/source/Entities/Player.h
index 4adf946db..82ff48954 100644
--- a/source/Entities/Player.h
+++ b/source/Entities/Player.h
@@ -73,7 +73,7 @@ public:
 	void CancelChargingBow(void);
 	
 	/// Returns true if the player is currently charging the bow
-	bool IsChargingBox(void) const { return m_IsChargingBow; }
+	bool IsChargingBow(void) const { return m_IsChargingBow; }
 
 	void SetTouchGround( bool a_bTouchGround );
 	inline void SetStance( const double a_Stance ) { m_Stance = a_Stance; }
@@ -90,6 +90,12 @@ public:
 
 	// tolua_begin
 	
+	/// Returns the position where projectiles thrown by this player should start, player eye position + adjustment
+	Vector3d GetThrowStartPos(void) const;
+	
+	/// Returns the initial speed vector of a throw, with a 3D length of a_SpeedCoeff.
+	Vector3d GetThrowSpeed(double a_SpeedCoeff) const;
+	
 	/// Returns the current gamemode. Partly OBSOLETE, you should use IsGameModeXXX() functions wherever applicable
 	eGameMode GetGameMode(void) const { return m_GameMode; }
 	
diff --git a/source/Entities/ProjectileEntity.cpp b/source/Entities/ProjectileEntity.cpp
index f405e9aa4..91b2c97a8 100644
--- a/source/Entities/ProjectileEntity.cpp
+++ b/source/Entities/ProjectileEntity.cpp
@@ -101,11 +101,14 @@ 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 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);
 		// TODO: the rest
 	}
 	
-	LOGWARNING("%s: Unknown kind: %d", __FUNCTION__, a_Kind);
+	LOGWARNING("%s: Unknown projectile kind: %d", __FUNCTION__, a_Kind);
 	return NULL;
 }
 
@@ -210,10 +213,20 @@ 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);
+}
+
+
+
+
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // cArrowEntity:
 
-cArrowEntity::cArrowEntity(cEntity * a_Creator, double a_X, double a_Y, double a_Z, const Vector3d a_Speed) :
+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)
@@ -230,7 +243,7 @@ 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, PosFromPlayerPos(a_Player), SpeedFromPlayerLook(a_Player, a_Force), 0.5, 0.5),
+	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)
 {
@@ -240,57 +253,99 @@ cArrowEntity::cArrowEntity(cPlayer & a_Player, double a_Force) :
 
 
 
-Vector3d cArrowEntity::PosFromPlayerPos(const cPlayer & a_Player)
+bool cArrowEntity::CanPickup(const cPlayer & a_Player) const
 {
-	Vector3d res = a_Player.GetEyePosition();
-	
-	// Adjust the position to be just outside the player's bounding box:
-	res.x += 0.16 * cos(a_Player.GetPitch());
-	res.y += -0.1;
-	res.z += 0.16 * sin(a_Player.GetPitch());
-	
-	return res;
+	switch (m_PickupState)
+	{
+		case psNoPickup:             return false;
+		case psInSurvivalOrCreative: return (a_Player.IsGameModeSurvival() || a_Player.IsGameModeCreative());
+		case psInCreative:           return a_Player.IsGameModeCreative();
+	}
+	ASSERT(!"Unhandled pickup state");
+	return false;
 }
 
 
 
 
 
-Vector3d cArrowEntity::SpeedFromPlayerLook(const cPlayer & a_Player, double a_Force)
+void cArrowEntity::SpawnOn(cClientHandle & a_Client)
 {
-	Vector3d res = a_Player.GetLookVector();
-	res.Normalize();
+	a_Client.SendSpawnObject(*this, pkArrow, 0, 0, 0);
+}
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cThrownEggEntity:
+
+cThrownEggEntity::cThrownEggEntity(cEntity * a_Creator, double a_X, double a_Y, double a_Z, const Vector3d & a_Speed) :
+	super(pkEgg, a_Creator, a_X, a_Y, a_Z, 0.25, 0.25)
+{
+	SetSpeed(a_Speed);
+}
+
+
+
+
+
+void cThrownEggEntity::OnHitSolidBlock(int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace)
+{
+	// TODO: Random-spawn a chicken or four
 	
-	// TODO: Add a slight random change (+-0.0075 in each direction)
+	Destroy();
+}
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cThrownEnderPearlEntity :
+
+cThrownEnderPearlEntity::cThrownEnderPearlEntity(cEntity * a_Creator, double a_X, double a_Y, double a_Z, const Vector3d & a_Speed) :
+	super(pkEnderPearl, a_Creator, a_X, a_Y, a_Z, 0.25, 0.25)
+{
+	SetSpeed(a_Speed);
+}
+
+
+
+
+
+void cThrownEnderPearlEntity::OnHitSolidBlock(int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace)
+{
+	// TODO: Teleport the creator here, make them take 5 damage
 	
-	return res * a_Force * 1.5 * 20;
+	Destroy();
 }
 
 
 
 
 
-bool cArrowEntity::CanPickup(const cPlayer & a_Player) const
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cThrownSnowballEntity :
+
+cThrownSnowballEntity::cThrownSnowballEntity(cEntity * a_Creator, double a_X, double a_Y, double a_Z, const Vector3d & a_Speed) :
+	super(pkSnowball, a_Creator, a_X, a_Y, a_Z, 0.25, 0.25)
 {
-	switch (m_PickupState)
-	{
-		case psNoPickup:             return false;
-		case psInSurvivalOrCreative: return (a_Player.IsGameModeSurvival() || a_Player.IsGameModeCreative());
-		case psInCreative:           return a_Player.IsGameModeCreative();
-	}
-	ASSERT(!"Unhandled pickup state");
-	return false;
+	SetSpeed(a_Speed);
 }
 
 
 
 
 
-void cArrowEntity::SpawnOn(cClientHandle & a_Client)
+void cThrownSnowballEntity::OnHitSolidBlock(int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace)
 {
-	a_Client.SendSpawnObject(*this, pkArrow, 0, 0, 0);
+	// TODO: Apply damage to certain mobs (blaze etc.) and anger all mobs
+	
+	Destroy();
 }
 
 
 
 
+
diff --git a/source/Entities/ProjectileEntity.h b/source/Entities/ProjectileEntity.h
index 1569ad035..95dc00abc 100644
--- a/source/Entities/ProjectileEntity.h
+++ b/source/Entities/ProjectileEntity.h
@@ -78,6 +78,7 @@ protected:
 	// cEntity overrides:
 	virtual void Tick(float a_Dt, cChunk & a_Chunk) override;
 	virtual void HandlePhysics(float a_Dt, cChunk & a_Chunk) override;
+	virtual void SpawnOn(cClientHandle & a_Client) override;
 	
 	// tolua_begin
 } ;
@@ -105,19 +106,13 @@ public:
 	CLASS_PROTODEF(cArrowEntity);
 
 	/// Creates a new arrow with psNoPickup state and default damage modifier coeff
-	cArrowEntity(cEntity * a_Creator, double a_X, double a_Y, double a_Z, const Vector3d a_Speed);
+	cArrowEntity(cEntity * a_Creator, double a_X, double a_Y, double a_Z, const Vector3d & a_Speed);
 	
 	/// Creates a new arrow as shot by a player, initializes it from the player object
 	cArrowEntity(cPlayer & a_Player, double a_Force);
 	
 	// tolua_begin
 	
-	/// Returns the initial arrow position, as defined by the player eye position + adjustment.
-	static Vector3d PosFromPlayerPos(const cPlayer & a_Player);
-
-	/// Returns the initial arrow speed, as defined by the player look vector and the force coefficient
-	static Vector3d SpeedFromPlayerLook(const cPlayer & a_Player, double a_Force);
-	
 	/// Returns whether the arrow can be picked up by players
 	ePickupState GetPickupState(void) const { return m_PickupState; }
 	
@@ -143,12 +138,100 @@ protected:
 	/// The coefficient applied to the damage that the arrow will deal, based on the bow enchantment. 2.0 for normal arrow
 	double m_DamageCoeff;
 
-	// cEntity overrides:
+	// cProjectileEntity overrides:
 	virtual void SpawnOn(cClientHandle & a_Client) override;
 	
 	// tolua_begin
 } ;
 
+
+
+
+
+class cThrownEggEntity :
+	public cProjectileEntity
+{
+	typedef cProjectileEntity super;
+	
+public:
+
+	// tolua_end
+	
+	CLASS_PROTODEF(cThrownEggEntity);
+
+	cThrownEggEntity(cEntity * a_Creator, double a_X, double a_Y, double a_Z, const Vector3d & a_Speed);
+	
+protected:
+
+	// tolua_end
+	
+	// cProjectileEntity overrides:
+	virtual void OnHitSolidBlock(int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace) override;
+
+	// tolua_begin
+	
+} ;
+
+
+
+
+
+class cThrownEnderPearlEntity :
+	public cProjectileEntity
+{
+	typedef cProjectileEntity super;
+	
+public:
+
+	// tolua_end
+	
+	CLASS_PROTODEF(cThrownEnderPearlEntity);
+
+	cThrownEnderPearlEntity(cEntity * a_Creator, double a_X, double a_Y, double a_Z, const Vector3d & a_Speed);
+	
+protected:
+
+	// tolua_end
+	
+	// cProjectileEntity overrides:
+	virtual void OnHitSolidBlock(int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace) override;
+
+	// tolua_begin
+	
+} ;
+
+
+
+
+
+class cThrownSnowballEntity :
+	public cProjectileEntity
+{
+	typedef cProjectileEntity super;
+	
+public:
+
+	// tolua_end
+	
+	CLASS_PROTODEF(cThrownSnowballEntity);
+
+	cThrownSnowballEntity(cEntity * a_Creator, double a_X, double a_Y, double a_Z, const Vector3d & a_Speed);
+	
+protected:
+
+	// tolua_end
+	
+	// cProjectileEntity overrides:
+	virtual void OnHitSolidBlock(int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace) override;
+
+	// tolua_begin
+	
+} ;
+
+
+
+
+
 // tolua_end
 
 
diff --git a/source/Items/ItemHandler.cpp b/source/Items/ItemHandler.cpp
index c0de4a6ec..2ae193d52 100644
--- a/source/Items/ItemHandler.cpp
+++ b/source/Items/ItemHandler.cpp
@@ -22,6 +22,7 @@
 #include "ItemLighter.h"
 #include "ItemMinecart.h"
 #include "ItemPickaxe.h"
+#include "ItemThrowable.h"
 #include "ItemRedstoneDust.h"
 #include "ItemRedstoneRepeater.h"
 #include "ItemSapling.h"
@@ -88,12 +89,15 @@ cItemHandler *cItemHandler::CreateItemHandler(int a_ItemType)
 		case E_ITEM_BREWING_STAND:     return new cItemBrewingStandHandler(a_ItemType);
 		case E_ITEM_CAULDRON:          return new cItemCauldronHandler(a_ItemType);
 		case E_ITEM_DYE:               return new cItemDyeHandler(a_ItemType);
+		case E_ITEM_EGG:               return new cItemEggHandler();
+		case E_ITEM_ENDER_PEARL:       return new cItemEnderPearlHandler();
 		case E_ITEM_FLINT_AND_STEEL:   return new cItemLighterHandler(a_ItemType);
 		case E_ITEM_FLOWER_POT:        return new cItemFlowerPotHandler(a_ItemType);
 		case E_ITEM_REDSTONE_DUST:     return new cItemRedstoneDustHandler(a_ItemType);
 		case E_ITEM_REDSTONE_REPEATER: return new cItemRedstoneRepeaterHandler(a_ItemType);
 		case E_ITEM_SHEARS:            return new cItemShearsHandler(a_ItemType);
 		case E_ITEM_SIGN:              return new cItemSignHandler(a_ItemType);
+		case E_ITEM_SNOWBALL:          return new cItemSnowballHandler();
 		case E_ITEM_SPAWN_EGG:         return new cItemSpawnEggHandler(a_ItemType);
 		case E_ITEM_SUGARCANE:         return new cItemSugarcaneHandler(a_ItemType);
 		
diff --git a/source/Items/ItemThrowable.h b/source/Items/ItemThrowable.h
new file mode 100644
index 000000000..dacdb6157
--- /dev/null
+++ b/source/Items/ItemThrowable.h
@@ -0,0 +1,90 @@
+
+// ItemThrowable.h
+
+// Declares the itemhandlers for throwable items: eggs, snowballs and ender pearls
+
+
+
+
+
+#pragma once
+
+
+
+
+
+class cItemThrowableHandler :
+	public cItemHandler
+{
+	typedef cItemHandler super;
+public:
+	cItemThrowableHandler(int a_ItemType, cProjectileEntity::eKind a_ProjectileKind, double a_SpeedCoeff) :
+		super(a_ItemType),
+		m_ProjectileKind(a_ProjectileKind),
+		m_SpeedCoeff(a_SpeedCoeff)
+	{
+	}
+	
+
+	virtual bool OnItemUse(cWorld * a_World, cPlayer * a_Player, const cItem & a_Item, int a_BlockX, int a_BlockY, int a_BlockZ, char a_Dir) override
+	{
+		Vector3d Pos = a_Player->GetThrowStartPos();
+		Vector3d Speed = a_Player->GetLookVector() * m_SpeedCoeff;
+		a_World->CreateProjectile(Pos.x, Pos.y, Pos.z, m_ProjectileKind, a_Player, &Speed);
+		return true;
+	}
+	
+protected:
+	cProjectileEntity::eKind m_ProjectileKind;
+	double m_SpeedCoeff;
+} ;
+
+
+
+
+
+class cItemEggHandler :
+	public cItemThrowableHandler
+{
+	typedef cItemThrowableHandler super;
+public:
+	cItemEggHandler(void) :
+		super(E_ITEM_EGG, cProjectileEntity::pkEgg, 30)
+	{
+	}
+} ;
+
+
+
+
+class cItemSnowballHandler :
+	public cItemThrowableHandler
+{
+	typedef cItemThrowableHandler super;
+	
+public:
+	cItemSnowballHandler(void) :
+		super(E_ITEM_SNOWBALL, cProjectileEntity::pkSnowball, 30)
+	{
+	}
+} ;
+
+
+
+
+
+class cItemEnderPearlHandler :
+	public cItemThrowableHandler
+{
+	typedef cItemThrowableHandler super;
+	
+public:
+	cItemEnderPearlHandler(void) :
+		super(E_ITEM_ENDER_PEARL, cProjectileEntity::pkEnderPearl, 30)
+	{
+	}
+} ;
+
+
+
+