Initial commit

1 files changed, 929 insertions, 0 deletions

diff --git a/Minecraft.Client/TrackedEntity.cpp b/Minecraft.Client/TrackedEntity.cpp
new file mode 100644
index 00000000..70f25c93
--- /dev/null
+++ b/Minecraft.Client/TrackedEntity.cpp
@@ -0,0 +1,929 @@
+#include "stdafx.h"
+#include "TrackedEntity.h"
+#include "ServerPlayer.h"
+#include "PlayerConnection.h"
+#include "..\Minecraft.World\Mth.h"
+#include "..\Minecraft.World\net.minecraft.world.entity.h"
+#include "..\Minecraft.World\net.minecraft.world.entity.item.h"
+#include "..\Minecraft.World\net.minecraft.world.entity.monster.h"
+#include "..\Minecraft.World\net.minecraft.world.entity.player.h"
+#include "..\Minecraft.World\net.minecraft.world.entity.animal.h"
+#include "..\Minecraft.World\net.minecraft.world.entity.global.h"
+#include "..\Minecraft.World\net.minecraft.world.entity.projectile.h"
+#include "..\Minecraft.World\net.minecraft.network.packet.h"
+#include "..\Minecraft.World\net.minecraft.world.item.h"
+#include "..\Minecraft.World\net.minecraft.world.level.saveddata.h"
+#include "MinecraftServer.h"
+#include "ServerLevel.h"
+#include "PlayerList.h"
+#include "EntityTracker.h"
+#include "PlayerChunkMap.h"
+#include <qnet.h>
+
+TrackedEntity::TrackedEntity(shared_ptr<Entity> e, int range, int updateInterval, bool trackDelta)
+{
+	// 4J added initialisers
+    xap = yap = zap = 0;
+    tickCount = 0;
+	xpu = ypu = zpu = 0;
+    updatedPlayerVisibility = false;
+    teleportDelay = 0;
+	moved = false;
+	
+	this->e = e;
+    this->range = range;
+    this->updateInterval = updateInterval;
+    this->trackDelta = trackDelta;
+
+    xp = Mth::floor(e->x * 32);
+    yp = Mth::floor(e->y * 32);
+    zp = Mth::floor(e->z * 32);
+
+    yRotp = Mth::floor(e->yRot * 256 / 360);
+    xRotp = Mth::floor(e->xRot * 256 / 360);
+	yHeadRotp = Mth::floor(e->getYHeadRot() * 256 / 360);
+}
+
+int c0a = 0, c0b = 0, c1a = 0, c1b = 0, c1c = 0, c2a = 0, c2b = 0;
+
+void TrackedEntity::tick(EntityTracker *tracker, vector<shared_ptr<Player> > *players)
+{
+    moved = false;
+    if (!updatedPlayerVisibility || e->distanceToSqr(xpu, ypu, zpu) > 4 * 4)
+	{
+        xpu = e->x;
+        ypu = e->y;
+        zpu = e->z;
+        updatedPlayerVisibility = true;
+        moved = true;
+        updatePlayers(tracker, players);
+    }
+
+	if (wasRiding != e->riding)
+	{
+		wasRiding = e->riding;
+		broadcast(shared_ptr<SetRidingPacket>(new SetRidingPacket(e, e->riding)));
+	}
+
+	// Moving forward  special case for item frames
+	if (e->GetType()== eTYPE_ITEM_FRAME && tickCount % 10 == 0) 
+	{
+		shared_ptr<ItemFrame> frame = dynamic_pointer_cast<ItemFrame> (e);
+		shared_ptr<ItemInstance> item = frame->getItem();
+
+		if (item != NULL && item->getItem()->id == Item::map_Id && !e->removed) 
+		{
+ 			shared_ptr<MapItemSavedData> data = Item::map->getSavedData(item, e->level);
+ 			for (AUTO_VAR(it,players->begin() ); it != players->end(); ++it)
+			{
+ 				shared_ptr<ServerPlayer> player = dynamic_pointer_cast<ServerPlayer>(*it);
+ 				data->tickCarriedBy(player, item);
+ 
+ 				if (!player->removed && player->connection && player->connection->countDelayedPackets() <= 5) 
+ 				{
+ 					shared_ptr<Packet> packet = Item::map->getUpdatePacket(item, e->level, player);
+ 					if (packet != NULL) player->connection->send(packet);
+ 				}
+ 			}
+		}
+
+		shared_ptr<SynchedEntityData> entityData = e->getEntityData();
+		if (entityData->isDirty()) 
+		{
+			broadcastAndSend( shared_ptr<SetEntityDataPacket>( new SetEntityDataPacket(e->entityId, entityData, false) ) );
+		}
+	}
+	else
+	{
+		if(e->riding == NULL)
+		{
+			teleportDelay++;
+			if (tickCount++ % updateInterval == 0 || e->hasImpulse)
+			{
+				int xn = Mth::floor(this->e->x * 32.0);
+				int yn = Mth::floor(this->e->y * 32.0);
+				int zn = Mth::floor(this->e->z * 32.0);
+				int yRotn = Mth::floor(e->yRot * 256 / 360);
+				int xRotn = Mth::floor(e->xRot * 256 / 360);
+
+
+				int xa = xn - xp;
+				int ya = yn - yp;
+				int za = zn - zp;
+
+				shared_ptr<Packet> packet = nullptr;
+
+				// 4J - this pos flag used to be set based on abs(xn) etc. but that just seems wrong
+				bool pos = abs(xa) >= TOLERANCE_LEVEL || abs(ya) >= TOLERANCE_LEVEL || abs(za) >= TOLERANCE_LEVEL;
+				// 4J - changed rotation to be generally sent as a delta as well as position
+				int yRota = yRotn - yRotp;
+				int xRota = xRotn - xRotp;
+				// Keep rotation deltas in +/- 180 degree range 
+				while( yRota > 127 ) yRota -= 256;
+				while( yRota < -128 ) yRota += 256;
+				while( xRota > 127 ) xRota -= 256;
+				while( xRota < -128 ) xRota += 256;
+
+				bool rot = abs(yRota) >= TOLERANCE_LEVEL || abs(xRota) >= TOLERANCE_LEVEL;
+
+				if (xa < -128 || xa >= 128 || ya < -128 || ya >= 128 || za < -128 || za >= 128
+					// 4J Stu - I fixed the initialisation of teleportDelay in the ctor, but we managed this far without out
+						// and would prefer not to have all the extra traffix so ignore it
+							// 4J Stu - Fix for #9579 - GAMEPLAY: Boats with a player in them slowly sink under the water over time, and with no player in them they float into the sky.
+								|| (e->GetType() == eTYPE_BOAT && teleportDelay > 20 * 20)
+								)
+				{
+					teleportDelay = 0;
+					packet = shared_ptr<TeleportEntityPacket>( new TeleportEntityPacket(e->entityId, xn, yn, zn, (byte) yRotn, (byte) xRotn) );
+					//			printf("%d: New teleport rot %d\n",e->entityId,yRotn);
+					yRotp = yRotn;
+					xRotp = xRotn;
+				}
+				else
+				{
+					if (pos && rot)
+					{
+						// 4J If the movement is small enough, and there's no xrot, then use the new smaller packets
+						if( ( xa >= -16 ) && ( xa <= 15 ) &&
+							( za >= -16 ) && ( za <= 15 ) &&
+							( ya >= -32 ) && ( ya <= 31 ) &&
+							( xRota == 0 ))
+						{
+							// Clamp rotations that are too big
+							if( yRota < -16 )
+							{
+								yRota = -16;
+								yRotn = yRotp + yRota;
+							}
+							else if( yRota > 15 )
+							{
+								yRota = 15;
+								yRotn = yRotp + yRota;
+							}
+							// 5 bits each for x & z, and 6 for y
+							packet = shared_ptr<MoveEntityPacketSmall>( new MoveEntityPacketSmall::PosRot(e->entityId, (char) xa, (char) ya, (char) za, (char) yRota, 0 ) );
+							c0a++;
+						}
+						else
+						{
+							packet = shared_ptr<MoveEntityPacket>( new MoveEntityPacket::PosRot(e->entityId, (char) xa, (char) ya, (char) za, (char) yRota, (char) xRota) );
+							//					printf("%d: New posrot %d + %d = %d\n",e->entityId,yRotp,yRota,yRotn);
+							c0b++;
+						}
+					}
+					else if (pos)
+					{
+						// 4J If the movement is small enough, then use the new smaller packets
+						if( ( xa >= -8 ) && ( xa <= 7 ) &&
+							( za >= -8 ) && ( za <= 7 ) &&
+							( ya >= -16 ) && ( ya <= 15 ) )
+						{
+							// 4 bits each for x & z, and 5 for y
+							packet = shared_ptr<MoveEntityPacketSmall>( new MoveEntityPacketSmall::Pos(e->entityId, (char) xa, (char) ya, (char) za) );
+							c1a++;
+						}
+
+						else if( ( xa >= -16 ) && ( xa <= 15 ) &&
+							( za >= -16 ) && ( za <= 15 ) &&
+							( ya >= -32 ) && ( ya <= 31 ) )
+						{
+							// use the packet with small packet with rotation if we can - 5 bits each for x & z, and 6 for y - still a byte less than the alternative
+							packet = shared_ptr<MoveEntityPacketSmall>( new MoveEntityPacketSmall::PosRot(e->entityId, (char) xa, (char) ya, (char) za, 0, 0 ));
+							c1b++;
+						}
+						else
+						{
+							packet = shared_ptr<MoveEntityPacket>( new MoveEntityPacket::Pos(e->entityId, (char) xa, (char) ya, (char) za) );
+							c1c++;
+						}
+					}
+					else if (rot)
+					{
+						// 4J If there's no x rotation, then use the new smaller packet type
+						if( xRota == 0 )
+						{
+							// Clamp rotations that are too big
+							if( yRota < -16 )
+							{
+								yRota = -16;
+								yRotn = yRotp + yRota;
+							}
+							else if( yRota > 15 )
+							{
+								yRota = 15;
+								yRotn = yRotp + yRota;
+							}
+							packet = shared_ptr<MoveEntityPacketSmall>( new MoveEntityPacketSmall::Rot(e->entityId, (char) yRota, 0) );
+							c2a++;
+						}
+						else
+						{
+							//					printf("%d: New rot %d + %d = %d\n",e->entityId,yRotp,yRota,yRotn);
+							packet = shared_ptr<MoveEntityPacket>( new MoveEntityPacket::Rot(e->entityId, (char) yRota, (char) xRota) );
+							c2b++;
+						}
+					}
+				}
+
+				if (trackDelta)
+				{
+					double xad = e->xd - xap;
+					double yad = e->yd - yap;
+					double zad = e->zd - zap;
+
+					double max = 0.02;
+
+					double diff = xad * xad + yad * yad + zad * zad;
+
+					if (diff > max * max || (diff > 0 && e->xd == 0 && e->yd == 0 && e->zd == 0))
+					{
+						xap = e->xd;
+						yap = e->yd;
+						zap = e->zd;
+						broadcast( shared_ptr<SetEntityMotionPacket>( new SetEntityMotionPacket(e->entityId, xap, yap, zap) ) );
+					}
+
+				}
+
+				if (packet != NULL)
+				{
+					broadcast(packet);
+				}
+
+				shared_ptr<SynchedEntityData> entityData = e->getEntityData();
+
+				if (entityData->isDirty())
+				{
+					broadcastAndSend( shared_ptr<SetEntityDataPacket>( new SetEntityDataPacket(e->entityId, entityData, false) ) );
+				}
+
+				int yHeadRot = Mth::floor(e->getYHeadRot() * 256 / 360);
+				if (abs(yHeadRot - yHeadRotp) >= TOLERANCE_LEVEL)
+				{
+					broadcast(shared_ptr<RotateHeadPacket>(new RotateHeadPacket(e->entityId, (byte) yHeadRot)));
+					yHeadRotp = yHeadRot;
+				}
+
+				if (pos)
+				{
+					xp = xn;
+					yp = yn;
+					zp = zn;
+				}
+				if (rot)
+				{
+					yRotp = yRotn;
+					xRotp = xRotn;
+				}
+
+				//		if( dynamic_pointer_cast<ServerPlayer>(e) != NULL )
+				//		{
+				//			printf("%d: %d + %d = %d (%f)\n",e->entityId,xRotp,xRota,xRotn,e->xRot);
+				//		}
+			}
+			
+		}
+		else // 4J-JEV: Added: Mobs in minecarts weren't synching their invisibility.
+		{
+			shared_ptr<SynchedEntityData> entityData = e->getEntityData();
+			if (entityData->isDirty())
+				broadcastAndSend( shared_ptr<SetEntityDataPacket>( new SetEntityDataPacket(e->entityId, entityData, false) ) );
+		}
+		e->hasImpulse = false;
+	}
+
+    if (e->hurtMarked)
+	{
+        // broadcast(new AnimatePacket(e, AnimatePacket.HURT));
+        broadcastAndSend( shared_ptr<SetEntityMotionPacket>( new SetEntityMotionPacket(e) ) );
+        e->hurtMarked = false;
+    }
+
+}
+
+void TrackedEntity::broadcast(shared_ptr<Packet> packet)
+{
+	if( Packet::canSendToAnyClient( packet ) )
+	{
+		// 4J-PB - due to the knockback on a player being hit, we need to send to all players, but limit the network traffic here to players that have not already had it sent to their system
+		vector< shared_ptr<ServerPlayer> > sentTo;
+
+		// 4J - don't send to a player we've already sent this data to that shares the same machine. 
+		// EntityMotionPacket used to limit themselves to sending once to each machine
+		// by only sending to the primary player on each machine. This was causing trouble for split screen
+		// as only the primary player would get a knockback velocity. Now these packets can be sent to any
+		// player, but we try to restrict the network impact this has by not resending to the one machine
+
+		for( AUTO_VAR(it, seenBy.begin()); it != seenBy.end(); it++ )
+		{
+			shared_ptr<ServerPlayer> player = *it;
+			bool dontSend = false;
+			if( sentTo.size() )
+			{
+				INetworkPlayer *thisPlayer =player->connection->getNetworkPlayer();
+				if( thisPlayer == NULL )
+				{
+					dontSend = true;
+				}
+				else
+				{
+					for(unsigned int j = 0; j < sentTo.size(); j++ )	
+					{
+						shared_ptr<ServerPlayer> player2 = sentTo[j];
+						INetworkPlayer *otherPlayer = player2->connection->getNetworkPlayer();
+						if( otherPlayer != NULL && thisPlayer->IsSameSystem(otherPlayer) )
+						{
+							dontSend = true;
+		// #ifdef _DEBUG
+		// 					shared_ptr<SetEntityMotionPacket> emp= dynamic_pointer_cast<SetEntityMotionPacket> (packet);
+		// 					if(emp!=NULL)
+		// 					{
+		// 						app.DebugPrintf("Not sending this SetEntityMotionPacket to player - it's already been sent to a player on their console\n");
+		// 					}
+		// #endif
+						}
+					}
+				}
+			}
+			if( dontSend )
+			{
+				continue;
+			}
+
+
+			(*it)->connection->send(packet);
+			sentTo.push_back(player);
+		}
+	}
+	else
+	{
+		// This packet hasn't got canSendToAnyClient set, so just send to everyone here, and it
+
+		for( AUTO_VAR(it, seenBy.begin()); it != seenBy.end(); it++ )
+		{
+			(*it)->connection->send(packet);
+		}
+	}
+}
+
+void TrackedEntity::broadcastAndSend(shared_ptr<Packet> packet)
+{
+	vector< shared_ptr<ServerPlayer> > sentTo;
+    broadcast(packet);
+	shared_ptr<ServerPlayer> sp = dynamic_pointer_cast<ServerPlayer>(e);
+	if (sp != NULL && sp->connection)
+	{
+        sp->connection->send(packet);
+    }
+}
+
+void TrackedEntity::broadcastRemoved()
+{
+	for( AUTO_VAR(it, seenBy.begin()); it != seenBy.end(); it++ )
+	{
+		(*it)->entitiesToRemove.push_back(e->entityId);
+	}
+}
+
+void TrackedEntity::removePlayer(shared_ptr<ServerPlayer> sp)
+{
+	AUTO_VAR(it, seenBy.find( sp ));
+	if( it != seenBy.end() )
+	{
+		seenBy.erase( it );
+	}
+}
+
+// 4J-JEV: Added for code reuse.
+TrackedEntity::eVisibility TrackedEntity::isVisible(EntityTracker *tracker, shared_ptr<ServerPlayer> sp, bool forRider)
+{
+	// 4J Stu - We call update players when the entity has moved more than a certain amount at the start of it's tick
+	// Before this call we set xpu, ypu and zpu to the entities new position, but xp,yp and zp are the old position until later in the tick.
+	// Therefore we should use the new position for visibility checks
+    double xd = sp->x - xpu; //xp / 32;
+    double zd = sp->z - zpu; //zp / 32;
+
+	int playersRange = range;
+	if( playersRange > TRACKED_ENTITY_MINIMUM_VIEW_DISTANCE  )
+	{
+		playersRange -= sp->getPlayerViewDistanceModifier();
+	}
+
+	bool bVisible = xd >= -playersRange && xd <= playersRange && zd >= -playersRange && zd <= playersRange;
+	bool canBeSeenBy = canBySeenBy(sp);
+
+	// 4J - added. Try and find other players who are in the same dimension as this one and on the same machine, and extend our visibility
+	// so things are consider visible to this player if they are near the other one. This is because we only send entity tracking info to
+	// players who canReceiveAllPackets().
+	if(!bVisible)
+	{
+		MinecraftServer *server = MinecraftServer::getInstance();
+		INetworkPlayer *thisPlayer = sp->connection->getNetworkPlayer();
+		if( thisPlayer )
+		{
+			for( unsigned int i = 0; i < server->getPlayers()->players.size(); i++ )
+			{
+				// Consider extra players, but not if they are the entity we are tracking, or the player we've been passed as input, or in another dimension
+				shared_ptr<ServerPlayer> ep = server->getPlayers()->players[i];
+				if( ep == sp ) continue;
+				if( ep == e ) continue;
+				if( ep->dimension != sp->dimension ) continue;
+
+				INetworkPlayer * otherPlayer = ep->connection->getNetworkPlayer();
+				if( otherPlayer != NULL && thisPlayer->IsSameSystem(otherPlayer) )
+				{
+					// 4J Stu - We call update players when the entity has moved more than a certain amount at the start of it's tick
+					// Before this call we set xpu, ypu and zpu to the entities new position, but xp,yp and zp are the old position until later in the tick.
+					// Therefore we should use the new position for visibility checks
+					double xd = ep->x - xpu; //xp / 32;
+					double zd = ep->z - zpu; //zp / 32;
+					bVisible |= ( xd >= -playersRange && xd <= playersRange && zd >= -playersRange && zd <= playersRange );
+					canBeSeenBy |= canBySeenBy(ep);
+				}
+			}
+		}
+	}
+
+	// 4J Stu - We need to ensure that we send the mount before the rider, so check that the player has been added to the seenBy list
+	if(forRider)
+	{
+		canBeSeenBy = canBeSeenBy && (seenBy.find(sp) != seenBy.end());
+	}
+
+	// 4J-JEV: ADDED! An entities mount has to be visible before the entity visible,
+	// this is to ensure that the mount is already in the client's game when the rider is added.
+	if (canBeSeenBy && bVisible && e->riding != NULL)
+	{
+		return tracker->getTracker(e->riding)->isVisible(tracker, sp, true);
+	}
+	else if (canBeSeenBy && bVisible)	return eVisibility_SeenAndVisible;
+	else if (bVisible)					return eVisibility_IsVisible;
+	else								return eVisibility_NotVisible;
+}
+
+void TrackedEntity::updatePlayer(EntityTracker *tracker, shared_ptr<ServerPlayer> sp)
+{
+    if (sp == e) return;
+
+	eVisibility visibility = this->isVisible(tracker, sp);
+	
+    if (	visibility == eVisibility_SeenAndVisible
+		&&	seenBy.find(sp) == seenBy.end()				)
+	{
+        seenBy.insert(sp);
+		shared_ptr<Packet> packet = getAddEntityPacket();
+        sp->connection->send(packet);
+
+		xap = e->xd;
+		yap = e->yd;
+		zap = e->zd;
+
+		shared_ptr<Player> plr = dynamic_pointer_cast<Player>(e);
+		if (plr != NULL)
+		{
+			app.DebugPrintf( "TrackedEntity:: Player '%ls' is now visible to player '%ls', %s.\n",
+				plr->name.c_str(), sp->name.c_str(),
+				(e->riding==NULL?"not riding minecart":"in minecart")
+				);
+		}
+
+		// 4J Stu brought forward to fix when Item Frames
+		if (!e->getEntityData()->isEmpty() && !(dynamic_pointer_cast<AddMobPacket>(packet)))
+		{
+			sp->connection->send(shared_ptr<SetEntityDataPacket>( new SetEntityDataPacket(e->entityId, e->getEntityData(), true)));
+		}
+
+        if (this->trackDelta)
+		{
+            sp->connection->send( shared_ptr<SetEntityMotionPacket>( new SetEntityMotionPacket(e->entityId, e->xd, e->yd, e->zd) ) );
+        }
+
+		if (e->riding != NULL)
+		{
+			sp->connection->send(shared_ptr<SetRidingPacket>(new SetRidingPacket(e, e->riding)));
+		}
+
+        ItemInstanceArray equipped = e->getEquipmentSlots();
+        if (equipped.data != NULL)
+		{
+            for (unsigned int i = 0; i < equipped.length; i++)
+			{
+                sp->connection->send( shared_ptr<SetEquippedItemPacket>( new SetEquippedItemPacket(e->entityId, i, equipped[i]) ) );
+            }
+        }
+
+        if (dynamic_pointer_cast<Player>(e) != NULL)
+		{
+            shared_ptr<Player> spe = dynamic_pointer_cast<Player>(e);
+            if (spe->isSleeping())
+			{
+                sp->connection->send( shared_ptr<EntityActionAtPositionPacket>( new EntityActionAtPositionPacket(e, EntityActionAtPositionPacket::START_SLEEP, Mth::floor(e->x), Mth::floor(e->y), Mth::floor(e->z)) ) );
+            }
+        }
+
+		if (dynamic_pointer_cast<Mob>(e) != NULL)
+		{
+			shared_ptr<Mob> mob = dynamic_pointer_cast<Mob>(e);
+			vector<MobEffectInstance *> *activeEffects = mob->getActiveEffects();
+			for(AUTO_VAR(it, activeEffects->begin()); it != activeEffects->end(); ++it)
+			{
+				MobEffectInstance *effect = *it;
+
+				sp->connection->send(shared_ptr<UpdateMobEffectPacket>( new UpdateMobEffectPacket(e->entityId, effect) ) );
+			}
+			delete activeEffects;
+		}
+    }
+	else if (visibility == eVisibility_NotVisible)
+	{
+		AUTO_VAR(it, seenBy.find(sp));
+        if (it != seenBy.end())
+		{
+            seenBy.erase(it);
+            sp->entitiesToRemove.push_back(e->entityId);
+        }
+    }
+
+}
+
+bool TrackedEntity::canBySeenBy(shared_ptr<ServerPlayer> player)
+{
+	// 4J - for some reason this isn't currently working, and is causing players to not appear until we are really close to them. Not sure
+	// what the conflict is between the java & our version, but removing for now as it is causing issues and we shouldn't *really* need it
+	// TODO - investigate further
+
+	return true;
+//	return player->getLevel()->getChunkMap()->isPlayerIn(player, e->xChunk, e->zChunk);
+}
+
+void TrackedEntity::updatePlayers(EntityTracker *tracker, vector<shared_ptr<Player> > *players)
+{
+    for (unsigned int i = 0; i < players->size(); i++)
+	{
+        updatePlayer(tracker, dynamic_pointer_cast<ServerPlayer>( players->at(i) ) );
+    }
+}
+
+shared_ptr<Packet> TrackedEntity::getAddEntityPacket()
+{
+	if (e->removed)
+	{
+		app.DebugPrintf("Fetching addPacket for removed entity - %ls\n", e->getAName().c_str());
+	}
+
+	// 4J-PB - replacing with a switch, rather than tons of ifs
+	if (dynamic_pointer_cast<Creature>(e) != NULL)
+	{
+		yHeadRotp = Mth::floor(e->getYHeadRot() * 256 / 360);
+		return shared_ptr<AddMobPacket>( new AddMobPacket(dynamic_pointer_cast<Mob>(e), yRotp, xRotp, xp, yp, zp, yHeadRotp) );
+	}
+
+	switch(e->GetType())
+	{
+	case eTYPE_ITEMENTITY:
+		{
+			shared_ptr<AddEntityPacket> packet = shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::ITEM, 1, yRotp, xRotp, xp, yp, zp) );
+			return packet;
+		}
+		break;
+	case eTYPE_SERVERPLAYER:
+		{
+			shared_ptr<ServerPlayer> player = dynamic_pointer_cast<ServerPlayer>(e);
+			PlayerUID xuid = INVALID_XUID;
+			PlayerUID OnlineXuid = INVALID_XUID;
+			if( player != NULL )
+			{
+				xuid = player->getXuid();
+				OnlineXuid = player->getOnlineXuid();
+			}
+			// 4J Added yHeadRotp param to fix #102563 - TU12: Content: Gameplay: When one of the Players is idle for a few minutes his head turns 180 degrees.
+			return shared_ptr<AddPlayerPacket>( new AddPlayerPacket(dynamic_pointer_cast<Player>(e), xuid, OnlineXuid, xp, yp, zp, yRotp, xRotp, yHeadRotp ) );
+		}
+		break;
+	case eTYPE_MINECART:
+		{
+			shared_ptr<Minecart> minecart = dynamic_pointer_cast<Minecart>(e);
+			if (minecart->type == Minecart::RIDEABLE) return shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::MINECART_RIDEABLE, yRotp, xRotp, xp, yp, zp) );
+			if (minecart->type == Minecart::CHEST) return shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::MINECART_CHEST, yRotp, xRotp, xp, yp, zp) );
+			if (minecart->type == Minecart::FURNACE) return shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::MINECART_FURNACE, yRotp, xRotp, xp, yp, zp) );
+		}
+		break;
+	case eTYPE_BOAT:
+		{
+			return shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::BOAT, yRotp, xRotp, xp, yp, zp) );
+		}
+		break;
+	case eTYPE_ENDERDRAGON:
+		{
+			yHeadRotp = Mth::floor(e->getYHeadRot() * 256 / 360);
+			return shared_ptr<AddMobPacket>( new AddMobPacket(dynamic_pointer_cast<Mob>(e), yRotp, xRotp, xp, yp, zp, yHeadRotp ) );
+		}
+		break;
+	case eTYPE_FISHINGHOOK:
+		{
+			shared_ptr<Entity> owner = dynamic_pointer_cast<FishingHook>(e)->owner;
+			return shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::FISH_HOOK, owner != NULL ? owner->entityId : e->entityId, yRotp, xRotp, xp, yp, zp) );
+		}
+		break;
+	case eTYPE_ARROW:
+		{
+			shared_ptr<Entity> owner = (dynamic_pointer_cast<Arrow>(e))->owner;
+			return shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::ARROW, owner != NULL ? owner->entityId : e->entityId, yRotp, xRotp, xp, yp, zp) );
+		}
+		break;
+	case eTYPE_SNOWBALL:
+		{
+			return shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::SNOWBALL, yRotp, xRotp, xp, yp, zp) );
+		}
+		break;
+	case eTYPE_THROWNPOTION:
+		{
+			return shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::THROWN_POTION, ((dynamic_pointer_cast<ThrownPotion>(e))->getPotionValue()), yRotp, xRotp, xp, yp, zp));
+		}
+		break;
+	case eTYPE_THROWNEXPBOTTLE:
+		{
+			return shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::THROWN_EXPBOTTLE, yRotp, xRotp, xp, yp, zp) );
+		}
+		break;
+	case eTYPE_THROWNENDERPEARL:
+		{
+			return shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::THROWN_ENDERPEARL, yRotp, xRotp, xp, yp, zp) );
+		}
+		break;
+	case eTYPE_EYEOFENDERSIGNAL:
+		{
+			return shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::EYEOFENDERSIGNAL, yRotp, xRotp, xp, yp, zp) );
+		}
+		break;
+	case eTYPE_SMALL_FIREBALL:
+		{
+			shared_ptr<SmallFireball> fb = dynamic_pointer_cast<SmallFireball>(e);
+			shared_ptr<AddEntityPacket> aep = nullptr;
+			if (fb->owner != NULL)
+			{
+				aep = shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::SMALL_FIREBALL, fb->owner->entityId, yRotp, xRotp, xp, yp, zp) );
+			}
+			else
+			{
+				aep = shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::SMALL_FIREBALL, 0, yRotp, xRotp, xp, yp, zp) );
+			}
+			aep->xa = (int) (fb->xPower * 8000);
+			aep->ya = (int) (fb->yPower * 8000);
+			aep->za = (int) (fb->zPower * 8000);
+			return aep;
+		}
+		break;
+	case eTYPE_DRAGON_FIREBALL:
+		{
+			shared_ptr<DragonFireball> fb = dynamic_pointer_cast<DragonFireball>(e);
+			shared_ptr<AddEntityPacket> aep = nullptr;
+			if (fb->owner != NULL)
+			{
+				aep = shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::DRAGON_FIRE_BALL, fb->owner->entityId, yRotp, xRotp, xp, yp, zp) );
+			}
+			else
+			{
+				aep = shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::DRAGON_FIRE_BALL, 0, yRotp, xRotp, xp, yp, zp) );
+			}
+			aep->xa = (int) (fb->xPower * 8000);
+			aep->ya = (int) (fb->yPower * 8000);
+			aep->za = (int) (fb->zPower * 8000);
+			return aep;
+		}
+		break;
+	case eTYPE_FIREBALL:
+		{
+			shared_ptr<Fireball> fb = dynamic_pointer_cast<Fireball>(e);
+			shared_ptr<AddEntityPacket> aep = nullptr;
+			if (fb->owner != NULL)
+			{
+				aep = shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::FIREBALL, fb->owner->entityId, yRotp, xRotp, xp, yp, zp) );
+			}
+			else
+			{
+				aep = shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::FIREBALL, 0, yRotp, xRotp, xp, yp, zp) );
+			}
+			aep->xa = (int) (fb->xPower * 8000);
+			aep->ya = (int) (fb->yPower * 8000);
+			aep->za = (int) (fb->zPower * 8000);
+			return aep;
+		}
+		break;
+	case eTYPE_THROWNEGG:
+		{
+			return shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::EGG, yRotp, xRotp, xp, yp, zp) );
+		}
+		break;
+	case eTYPE_PRIMEDTNT:
+		{
+			return shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::PRIMED_TNT, yRotp, xRotp, xp, yp, zp) );
+		}
+		break;
+	case eTYPE_ENDER_CRYSTAL:
+		{
+			return shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::ENDER_CRYSTAL, yRotp, xRotp, xp, yp, zp) );
+		}
+		break;
+	case eTYPE_FALLINGTILE:
+		{
+			shared_ptr<FallingTile> ft = dynamic_pointer_cast<FallingTile>(e);
+            return shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::FALLING, ft->tile | (ft->data << 16), yRotp, xRotp, xp, yp, zp) );
+		}
+		break;
+	case eTYPE_PAINTING:
+		{
+			return shared_ptr<AddPaintingPacket>( new AddPaintingPacket(dynamic_pointer_cast<Painting>(e)) );
+		}
+		break;
+	case eTYPE_ITEM_FRAME:
+		{
+			shared_ptr<ItemFrame> frame = dynamic_pointer_cast<ItemFrame>(e);
+			{
+
+				int ix= (int)frame->xTile;
+				int iy= (int)frame->yTile;
+				int iz= (int)frame->zTile;
+				app.DebugPrintf("eTYPE_ITEM_FRAME xyz %d,%d,%d\n",ix,iy,iz);
+			}
+
+			shared_ptr<AddEntityPacket> packet = shared_ptr<AddEntityPacket>(new AddEntityPacket(e, AddEntityPacket::ITEM_FRAME, frame->dir, yRotp, xRotp, xp, yp, zp));
+			packet->x = Mth::floor(frame->xTile * 32.0f);
+			packet->y = Mth::floor(frame->yTile * 32.0f);
+			packet->z = Mth::floor(frame->zTile * 32.0f);
+			return packet;
+		}
+		break;
+	case eTYPE_EXPERIENCEORB:
+		{
+			return shared_ptr<AddExperienceOrbPacket>( new AddExperienceOrbPacket(dynamic_pointer_cast<ExperienceOrb>(e)) );
+		}
+		break;
+	default:
+		assert(false);
+		break;	
+	}
+/*
+	if (e->GetType() == eTYPE_ITEMENTITY)
+	{
+		shared_ptr<ItemEntity> itemEntity = dynamic_pointer_cast<ItemEntity>(e);
+        shared_ptr<AddItemEntityPacket> packet = shared_ptr<AddItemEntityPacket>( new AddItemEntityPacket(itemEntity, xp, yp, zp) );
+        itemEntity->x = packet->x / 32.0;
+        itemEntity->y = packet->y / 32.0;
+        itemEntity->z = packet->z / 32.0;
+        return packet;
+    }
+
+    if (e->GetType() == eTYPE_SERVERPLAYER )
+	{
+		shared_ptr<ServerPlayer> player = dynamic_pointer_cast<ServerPlayer>(e);
+		XUID xuid = INVALID_XUID;
+		XUID OnlineXuid = INVALID_XUID;
+		if( player != NULL )
+		{
+			xuid = player->getXuid();
+			OnlineXuid = player->getOnlineXuid();
+		}
+		return shared_ptr<AddPlayerPacket>( new AddPlayerPacket(dynamic_pointer_cast<Player>(e), xuid, OnlineXuid, xp, yp, zp, yRotp, xRotp ) );
+    }
+    if (e->GetType() == eTYPE_MINECART)
+	{
+        shared_ptr<Minecart> minecart = dynamic_pointer_cast<Minecart>(e);
+        if (minecart->type == Minecart::RIDEABLE) return shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::MINECART_RIDEABLE, yRotp, xRotp, xp, yp, zp) );
+        if (minecart->type == Minecart::CHEST) return shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::MINECART_CHEST, yRotp, xRotp, xp, yp, zp) );
+        if (minecart->type == Minecart::FURNACE) return shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::MINECART_FURNACE, yRotp, xRotp, xp, yp, zp) );
+    }
+	if (e->GetType() == eTYPE_BOAT)
+	{
+        return shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::BOAT, yRotp, xRotp, xp, yp, zp) );
+    }
+    if (dynamic_pointer_cast<Creature>(e) != NULL)
+	{
+        return shared_ptr<AddMobPacket>( new AddMobPacket(dynamic_pointer_cast<Mob>(e), yRotp, xRotp, xp, yp, zp) );
+    }
+	if (e->GetType() == eTYPE_ENDERDRAGON)
+	{
+		return shared_ptr<AddMobPacket>( new AddMobPacket(dynamic_pointer_cast<Mob>(e), yRotp, xRotp, xp, yp, zp ) );
+	}
+	if (e->GetType() == eTYPE_FISHINGHOOK)
+	{
+		shared_ptr<Entity> owner = dynamic_pointer_cast<FishingHook>(e)->owner;
+		return shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::FISH_HOOK, owner != NULL ? owner->entityId : e->entityId, yRotp, xRotp, xp, yp, zp) );
+    }
+    if (e->GetType() == eTYPE_ARROW)
+	{
+        shared_ptr<Entity> owner = (dynamic_pointer_cast<Arrow>(e))->owner;
+        return shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::ARROW, owner != NULL ? owner->entityId : e->entityId, yRotp, xRotp, xp, yp, zp) );
+    }
+	if (e->GetType() == eTYPE_SNOWBALL)
+	{
+        return shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::SNOWBALL, yRotp, xRotp, xp, yp, zp) );
+    }
+	if (e->GetType() == eTYPE_THROWNPOTION)
+	{
+		return shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::THROWN_POTION, ((dynamic_pointer_cast<ThrownPotion>(e))->getPotionValue()), yRotp, xRotp, xp, yp, zp));
+	}
+	if (e->GetType() == eTYPE_THROWNEXPBOTTLE)
+	{
+		return shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::THROWN_EXPBOTTLE, yRotp, xRotp, xp, yp, zp) );
+	}
+	if (e->GetType() == eTYPE_THROWNENDERPEARL)
+	{
+		return shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::THROWN_ENDERPEARL, yRotp, xRotp, xp, yp, zp) );
+	}
+	if (e->GetType() == eTYPE_EYEOFENDERSIGNAL)
+	{
+		return shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::EYEOFENDERSIGNAL, yRotp, xRotp, xp, yp, zp) );
+	}
+	if (e->GetType() == eTYPE_SMALL_FIREBALL)
+	{
+		shared_ptr<SmallFireball> fb = dynamic_pointer_cast<SmallFireball>(e);
+		shared_ptr<AddEntityPacket> aep = NULL;
+		if (fb->owner != NULL)
+		{
+			aep = shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::SMALL_FIREBALL, fb->owner->entityId, yRotp, xRotp, xp, yp, zp) );
+		}
+		else
+		{
+			aep = shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::SMALL_FIREBALL, 0, yRotp, xRotp, xp, yp, zp) );
+		}
+		aep->xa = (int) (fb->xPower * 8000);
+		aep->ya = (int) (fb->yPower * 8000);
+		aep->za = (int) (fb->zPower * 8000);
+		return aep;
+	}
+	if (e->GetType() == eTYPE_FIREBALL)
+	{
+        shared_ptr<Fireball> fb = dynamic_pointer_cast<Fireball>(e);
+		shared_ptr<AddEntityPacket> aep = NULL;
+		if (fb->owner != NULL)
+		{
+			aep = shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::FIREBALL, fb->owner->entityId, yRotp, xRotp, xp, yp, zp) );
+		}
+		else
+		{
+			aep = shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::FIREBALL, 0, yRotp, xRotp, xp, yp, zp) );
+		}
+        aep->xa = (int) (fb->xPower * 8000);
+        aep->ya = (int) (fb->yPower * 8000);
+        aep->za = (int) (fb->zPower * 8000);
+        return aep;
+    }
+	if (e->GetType() == eTYPE_THROWNEGG)
+	{
+        return shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::EGG, yRotp, xRotp, xp, yp, zp) );
+    }
+	if (e->GetType() == eTYPE_PRIMEDTNT)
+	{
+        return shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::PRIMED_TNT, yRotp, xRotp, xp, yp, zp) );
+    }
+	if (e->GetType() == eTYPE_ENDER_CRYSTAL)
+	{
+		return shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::ENDER_CRYSTAL, yRotp, xRotp, xp, yp, zp) );
+	}
+	if (e->GetType() == eTYPE_FALLINGTILE)
+	{
+        shared_ptr<FallingTile> ft = dynamic_pointer_cast<FallingTile>(e);
+        if (ft->tile == Tile::sand_Id) return shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::FALLING_SAND, yRotp, xRotp, xp, yp, zp) );
+        if (ft->tile == Tile::gravel_Id) return shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::FALLING_GRAVEL, yRotp, xRotp, xp, yp, zp) );
+		if (ft->tile == Tile::dragonEgg_Id) return shared_ptr<AddEntityPacket>( new AddEntityPacket(e, AddEntityPacket::FALLING_EGG, yRotp, xRotp, xp, yp, zp) );
+    }
+	if (e->GetType() == eTYPE_PAINTING)
+	{
+        return shared_ptr<AddPaintingPacket>( new AddPaintingPacket(dynamic_pointer_cast<Painting>(e)) );
+    }
+	if (e->GetType() == eTYPE_ITEM_FRAME) 
+	{
+		shared_ptr<ItemFrame> frame = dynamic_pointer_cast<ItemFrame>(e);
+		{
+
+			int ix= (int)frame->xTile;
+			int iy= (int)frame->yTile;
+			int iz= (int)frame->zTile;
+		app.DebugPrintf("eTYPE_ITEM_FRAME xyz %d,%d,%d\n",ix,iy,iz);
+		}
+
+		shared_ptr<AddEntityPacket> packet = shared_ptr<AddEntityPacket>(new AddEntityPacket(e, AddEntityPacket::ITEM_FRAME, frame->dir, yRotp, xRotp, xp, yp, zp));
+		packet->x = Mth::floor(frame->xTile * 32.0f);
+		packet->y = Mth::floor(frame->yTile * 32.0f);
+		packet->z = Mth::floor(frame->zTile * 32.0f);
+		return packet;
+	}
+	if (e->GetType() == eTYPE_EXPERIENCEORB)
+	{
+        return shared_ptr<AddExperienceOrbPacket>( new AddExperienceOrbPacket(dynamic_pointer_cast<ExperienceOrb>(e)) );
+    }
+	assert(false);
+	*/
+	return nullptr;
+}
+
+void TrackedEntity::clear(shared_ptr<ServerPlayer> sp)
+{
+	AUTO_VAR(it, seenBy.find(sp));
+    if (it != seenBy.end())
+	{
+        seenBy.erase(it);
+        sp->entitiesToRemove.push_back(e->entityId);
+    }
+}