#include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules

#include "cClientHandle.h"
#include "cServer.h"
#include "cWorld.h"
#include "cChunk.h"
#include "cPickup.h"
#include "cPluginManager.h"
#include "cPlayer.h"
#include "cInventory.h"
#include "cChestEntity.h"
#include "cSignEntity.h"
#include "cWindow.h"
#include "cCraftingWindow.h"
#include "cItem.h"
#include "cTorch.h"
#include "cStairs.h"
#include "cDoors.h"
#include "cLadder.h"
#include "cSign.h"
#include "cRedstone.h"
#include "cPiston.h"
#include "cBlockToPickup.h"
#include "cMonster.h"
#include "cChatColor.h"
#include "cThread.h"
#include "cSocket.h"
#include "cTimer.h"

#include "cTracer.h"
#include "Vector3f.h"
#include "Vector3d.h"

#include "cSleep.h"
#include "cRoot.h"

#include "cBlockingTCPLink.h"
#include "cAuthenticator.h"
#include "MersenneTwister.h"

#include "packets/cPacket_KeepAlive.h"
#include "packets/cPacket_PlayerPosition.h"
#include "packets/cPacket_Respawn.h"
#include "packets/cPacket_UpdateHealth.h"
#include "packets/cPacket_RelativeEntityMoveLook.h"
#include "packets/cPacket_Chat.h"
#include "packets/cPacket_Login.h"
#include "packets/cPacket_WindowClick.h"
#include "packets/cPacket_PlayerMoveLook.h"
#include "packets/cPacket_TimeUpdate.h"
#include "packets/cPacket_BlockDig.h"
#include "packets/cPacket_Handshake.h"
#include "packets/cPacket_PlayerLook.h"
#include "packets/cPacket_ArmAnim.h"
#include "packets/cPacket_BlockPlace.h"
#include "packets/cPacket_Flying.h"
#include "packets/cPacket_Disconnect.h"
#include "packets/cPacket_PickupSpawn.h"
#include "packets/cPacket_ItemSwitch.h"
#include "packets/cPacket_EntityEquipment.h"
#include "packets/cPacket_CreativeInventoryAction.h"
#include "packets/cPacket_NewInvalidState.h"
#include "packets/cPacket_UseEntity.h"
#include "packets/cPacket_WindowClose.h"
#include "packets/cPacket_13.h"
#include "packets/cPacket_UpdateSign.h"
#include "packets/cPacket_Ping.h"
#include "packets/cPacket_PlayerListItem.h"


#define AddPistonDir( x, y, z, dir, amount ) switch(dir) { case 0: (y)-=(amount); break; case 1: (y)+=(amount); break;\
													 case 2: (z)-=(amount); break; case 3: (z)+=(amount); break;\
													 case 4: (x)-=(amount); break; case 5: (x)+=(amount); break; }

#define MAX_SEMAPHORES (2000)





// fwd: cServer.cpp:
extern std::string GetWSAError();





///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// cClientHandle:

cClientHandle::cClientHandle(const cSocket & a_Socket)
	: mProtocolVersion( 23 )
	, pReceiveThread(NULL)
	, pSendThread(NULL)
	, mSocket(a_Socket)
	, mSemaphore(MAX_SEMAPHORES)
	, m_bDestroyed( false )
	, m_Player(NULL)
	, m_bKicking( false )
	, m_TimeLastPacket( cWorld::GetTime() )
	, m_bLoggedIn( false )
	, m_bKeepThreadGoing( true )
	, m_bSendLoginResponse( false )
	, m_Ping(1000)
	, m_bPositionConfirmed( false )
{
	LOG("cClientHandle::cClientHandle");
	
	cTimer t1;
	m_LastPingTime = t1.GetNowTime();

	// All the packets that can be received from the client
	for (int i = 0; i < ARRAYCOUNT(mPacketMap); ++i)
	{
		mPacketMap[i] = NULL;
	}
	mPacketMap[E_KEEP_ALIVE]                = new cPacket_KeepAlive;
	mPacketMap[E_HANDSHAKE]                 = new cPacket_Handshake;
	mPacketMap[E_LOGIN]                     = new cPacket_Login;
	mPacketMap[E_PLAYERPOS]                 = new cPacket_PlayerPosition;
	mPacketMap[E_PLAYERLOOK]                = new cPacket_PlayerLook;
	mPacketMap[E_PLAYERMOVELOOK]            = new cPacket_PlayerMoveLook;
	mPacketMap[E_CHAT]                      = new cPacket_Chat;
	mPacketMap[E_ANIMATION]                 = new cPacket_ArmAnim;
	mPacketMap[E_FLYING]                    = new cPacket_Flying;
	mPacketMap[E_BLOCK_DIG]                 = new cPacket_BlockDig;
	mPacketMap[E_BLOCK_PLACE]               = new cPacket_BlockPlace;
	mPacketMap[E_DISCONNECT]                = new cPacket_Disconnect;
	mPacketMap[E_ITEM_SWITCH]               = new cPacket_ItemSwitch;
	mPacketMap[E_ENTITY_EQUIPMENT]          = new cPacket_EntityEquipment;
	mPacketMap[E_CREATIVE_INVENTORY_ACTION] = new cPacket_CreativeInventoryAction;
	mPacketMap[E_NEW_INVALID_STATE]         = new cPacket_NewInvalidState;
	mPacketMap[E_PICKUP_SPAWN]              = new cPacket_PickupSpawn;
	mPacketMap[E_USE_ENTITY]                = new cPacket_UseEntity;
	mPacketMap[E_WINDOW_CLOSE]              = new cPacket_WindowClose;
	mPacketMap[E_WINDOW_CLICK]              = new cPacket_WindowClick;
	mPacketMap[E_PACKET_13]                 = new cPacket_13;
	mPacketMap[E_UPDATE_SIGN]               = new cPacket_UpdateSign;
	mPacketMap[E_RESPAWN]                   = new cPacket_Respawn;
	mPacketMap[E_PING]                      = new cPacket_Ping;

	memset(m_LoadedChunks, 0x00, sizeof(m_LoadedChunks));

	//////////////////////////////////////////////////////////////////////////
	pReceiveThread = new cThread( ReceiveThread, this, "cClientHandle::ReceiveThread" );
	pSendThread = new cThread( SendThread, this, "cClientHandle::SendThread" );
	pReceiveThread->Start( true );
	pSendThread->Start( true );
	//////////////////////////////////////////////////////////////////////////

	LOG("New ClientHandle" );
}





cClientHandle::~cClientHandle()
{
	LOG("Deleting client %s", GetUsername().c_str() );

	for(unsigned int i = 0; i < VIEWDISTANCE*VIEWDISTANCE; i++)
	{
		if( m_LoadedChunks[i] ) m_LoadedChunks[i]->RemoveClient( this );
	}

	cWorld::PlayerList PlayerList = cRoot::Get()->GetWorld()->GetAllPlayers();
	for( cWorld::PlayerList::iterator itr = PlayerList.begin(); itr != PlayerList.end(); ++itr )
	{
		if ((*itr) && (*itr)->GetClientHandle() && !GetUsername().empty())
		{
			std::string NameColor = ( m_Player ? m_Player->GetColor() : "" );
			cPacket_PlayerListItem PlayerList(NameColor + GetUsername(), false, (short)9999);
			(*itr)->GetClientHandle()->Send(PlayerList);
		}
	}
	
	if (mUsername.size() > 0)
	{
		cPacket_Chat Left(mUsername + " left the game!");
		cRoot::Get()->GetServer()->Broadcast( Left, this );
	}

	// First stop sending thread
	m_bKeepThreadGoing = false;

	cCSLock Lock(mSocketCriticalSection);
	if (mSocket.IsValid())
	{
		cPacket_Disconnect Disconnect;
		Disconnect.m_Reason = "Server shut down? Kthnxbai";
		Disconnect.Send(mSocket);

		mSocket.CloseSocket();
	}
	Lock.Unlock();

	mSemaphore.Signal();
	delete pReceiveThread;
	delete pSendThread;

	while (!mPendingParsePackets.empty())
	{
		delete *mPendingParsePackets.begin();
		mPendingParsePackets.erase(mPendingParsePackets.begin());
	}
	while (!mPendingNrmSendPackets.empty())
	{
		delete *mPendingNrmSendPackets.begin();
		mPendingNrmSendPackets.erase(mPendingNrmSendPackets.begin());
	}
	while (!mPendingLowSendPackets.empty())
	{
		delete *mPendingLowSendPackets.begin();
		mPendingLowSendPackets.erase(mPendingLowSendPackets.begin());
	}
	if (m_Player != NULL)
	{
		m_Player->SetClientHandle(NULL);
		m_Player->Destroy();
		m_Player = NULL;
	}
	for (int i = 0; i < ARRAYCOUNT(mPacketMap); i++)
	{
		delete mPacketMap[i];
	}
}





void cClientHandle::Destroy()
{
	 m_bDestroyed = true;
	 cCSLock Lock(mSocketCriticalSection);
	 if (mSocket.IsValid())
	 {
		 mSocket.CloseSocket();
	 }
}





void cClientHandle::Kick(const AString & a_Reason)
{
	Send(cPacket_Disconnect(a_Reason));
	m_bKicking = true;
}





void cClientHandle::Authenticate(void)
{
	m_bSendLoginResponse = true;
}





void cClientHandle::StreamChunks(void)
{
	if (!m_bLoggedIn)
	{
		return;
	}

	assert(m_Player != NULL);
	
	int ChunkPosX = (int)floor(m_Player->GetPosX() / 16);
	int ChunkPosZ = (int)floor(m_Player->GetPosZ() / 16);

	cWorld * World = m_Player->GetWorld();

	cChunk * NeededChunks[VIEWDISTANCE * VIEWDISTANCE] = { 0 };
	const int MaxDist = VIEWDISTANCE + GENERATEDISTANCE * 2;
	for (int x = 0; x < MaxDist; x++)
	{
		for (int z = 0; z < MaxDist; z++)
		{
			int RelX = x - (MaxDist - 1) / 2;
			int RelZ = z - (MaxDist - 1) / 2;
			cChunk * Chunk = World->GetChunk( ChunkPosX + RelX, 0, ChunkPosZ + RelZ );	// Touch all chunks in wide range, so they get generated
			if (
				(x >= GENERATEDISTANCE) && 
				(x < VIEWDISTANCE + GENERATEDISTANCE) && 
				(z >= GENERATEDISTANCE) && 
				(z < VIEWDISTANCE + GENERATEDISTANCE)
			) // but player only needs chunks in view distance
			{
				NeededChunks[(x - GENERATEDISTANCE) + (z - GENERATEDISTANCE) * VIEWDISTANCE] = Chunk;
			}
		}
	}

	cChunk * MissingChunks[VIEWDISTANCE * VIEWDISTANCE];
	memset(MissingChunks, 0, sizeof(MissingChunks));
	unsigned int MissIndex = 0;
	for(int i = 0; i < VIEWDISTANCE * VIEWDISTANCE; i++)	// Handshake loop - touch each chunk once
	{
		if( NeededChunks[i] == 0 ) continue;	// Chunk is not yet loaded, so ignore
												// This can cause MissIndex to be 0 and thus chunks will not be unloaded while they are actually out of range,
												// which might actually be a good thing, otherwise it would keep trying to unload chunks until the new chunks are fully loaded
		bool bChunkMissing = true;
		for(int j = 0; j < VIEWDISTANCE*VIEWDISTANCE; j++)
		{
			if( m_LoadedChunks[j] == NeededChunks[i] )
			{
				bChunkMissing = false;
				break;
			}
		}
		if(bChunkMissing)
		{
			MissingChunks[MissIndex] = NeededChunks[i];
			MissIndex++;
		}
	}

	if (MissIndex > 0)
	{
		// Chunks are gonna be streamed in, so chunks probably also need to be streamed out <- optimization
		for(int x = 0; x < VIEWDISTANCE; x++)
		{
			for(int z = 0; z < VIEWDISTANCE; z++)
			{
				cChunk* Chunk = m_LoadedChunks[x + z*VIEWDISTANCE];
				if (Chunk != NULL)
				{
					if ( (Chunk->GetPosX() < ChunkPosX - (VIEWDISTANCE - 1) / 2)
						|| (Chunk->GetPosX() > ChunkPosX + (VIEWDISTANCE - 1) / 2)
						|| (Chunk->GetPosZ() < ChunkPosZ - (VIEWDISTANCE - 1) / 2)
						|| (Chunk->GetPosZ() > ChunkPosZ + (VIEWDISTANCE - 1) / 2)
					)
					{
						Chunk->RemoveClient( this );
						Chunk->AsyncUnload( this );		// TODO - I think it's possible to unload the chunk immediately instead of next tick
														// I forgot why I made it happen next tick

						m_LoadedChunks[x + z * VIEWDISTANCE] = NULL;
					}
				}
			}
		}

		StreamChunksSmart( MissingChunks, MissIndex );

		memcpy(m_LoadedChunks, NeededChunks, sizeof(NeededChunks));
	}
}





// Sends chunks to the player from the player position outward
void cClientHandle::StreamChunksSmart( cChunk** a_Chunks, unsigned int a_NumChunks )
{
	int X = (int)floor(m_Player->GetPosX() / 16);
	int Y = (int)floor(m_Player->GetPosY() / 128);
	int Z = (int)floor(m_Player->GetPosZ() / 16);

	bool bAllDone = false;
	while( !bAllDone )
	{
		bAllDone = true;
		int ClosestIdx = -1;
		unsigned int ClosestSqrDist = (unsigned int)-1; // wraps around, becomes biggest number possible
		for(unsigned int i = 0; i < a_NumChunks; ++i)
		{
			if( a_Chunks[i] )
			{
				bAllDone = false;
				int DistX = a_Chunks[i]->GetPosX()-X;
				int DistY = a_Chunks[i]->GetPosY()-Y;
				int DistZ = a_Chunks[i]->GetPosZ()-Z;
				unsigned int SqrDist = (DistX*DistX)+(DistY*DistY)+(DistZ*DistZ);
				if( SqrDist < ClosestSqrDist )
				{
					ClosestSqrDist = SqrDist;
					ClosestIdx = i;
				}
			}
		}
		if(ClosestIdx > -1)
		{
			a_Chunks[ClosestIdx]->Send( this );
			a_Chunks[ClosestIdx]->AddClient( this );
			//LOGINFO("CCC: Sending chunk %i %i", a_Chunks[ClosestIdx]->GetPosX(), a_Chunks[ClosestIdx]->GetPosZ() );
			a_Chunks[ClosestIdx] = 0;
		}
	}
}





// This removes the client from all chunks. Used when switching worlds
void cClientHandle::RemoveFromAllChunks()
{
	for(int i = 0; i < VIEWDISTANCE*VIEWDISTANCE; i++)
	{
		if( m_LoadedChunks[i] )
		{
			m_LoadedChunks[i]->RemoveClient( this );
			m_LoadedChunks[i]->AsyncUnload( this );
			m_LoadedChunks[i] = 0;
		}
	}
}





void cClientHandle::AddPacket(cPacket * a_Packet)
{
	cCSLock Lock(mCriticalSection);
	mPendingParsePackets.push_back(a_Packet->Clone());
}





void cClientHandle::RemovePacket( cPacket * a_Packet )
{
	delete a_Packet;
	mPendingParsePackets.remove( a_Packet );
}





void cClientHandle::HandlePendingPackets()
{
	cCSLock Lock(mCriticalSection);
	while (!mPendingParsePackets.empty())
	{
		HandlePacket( *mPendingParsePackets.begin() );
		RemovePacket( *mPendingParsePackets.begin() );
	}
}





void cClientHandle::HandlePacket( cPacket* a_Packet )
{
	m_TimeLastPacket = cWorld::GetTime();

	// cPacket* CopiedPacket = a_Packet->Clone();
	// a_Packet = CopiedPacket;

	//LOG("Packet: 0x%02x", a_Packet->m_PacketID );

	if (m_bKicking)
	{
		return;
	}

	if (!m_bLoggedIn)
	{
		switch (a_Packet->m_PacketID)
		{
			case E_NEW_INVALID_STATE: // New/Invalid State packet received. I'm guessing the client only sends it when there's a problem with the bed?
			{
				LOGINFO("Got New Invalid State packet");
				break;
			}
		
			case E_PING: // Somebody tries to retrieve information about the server
			{
				LOGINFO("Got ping");
				AString Reply;
				Printf(Reply, "%s%s%i%s%i", 
					cRoot::Get()->GetWorld()->GetDescription().c_str(), 
					cChatColor::Delimiter.c_str(), 
					cRoot::Get()->GetWorld()->GetNumPlayers(),
					cChatColor::Delimiter.c_str(), 
					cRoot::Get()->GetWorld()->GetMaxPlayers()
				);
				Kick(Reply.c_str());
				break;
			}
			
			case E_HANDSHAKE:
			{
				cPacket_Handshake * PacketData = reinterpret_cast<cPacket_Handshake*>(a_Packet);
				mUsername = PacketData->m_Username;
				LOG("HANDSHAKE %s", GetUsername().c_str());

				if (cRoot::Get()->GetWorld()->GetNumPlayers() >= cRoot::Get()->GetWorld()->GetMaxPlayers())
				{
					Kick("The server is currently full :( -- Try again later");
					break;
				}
				cPacket_Chat Connecting(mUsername + " is connecting.");
				cRoot::Get()->GetServer()->Broadcast( Connecting, this );

				// Give a server handshake thingy back
				cPacket_Handshake Handshake;
				Handshake.m_Username = cRoot::Get()->GetServer()->GetServerID();//ServerID;//"2e66f1dc032ab5f0";
				Send( Handshake );
				break;
			}
			
			case E_LOGIN:
			{
				LOG("LOGIN %s", GetUsername().c_str());
				cPacket_Login * PacketData = reinterpret_cast<cPacket_Login*>(a_Packet);
				if (PacketData->m_ProtocolVersion < mProtocolVersion)
				{
					Kick("Your client is outdated!");
					return;
				}
				else if( PacketData->m_ProtocolVersion > mProtocolVersion )
				{
					Kick("Your client version is higher than the server!");
					return;
				}
				if (mUsername.compare(PacketData->m_Username) != 0)
				{
					LOGWARNING("Login Username does not match Handshake username (\"%s\" / \"%s\" for client \"%s\")",
						mUsername.c_str(),
						PacketData->m_Username.c_str(),
						mSocket.GetIPString().c_str()
					);
					Kick("Hacked client");  // Don't tell them why we don't want them
					return;
				}

				if (cRoot::Get()->GetPluginManager()->CallHook( cPluginManager::E_PLUGIN_LOGIN, 1, PacketData))
				{
					Destroy();
					return;
				}

				// Schedule for authentication; until then, let them wait (but do not block)
				cRoot::Get()->GetAuthenticator().Authenticate(mUsername, cRoot::Get()->GetServer()->GetServerID());
				break;
			}
			
			case E_PLAYERMOVELOOK:	// After this is received we're safe to send anything
			{
				if (m_Player == NULL)
				{
					LOGWARNING("Received PlayerMoveLook packet for NULL player from client \"%s\", kicking.", mSocket.GetIPString().c_str());
					Kick("Hacked client");  // Don't tell them why we don't want them
					return;
				}
				if ( !cRoot::Get()->GetPluginManager()->CallHook( cPluginManager::E_PLUGIN_PLAYER_JOIN, 1, m_Player))
				{
					// Broadcast that this player has joined the game! Yay~
					cPacket_Chat Joined(mUsername + " joined the game!");
					cRoot::Get()->GetServer()->Broadcast( Joined, this );
				}

				// Now initialize player (adds to entity list etc.)
				cWorld* PlayerWorld = cRoot::Get()->GetWorld( m_Player->GetLoadedWorldName() );
				if( !PlayerWorld ) PlayerWorld = cRoot::Get()->GetDefaultWorld();
				m_Player->Initialize( PlayerWorld );

				// Then we can start doing more stuffs! :D
				m_bLoggedIn = true;
				LOG("Player \"%s\" completely logged in", GetUsername().c_str());
				StreamChunks();

				// Send position
				mConfirmPosition = m_Player->GetPosition();
				Send( cPacket_PlayerMoveLook( m_Player ) );
				break;
			}
			
			case E_KEEP_ALIVE:
			{
				break;
			}
			
			default:
			{
				LOG("INVALID RESPONSE FOR LOGIN: needed 0x%02x, got 0x%02x from client \"%s\", username \"%s\"", 
					E_PLAYERMOVELOOK, 
					a_Packet->m_PacketID,
					mSocket.GetIPString().c_str(),
					mUsername.c_str()
				);
				Kick("Hacked client");  // Don't tell them why we don't like them
				break;
			}
		}  // switch (Packet type)
	}
	else if (!m_bPositionConfirmed)  // m_bLoggedIn is true
	{
		switch (a_Packet->m_PacketID)
		{
			case E_PLAYERMOVELOOK:
			{
				cPacket_PlayerMoveLook* PacketData = reinterpret_cast<cPacket_PlayerMoveLook*>(a_Packet);
				Vector3d ReceivedPosition = Vector3d(PacketData->m_PosX, PacketData->m_PosY, PacketData->m_PosZ);

				// Test the distance between points with a small/large enough value instead of comparing directly. Floating point inaccuracies might screw stuff up
				if ((ReceivedPosition - mConfirmPosition).SqrLength() < 1.0)
				{
					// Test
					if( ReceivedPosition.Equals(mConfirmPosition))
					{
						LOGINFO("Exact position confirmed by client!");
					}
					m_bPositionConfirmed = true;
				}
				break;
			}  // case E_PLAYERMOVELOOK
		}  // switch (Packet type)
	}  // if (! position confirmed)

	if (m_bPositionConfirmed)
	{
		switch (a_Packet->m_PacketID)
		{
			case E_CREATIVE_INVENTORY_ACTION: // This is for creative Inventory changes
			{
				if(m_Player->GetGameMode() == 1)	//Just to be sure
				{
					m_Player->GetInventory().Clicked(a_Packet);
				}
				break;
			}

			case E_PLAYERPOS:
			{
				cPacket_PlayerPosition* PacketData = reinterpret_cast<cPacket_PlayerPosition*>(a_Packet);
				//LOG("recv player pos: %0.2f %0.2f %0.2f", PacketData->m_PosX, PacketData->m_PosY, PacketData->m_PosZ );
				m_Player->MoveTo( Vector3d( PacketData->m_PosX, PacketData->m_PosY, PacketData->m_PosZ ) );
				m_Player->SetStance( PacketData->m_Stance );
				m_Player->SetTouchGround( PacketData->m_bFlying );
				break;
			}
			
			case E_BLOCK_DIG:
			{
				int LastActionCnt = m_Player->GetLastBlockActionCnt();
				if ( (cRoot::Get()->GetWorld()->GetTime() - m_Player->GetLastBlockActionTime()) < 0.1 ) { //only allow block interactions every 0.1 seconds
					m_Player->SetLastBlockActionTime(); //Player tried to interact with a block. Reset last block interation time.
					m_Player->SetLastBlockActionCnt(LastActionCnt+1);
					if (m_Player->GetLastBlockActionCnt() > MAXBLOCKCHANGEINTERACTIONS) { //kick if more than MAXBLOCKCHANGEINTERACTIONS per .1 seconds
						LOGWARN("Player %s tried to interact with a block too quickly! (could indicate bot) Was Kicked.", GetUsername().c_str());
						//TODO Too many false-positives :s for example on a minimal server lagg :s should be re checked
						Kick("You're a baaaaaad boy!");
						break;
					}
				}
				else
				{
					m_Player->SetLastBlockActionCnt(0); //reset count 
					m_Player->SetLastBlockActionTime(); //Player tried to interact with a block. Reset last block interation time.
				}

				cPacket_BlockDig* PacketData = reinterpret_cast<cPacket_BlockDig*>(a_Packet);
				LOG("OnBlockDig: %i %i %i Dir: %i Stat: %i", PacketData->m_PosX, PacketData->m_PosY, PacketData->m_PosZ, PacketData->m_Direction, PacketData->m_Status );
				if( PacketData->m_Status == 0x04 )	// Drop block
				{
					m_Player->TossItem( false );
				}
				else
				{
					cWorld* World = m_Player->GetWorld();

					char OldBlock = World->GetBlock(PacketData->m_PosX, PacketData->m_PosY, PacketData->m_PosZ);
					char MetaData = World->GetBlockMeta(PacketData->m_PosX, PacketData->m_PosY, PacketData->m_PosZ);

					bool bBroken = (PacketData->m_Status == 0x02) || g_BlockOneHitDig[(int)OldBlock] || ( (PacketData->m_Status == 0x00) && (m_Player->GetGameMode() == 1) );
					if (bBroken == false) bBroken = (m_Player->GetInventory().GetEquippedItem().m_ItemID == E_ITEM_SHEARS && OldBlock == E_BLOCK_LEAVES);

					if (OldBlock == E_BLOCK_WOODEN_DOOR && !bBroken)
					{
						cDoors::ChangeDoor(m_Player->GetWorld(), PacketData->m_PosX, PacketData->m_PosY, PacketData->m_PosZ);
					}

					cItem PickupItem;
					if (bBroken && !(m_Player->GetGameMode() == 1) ) // broken
					{
						ENUM_ITEM_ID PickupID = cBlockToPickup::ToPickup( (ENUM_BLOCK_ID)OldBlock, m_Player->GetInventory().GetEquippedItem().m_ItemID );
						PickupItem.m_ItemID = PickupID;
						PickupItem.m_ItemHealth = MetaData;
						PickupItem.m_ItemCount = cBlockToPickup::PickupCount(OldBlock);
						if( OldBlock == E_BLOCK_LAPIS_ORE )
						{
							PickupItem.m_ItemHealth = 4;
						}
						if(cDoors::IsDoor(OldBlock))
						{
							PickupItem.m_ItemHealth = 1;	//For a complete door this works :D
						}
					}
					if(!cRoot::Get()->GetPluginManager()->CallHook( cPluginManager::E_PLUGIN_BLOCK_DIG, 2, PacketData, m_Player, &PickupItem ) )
					{
						int pX = PacketData->m_PosX, pY = PacketData->m_PosY, pZ = PacketData->m_PosZ;

						AddDirection(pX, (char &) pY, pZ, PacketData->m_Direction);

						char PossibleBlock = World->GetBlock(pX, pY, pZ);

						if(PossibleBlock == E_BLOCK_FIRE)
						{
							PacketData->m_PosX = pX;
							PacketData->m_PosY = (char)pY;
							PacketData->m_PosZ = pZ;
							bBroken = true;
						}

						if( bBroken ) // Block broken
						{
							if( World->DigBlock( PacketData->m_PosX, PacketData->m_PosY, PacketData->m_PosZ, PickupItem ) )
							{
								if (OldBlock == E_BLOCK_REDSTONE_TORCH_ON) {
									cRedstone Redstone(World);
									Redstone.ChangeRedstone( PacketData->m_PosX, PacketData->m_PosY, PacketData->m_PosZ, false );
								}
								if (OldBlock == E_BLOCK_REDSTONE_TORCH_OFF) {
									cRedstone Redstone(World);
									Redstone.ChangeRedstone( PacketData->m_PosX, PacketData->m_PosY, PacketData->m_PosZ, false );
								}
								if (OldBlock == E_BLOCK_REDSTONE_WIRE) {
									cRedstone Redstone(World);
									Redstone.ChangeRedstone( PacketData->m_PosX, PacketData->m_PosY, PacketData->m_PosZ, false );
								}
								if (( OldBlock == E_BLOCK_PISTON) || (OldBlock == E_BLOCK_STICKY_PISTON) ) {
									int newX = PacketData->m_PosX;
									int newY = PacketData->m_PosY;
									int newZ = PacketData->m_PosZ;
									AddPistonDir( newX, newY, newZ, MetaData & ~(8), 1 )
									if (World->GetBlock(newX, newY, newZ) == E_BLOCK_PISTON_EXTENSION) {
										World->SetBlock( newX, newY, newZ, E_BLOCK_AIR, 0 );
									}
								}

								if(cDoors::IsDoor(OldBlock))	//Special actions for destroyed door (Destroy second part)
								{
									if(MetaData & 8)	//was Upper part of door
									{
										if(cDoors::IsDoor(World->GetBlock(PacketData->m_PosX, PacketData->m_PosY - 1, PacketData->m_PosZ)))
											World->SetBlock(PacketData->m_PosX, PacketData->m_PosY - 1, PacketData->m_PosZ, E_BLOCK_AIR, 0);
									}else{	//Was lower part
										if(cDoors::IsDoor(World->GetBlock(PacketData->m_PosX, PacketData->m_PosY + 1, PacketData->m_PosZ)))
											World->SetBlock(PacketData->m_PosX, PacketData->m_PosY + 1, PacketData->m_PosZ, E_BLOCK_AIR, 0);
									}
								}
								
								m_Player->UseEquippedItem();
							}
						}
					}
					else
					{
						World->SendBlockTo( PacketData->m_PosX, PacketData->m_PosY, PacketData->m_PosZ, m_Player );
					}
				}
				break;
			}  // case E_BLOCK_DIG
			
			case E_BLOCK_PLACE:
			{
				int LastActionCnt = m_Player->GetLastBlockActionCnt();
				if ( (cRoot::Get()->GetWorld()->GetTime() - m_Player->GetLastBlockActionTime()) < 0.1 ) { //only allow block interactions every 0.1 seconds
					m_Player->SetLastBlockActionTime(); //Player tried to interact with a block. Reset last block interation time.
					m_Player->SetLastBlockActionCnt(LastActionCnt+1);
					if (m_Player->GetLastBlockActionCnt() > MAXBLOCKCHANGEINTERACTIONS) { //kick if more than MAXBLOCKCHANGEINTERACTIONS per .1 seconds
						LOGWARN("Player %s tried to interact with a block too quickly! (could indicate bot) Was Kicked.", GetUsername().c_str());
						Kick("You're a baaaaaad boy!");
						break;
					}
				}
				else
				{
					m_Player->SetLastBlockActionCnt(0); //reset count 
					m_Player->SetLastBlockActionTime(); //Player tried to interact with a block. Reset last block interation time.
				}

				cPacket_BlockPlace* PacketData = reinterpret_cast<cPacket_BlockPlace*>(a_Packet);
				cItem & Equipped = m_Player->GetInventory().GetEquippedItem();

				if ((Equipped.m_ItemID != PacketData->m_ItemType))	// Not valid
				{
					LOGWARN("Player %s tried to place a block that was not selected! (could indicate bot)", GetUsername().c_str());
					break;
				}

				if (cRoot::Get()->GetPluginManager()->CallHook( cPluginManager::E_PLUGIN_BLOCK_PLACE, 2, PacketData, m_Player ) )
				{
					if (PacketData->m_Direction > -1)
					{
						AddDirection( PacketData->m_PosX, PacketData->m_PosY, PacketData->m_PosZ, PacketData->m_Direction );
						m_Player->GetWorld()->SendBlockTo( PacketData->m_PosX, PacketData->m_PosY, PacketData->m_PosZ, m_Player );
					}
					break;
				}

				//LOG("%i %i %i %i %i %i", PacketData->m_Count, PacketData->m_Direction, PacketData->m_ItemType, PacketData->m_PosX, PacketData->m_PosY, PacketData->m_PosZ );

				//printf("Place Dir:%i %i %i %i : %i\n", PacketData->m_Direction, PacketData->m_PosX, PacketData->m_PosY, PacketData->m_PosZ, PacketData->m_ItemType);
				// 'use' useable items instead of placing blocks
				bool bPlaceBlock = true;
				bool UpdateRedstone = false;
				bool AddedCurrent = false;

				if( PacketData->m_Direction >= 0 )
				{

					ENUM_BLOCK_ID BlockID = (ENUM_BLOCK_ID)m_Player->GetWorld()->GetBlock( PacketData->m_PosX, PacketData->m_PosY, PacketData->m_PosZ );
					switch( BlockID )
					{
					case E_BLOCK_REDSTONE_REPEATER_ON:
					case E_BLOCK_REDSTONE_REPEATER_OFF:
						{
							//no need to update redstone current with a repeater
							//todo: Find meta value of repeater and change it to one step more.
						}
						break;
					case E_BLOCK_WORKBENCH:
						{
							bPlaceBlock = false;
							cWindow* Window = new cCraftingWindow( 0, true );
							m_Player->OpenWindow( Window );
						}
						break;
					case E_BLOCK_FURNACE:
					case E_BLOCK_CHEST:
						{
							bPlaceBlock = false;
							cBlockEntity* BlockEntity = m_Player->GetWorld()->GetBlockEntity( PacketData->m_PosX, PacketData->m_PosY, PacketData->m_PosZ );
							if( BlockEntity )
							{
								BlockEntity->UsedBy( *m_Player );
							}
						}
						break;
					case E_BLOCK_WOODEN_DOOR:
						{
							bPlaceBlock = false;
							cDoors::ChangeDoor(m_Player->GetWorld(), PacketData->m_PosX, PacketData->m_PosY, PacketData->m_PosZ);
						}
						break;
					default:
						break;
					};
				}

				// Some checks to see if it's a placeable item :P
				if( bPlaceBlock )
				{
					cItem Item;
					Item.m_ItemID = Equipped.m_ItemID;
					Item.m_ItemCount = 1;
					LOG("PacketData->m_ItemType: %i", (int)PacketData->m_ItemType);
					// Hacked in edible items go!~
					// TODO: Handle hunger
					bool bEat = false;
					bool isDoor = false;
					switch( Item.m_ItemID )
					{
					case E_ITEM_APPLE:
						//m_Player->Heal( 4 ); // 2 hearts
						m_Player->Feed( 24 ); // 2 food bars
						bEat = true;
						break;
					case E_ITEM_GOLDEN_APPLE:
						//m_Player->Heal( 20 ); // 10 hearts
						m_Player->Feed(60); // 5 food
						bEat = true;
						break;
					case E_ITEM_MUSHROOM_SOUP:
						///m_Player->Heal( 10 ); // 5 hearts
						m_Player->Feed( 48 ); // 4 food
						bEat = true;
						break;
					case E_ITEM_BREAD:
						//m_Player->Heal( 5 ); // 2.5 hearts
						m_Player->Feed( 30 ); // 2.5 food
						bEat = true;
						break;
					case E_ITEM_RAW_MEAT:
						//m_Player->Heal( 3 ); // 1.5 hearts
						m_Player->Feed( 18 ); // 1.5 food
						bEat = true;
						break;
					case E_ITEM_COOKED_MEAT:
						//m_Player->Heal( 8 ); // 4 hearts
						m_Player->Feed( 48 ); // 4 food
						bEat = true;
						break;
					case E_ITEM_RAW_FISH:
						//m_Player->Heal( 2 ); // 1 heart
						m_Player->Feed( 12 ); // 1 food
						bEat = true;
						break;
					case E_ITEM_COOKED_FISH:
						//m_Player->Heal( 5 ); // 2.5 hearts
						m_Player->Feed( 30 ); // 2.5 food
						bEat = true;
						break;
					case E_ITEM_RAW_CHICKEN:
						//m_Player->Heal(3);
						m_Player->Feed( 12 ); // 1 food
						bEat = true;
						break;
					case E_ITEM_COOKED_CHICKEN:
						//m_Player->Heal( 8 );
						m_Player->Feed( 36 ); // 3 food
						bEat = true;
						break;
					case E_ITEM_RAW_BEEF:
						//m_Player->Heal(3);
						m_Player->Feed( 18 ); // 1.5 food
						bEat = true;
						break;
					case E_ITEM_STEAK:
						//m_Player->Heal( 8 );
						m_Player->Feed( 48 ); // 4 food
						bEat = true;
						break;
					default:
						break;
					};

					if( bEat )
					{
						m_Player->GetInventory().RemoveItem( Item );
						break;
					}

					if( PacketData->m_Direction < 0 ) // clicked in air
						break;

					//TODO: Wrong Blocks!
					int ClickedBlock = (int)m_Player->GetWorld()->GetBlock( PacketData->m_PosX, PacketData->m_PosY, PacketData->m_PosZ );
					char MetaData = (char)Equipped.m_ItemHealth;
					bool LavaBucket = false;
					bool WaterBucket = false;
					bool bRemoveItem = true;
					bool bIgnoreCollision = false;

					if(ClickedBlock == E_BLOCK_STEP)
					{
						if(MetaData == m_Player->GetWorld()->GetBlockMeta(PacketData->m_PosX, PacketData->m_PosY, PacketData->m_PosZ) && PacketData->m_Direction == 1)	//only make double slab if meta values are the same and if player clicked on top of the block (Dir = 1)
						{
							PacketData->m_ItemType = E_BLOCK_DOUBLE_STEP;
							PacketData->m_PosY--;
							bIgnoreCollision = true;
						}
					}

					switch( PacketData->m_ItemType )	// Special handling for special items
					{
					case E_ITEM_BUCKET:
						//TODO: Change this, it is just a small hack to get it working a little bit. seems like the Client sends the position from the first hitable block :s
						ClickedBlock = (int)m_Player->GetWorld()->GetBlock( PacketData->m_PosX, PacketData->m_PosY + 1, PacketData->m_PosZ );
						LOG("Bucket Clicked BlockID: %d", ClickedBlock);
						switch (ClickedBlock)
						{
							case E_BLOCK_WATER:
							case E_BLOCK_STATIONARY_WATER:
								WaterBucket = true;
								break;
							case E_BLOCK_LAVA:
							case E_BLOCK_STATIONARY_LAVA:
								LavaBucket = true;
								break;
						}
						break;
					case E_ITEM_LAVA_BUCKET:
						if((m_Player->GetGameMode() == 1) || (m_Player->GetInventory().RemoveItem( Item )))
						{
							PacketData->m_ItemType = E_BLOCK_LAVA;
							if(m_Player->GetGameMode() == 1)
								break;						//No new Bucket for creative players

							cItem NewItem;
							NewItem.m_ItemID = E_ITEM_BUCKET;
							NewItem.m_ItemCount = 1;
							m_Player->GetInventory().AddItem( NewItem );
							
						}
						break;
					case E_ITEM_WATER_BUCKET:
						if((m_Player->GetGameMode() == 1) || (m_Player->GetInventory().RemoveItem( Item )))
						{
							PacketData->m_ItemType = E_BLOCK_WATER;
							if(m_Player->GetGameMode() == 1)
								break;						//No new Bucket for creative players
							cItem NewItem;
							NewItem.m_ItemID = E_ITEM_BUCKET;
							NewItem.m_ItemCount = 1;
							m_Player->GetInventory().AddItem( NewItem );
							
						}
						break;
					case E_BLOCK_TORCH:
						MetaData = cTorch::DirectionToMetaData( PacketData->m_Direction );
						break;
					case E_BLOCK_REDSTONE_TORCH_OFF:
						{
						MetaData = cTorch::DirectionToMetaData( PacketData->m_Direction );
						if( g_BlockTransparent[ (int)m_Player->GetWorld()->GetBlock( PacketData->m_PosX, PacketData->m_PosY+2, PacketData->m_PosZ ) ] == true ) {//if block above is transparent
							//printf("transparent above me\n");
						} else {
							//printf("transparent not above me\n");
						}
						UpdateRedstone = true;
						AddedCurrent = false;
						break;
						}
					case E_BLOCK_REDSTONE_TORCH_ON:
						{
						MetaData = cTorch::DirectionToMetaData( PacketData->m_Direction );
						UpdateRedstone = true;
						AddedCurrent = true;
						break;
						}
					case E_ITEM_REDSTONE_DUST:
						MetaData = 0;
						PacketData->m_ItemType = E_BLOCK_REDSTONE_WIRE;
						UpdateRedstone = true;
						AddedCurrent = false;
						break;
					case E_ITEM_REDSTONE_REPEATER:
						MetaData = cRedstone::RepeaterRotationToMetaData( m_Player->GetRotation() );
						PacketData->m_ItemType = E_BLOCK_REDSTONE_REPEATER_OFF;
						UpdateRedstone = true;
						AddedCurrent = false;
						break;
					case E_BLOCK_PISTON:
					case E_BLOCK_STICKY_PISTON:
						MetaData = cPiston::RotationPitchToMetaData( m_Player->GetRotation(), m_Player->GetPitch() );
						UpdateRedstone = true;
						AddedCurrent = false;
						break;
					case E_ITEM_IRON_DOOR:
						{
							PacketData->m_ItemType = E_BLOCK_IRON_DOOR;
							MetaData = cDoors::RotationToMetaData( m_Player->GetRotation() );
							isDoor = true;
						}
						break;
					case E_ITEM_WOODEN_DOOR:
						{
							PacketData->m_ItemType = E_BLOCK_WOODEN_DOOR;
							MetaData = cDoors::RotationToMetaData( m_Player->GetRotation() );
							isDoor = true;
						}
						break;
					case E_BLOCK_CHEST:
					case E_BLOCK_FURNACE:
					case E_BLOCK_DISPENSER:
						MetaData = cPiston::RotationPitchToMetaData( m_Player->GetRotation(), 0 ); // Same orientation as pistons, just ignore pitch
						break;
					case E_BLOCK_COBBLESTONE_STAIRS:
					case E_BLOCK_BRICK_STAIRS:
					case E_BLOCK_STONE_BRICK_STAIRS:
					case E_BLOCK_NETHER_BRICK_STAIRS:
					case E_BLOCK_WOODEN_STAIRS:
						MetaData = cStairs::RotationToMetaData( m_Player->GetRotation() );
						break;
					case E_BLOCK_LADDER:
						MetaData = cLadder::DirectionToMetaData( PacketData->m_Direction );
						break;
					case E_ITEM_SIGN:
						LOG("Dir: %i", PacketData->m_Direction);
						if( PacketData->m_Direction == 1 )
						{
							LOG("Player Rotation: %f", m_Player->GetRotation() );
							MetaData = cSign::RotationToMetaData( m_Player->GetRotation() );
							LOG("Sign rotation %i", MetaData);
							PacketData->m_ItemType = E_BLOCK_SIGN_POST;
						}
						else
						{
							MetaData = cSign::DirectionToMetaData( PacketData->m_Direction );
							PacketData->m_ItemType = E_BLOCK_WALLSIGN;
						}
						break;
					case E_ITEM_FLINT_AND_STEEL:
						PacketData->m_ItemType = E_ITEM_FIRE;
						m_Player->UseEquippedItem();
						bRemoveItem = false;
						break;
					default:
						break;
					};


					if (LavaBucket) {

						if( (m_Player->GetGameMode() == 1) || (m_Player->GetInventory().RemoveItem( Item )) ) {
							cItem NewItem;
							NewItem.m_ItemID = E_ITEM_LAVA_BUCKET;
							NewItem.m_ItemCount = 1;
							m_Player->GetInventory().AddItem( NewItem );
							m_Player->GetWorld()->SetBlock( PacketData->m_PosX, PacketData->m_PosY + 1, PacketData->m_PosZ, E_BLOCK_AIR, 0 );
						}

					} else if (WaterBucket) {

						if( (m_Player->GetGameMode() == 1) || (m_Player->GetInventory().RemoveItem( Item )) ) {
							cItem NewItem;
							NewItem.m_ItemID = E_ITEM_WATER_BUCKET;
							NewItem.m_ItemCount = 1;
							m_Player->GetInventory().AddItem( NewItem );
							m_Player->GetWorld()->SetBlock( PacketData->m_PosX, PacketData->m_PosY + 1, PacketData->m_PosZ, E_BLOCK_AIR, 0 );
						}

					} else if( IsValidBlock( PacketData->m_ItemType) ) {
						int X = PacketData->m_PosX;
						char Y = PacketData->m_PosY;
						int Z = PacketData->m_PosZ;
						AddDirection( X, Y, Z, PacketData->m_Direction );

						int PlaceBlock = m_Player->GetWorld()->GetBlock( X, Y, Z );
						if (PlaceBlock != E_BLOCK_AIR
							&& PlaceBlock != E_BLOCK_WATER
							&& PlaceBlock != E_BLOCK_STATIONARY_WATER
							&& PlaceBlock != E_BLOCK_LAVA
							&& PlaceBlock != E_BLOCK_STATIONARY_LAVA
							&& !bIgnoreCollision ) { //tried to place a block *into* another?
							break;	//happens when you place a block aiming at side of block like torch or stem
						}

						// Check whether selected item is allowed to be placed on specific surface
						bool bIllegalSurface = false;
						ENUM_BLOCK_ID SurfaceBlock = (ENUM_BLOCK_ID)m_Player->GetWorld()->GetBlock( X, Y-1, Z );
						switch( PacketData->m_ItemType )
						{
						case E_BLOCK_YELLOW_FLOWER:	// Can ONLY be placed on dirt/grass
						case E_BLOCK_RED_ROSE:
						case E_BLOCK_SAPLING:
							switch( SurfaceBlock )
							{
							case E_BLOCK_DIRT:
							case E_BLOCK_GRASS:
								bIllegalSurface = false;
								break;
							default:
								bIllegalSurface = true;
								break;
							};
							break;
						case E_BLOCK_BROWN_MUSHROOM:	// Can be placed on pretty much anything, with exceptions
						case E_BLOCK_RED_MUSHROOM:
							switch( SurfaceBlock )
							{
							case E_BLOCK_GLASS:
							case E_BLOCK_YELLOW_FLOWER:
							case E_BLOCK_RED_ROSE:
							case E_BLOCK_BROWN_MUSHROOM:
							case E_BLOCK_RED_MUSHROOM:
							case E_BLOCK_CACTUS:
								bIllegalSurface = true;
								break;
							}
							break;
						case E_BLOCK_CACTUS:
							if( SurfaceBlock != E_BLOCK_SAND && SurfaceBlock != E_BLOCK_CACTUS )	// Cactus can only be placed on sand and itself
								bIllegalSurface = true;

							// Check surroundings. Cacti may ONLY be surrounded by air
							cWorld* World = m_Player->GetWorld();
							if(		World->GetBlock( X-1, Y, Z ) != E_BLOCK_AIR 
								||	World->GetBlock( X+1, Y, Z ) != E_BLOCK_AIR 
								||	World->GetBlock( X, Y, Z-1 ) != E_BLOCK_AIR 
								||	World->GetBlock( X, Y, Z+1 ) != E_BLOCK_AIR 
								)
							{
								bIllegalSurface = true;
							}
							break;
						};

						if( bIllegalSurface )
							break;

						if(bRemoveItem)
						{
							if((m_Player->GetGameMode() != 1) &&  !m_Player->GetInventory().RemoveItem( Item ))
								break;
						}


						if (isDoor)
						{
							if ( ( m_Player->GetWorld()->GetBlock( X, Y+1, Z ) == E_BLOCK_AIR ) || ( m_Player->GetWorld()->GetBlock( X, Y+1, Z ) == E_BLOCK_AIR ) )
							{
								m_Player->GetWorld()->SetBlock( X, Y+1, Z, (char)PacketData->m_ItemType, MetaData + 8 );
								m_Player->GetWorld()->SetBlock( X, Y, Z, (char)PacketData->m_ItemType, MetaData );
							}
						} else {
							m_Player->GetWorld()->SetBlock( X, Y, Z, (char)PacketData->m_ItemType, MetaData );
						}


						if (UpdateRedstone)
						{
							cRedstone Redstone(m_Player->GetWorld());
							Redstone.ChangeRedstone( PacketData->m_PosX, PacketData->m_PosY+1, PacketData->m_PosZ, AddedCurrent );
						}

					}
				}
				/*
				// Remove stuff with stick! :D
				if( m_Username.compare("FakeTruth") == 0 )
				{	// It's me! :D
					if( PacketData->m_ItemType == 280 )
					{
						cRoot::Get()->GetWorld()->SetBlock( PacketData->m_PosX, PacketData->m_PosY, PacketData->m_PosZ, 0, 0 );
					}
				}
				*/
				break;
			}  // case E_BLOCK_PLACE
			
			case E_PICKUP_SPAWN:
			{
				LOG("Received packet E_PICKUP_SPAWN");
				cPacket_PickupSpawn* PacketData = reinterpret_cast<cPacket_PickupSpawn*>(a_Packet);

				cItem DroppedItem;
				DroppedItem.m_ItemID = (ENUM_ITEM_ID)PacketData->m_Item;
				DroppedItem.m_ItemCount = PacketData->m_Count;
				DroppedItem.m_ItemHealth = 0x0; // TODO: Somehow figure out what item was dropped, and apply correct health
				if( m_Player->GetInventory().RemoveItem( DroppedItem ) )
				{
					cPickup* Pickup = new cPickup( PacketData );
					Pickup->Initialize( m_Player->GetWorld() );
				}
				break;
			}  // case E_PICKUP_SPAWN
			
			case E_CHAT:
			{
				cPacket_Chat* PacketData = reinterpret_cast<cPacket_Chat*>(a_Packet);
				if (!cRoot::Get()->GetServer()->Command( *this, PacketData->m_Message.c_str()))
				{
					PacketData->m_Message.insert( 0, "<" + m_Player->GetColor() + mUsername + cChatColor::White + "> " );
					cRoot::Get()->GetServer()->Broadcast( *PacketData );
				}
				break;
			}  // case E_CHAT
			
			case E_PLAYERLOOK:
			{
				cPacket_PlayerLook* PacketData = reinterpret_cast<cPacket_PlayerLook*>(a_Packet);
				m_Player->SetRotation( PacketData->m_Rotation );
				m_Player->SetPitch( PacketData->m_Pitch );
				m_Player->SetTouchGround( PacketData->m_bFlying );
				m_Player->WrapRotation();
				break;
			}  // case E_PLAYERLOOK
			
			case E_PLAYERMOVELOOK:
			{
				cPacket_PlayerMoveLook* PacketData = reinterpret_cast<cPacket_PlayerMoveLook*>(a_Packet);
				m_Player->MoveTo( Vector3d( PacketData->m_PosX, PacketData->m_PosY, PacketData->m_PosZ ) );
				m_Player->SetStance( PacketData->m_Stance );
				m_Player->SetTouchGround( PacketData->m_bFlying );
				m_Player->SetRotation( PacketData->m_Rotation );
				m_Player->SetPitch( PacketData->m_Pitch );
				m_Player->WrapRotation();
				break;
			}  // case E_PLAYERMOVELOOK
			
			case E_ANIMATION:
			{
				cPacket_ArmAnim* PacketData = reinterpret_cast<cPacket_ArmAnim*>(a_Packet);
				PacketData->m_EntityID = m_Player->GetUniqueID();
				cRoot::Get()->GetServer()->Broadcast( *PacketData, this );
				break;
			}  // case E_ANIMATION
			
			case E_ITEM_SWITCH:
			{
				cPacket_ItemSwitch* PacketData = reinterpret_cast<cPacket_ItemSwitch*>(a_Packet);

				m_Player->GetInventory().SetEquippedSlot( PacketData->m_SlotNum );

				cPacket_EntityEquipment Equipment;
				Equipment.m_ItemID = (short)m_Player->GetInventory().GetEquippedItem().m_ItemID;
				Equipment.m_Slot = 0;
				Equipment.m_UniqueID = m_Player->GetUniqueID();
				cRoot::Get()->GetServer()->Broadcast( Equipment, this );
				break;
			}  // case E_ITEM_SWITCH
			
			case E_WINDOW_CLOSE:
			{
				cPacket_WindowClose* PacketData = reinterpret_cast<cPacket_WindowClose*>(a_Packet);
				m_Player->CloseWindow(PacketData->m_Close);
				break;
			}  // case E_WINDOW_CLOSE
			
			case E_WINDOW_CLICK:
			{
				cPacket_WindowClick* PacketData = reinterpret_cast<cPacket_WindowClick*>(a_Packet);
				if( PacketData->m_WindowID == 0 )
				{
					m_Player->GetInventory().Clicked( PacketData );
				}
				else
				{
					cWindow* Window = m_Player->GetWindow();
					if( Window ) Window->Clicked( PacketData, *m_Player );
					else LOG("No 'other' window! WTF");
				}
				break;
			}  // case E_WINDOW_CLICK
			
			case E_UPDATE_SIGN:
			{
				cPacket_UpdateSign* PacketData = reinterpret_cast<cPacket_UpdateSign*>(a_Packet);
				cWorld* World = m_Player->GetWorld();
				cChunk* Chunk = World->GetChunkOfBlock( PacketData->m_PosX, PacketData->m_PosY, PacketData->m_PosZ );
				cBlockEntity* BlockEntity = Chunk->GetBlockEntity( PacketData->m_PosX, PacketData->m_PosY, PacketData->m_PosZ );
				if( BlockEntity && (BlockEntity->GetBlockType() == E_BLOCK_SIGN_POST || BlockEntity->GetBlockType() == E_BLOCK_WALLSIGN ) )
				{
					cSignEntity* Sign = reinterpret_cast< cSignEntity* >(BlockEntity);
					Sign->SetLines( PacketData->m_Line1, PacketData->m_Line2, PacketData->m_Line3, PacketData->m_Line4 );
					Sign->SendTo( 0 ); // Broadcast to all players in chunk
				}
				break;
			}  // case E_UPDATE_SIGN
			
			case E_USE_ENTITY:
			{
				cPacket_UseEntity* PacketData = reinterpret_cast<cPacket_UseEntity*>(a_Packet);
				if( PacketData->m_bLeftClick )
				{
					cWorld* World = m_Player->GetWorld();
					cEntity* Entity = World->GetEntity( PacketData->m_TargetID );
					if( Entity && Entity->IsA("cPawn") )
					{
						cPawn* Pawn = (cPawn*)Entity;
						Pawn->TakeDamage( 1, m_Player );
					}
				}
				break;
			}  // case E_USE_ENTITY
			
			case E_RESPAWN:
			{
				m_Player->Respawn();
				break;
			}  // case E_RESPAWN
			
			case E_DISCONNECT:
			{
				LOG("Received d/c packet from \"%s\"", GetUsername().c_str());
				cPacket_Disconnect* PacketData = reinterpret_cast<cPacket_Disconnect*>(a_Packet);
				if( !cRoot::Get()->GetPluginManager()->CallHook( cPluginManager::E_PLUGIN_DISCONNECT, 2, PacketData->m_Reason.c_str(), m_Player ) )
				{
					cPacket_Chat DisconnectMessage(mUsername + " disconnected: " + PacketData->m_Reason);
					cRoot::Get()->GetServer()->Broadcast( DisconnectMessage );
				}
				Destroy();
				return;
				break;
			}  // case E_DISCONNECT
			
			case E_KEEP_ALIVE:
			{
				cPacket_KeepAlive *PacketData = reinterpret_cast<cPacket_KeepAlive*>(a_Packet);
				if (PacketData->m_KeepAliveID == m_PingID)
				{
					cTimer t1;
					m_Ping = (short)((t1.GetNowTime() - m_PingStartTime) / 2);
				}
				break;
			}  // case E_KEEP_ALIVE
		}  // switch (Packet type)
	}  // if (normal game)
}





void cClientHandle::Tick(float a_Dt)
{
	(void)a_Dt;
	if (cWorld::GetTime() - m_TimeLastPacket > 30.f)  // 30 seconds time-out
	{
		cPacket_Disconnect DC("Nooooo!! You timed out! D: Come back!");
		DC.Send(mSocket);

		cSleep::MilliSleep(1000);  // Give packet some time to be received

		Destroy();
	}
	
	cTimer t1;
	// Send ping packet
	if (m_LastPingTime + cClientHandle::PING_TIME_MS <= t1.GetNowTime())
	{
		// TODO: why a random ping ID, can't we just use normal ascending numbers?
		MTRand r1;
		m_PingID = r1.randInt();
		cPacket_KeepAlive Ping(m_PingID);
		m_PingStartTime = t1.GetNowTime();
		Send(Ping);
		m_LastPingTime = m_PingStartTime;
	}

	if (m_bSendLoginResponse)
	{
		m_bSendLoginResponse = false;

		// Spawn player (only serversided, so data is loaded)
		m_Player = new cPlayer( this, GetUsername() );	// !!DO NOT INITIALIZE!! <- is done after receiving MoveLook Packet

		cWorld* World = cRoot::Get()->GetWorld( m_Player->GetLoadedWorldName() );
		if( !World ) World = cRoot::Get()->GetDefaultWorld();
		World->LockEntities();
		m_Player->LoginSetGameMode ( World->GetGameMode() ); //set player's gamemode to server's gamemode at login. TODO: set to last player's gamemode at logout

		m_Player->SetIP (mSocket.GetIPString());

		cRoot::Get()->GetPluginManager()->CallHook( cPluginManager::E_PLUGIN_PLAYER_SPAWN, 1, m_Player );

		// Return a server login packet
		cPacket_Login LoginResponse;
		LoginResponse.m_ProtocolVersion = m_Player->GetUniqueID();
		//LoginResponse.m_Username = "";
		LoginResponse.m_ServerMode = m_Player->GetGameMode(); //set gamemode from player.
		LoginResponse.m_MapSeed = cRoot::Get()->GetWorld()->GetWorldSeed();
		LoginResponse.m_Dimension = 0;
		LoginResponse.m_MaxPlayers = (unsigned char)cRoot::Get()->GetWorld()->GetMaxPlayers();
		LoginResponse.m_Difficulty = 2;
		Send( LoginResponse );

		// Send Weather if raining:
		if ( (World->GetWeather() == 1) || (World->GetWeather() == 2) ) {
			cPacket_NewInvalidState RainPacket;
			RainPacket.m_Reason = 1; //begin rain
			Send( RainPacket );
		}

		// Send time
		Send( cPacket_TimeUpdate( World->GetWorldTime() ) );

		// Send inventory
		m_Player->GetInventory().SendWholeInventory( this );

		// Send health
		cPacket_UpdateHealth Health;
		Health.m_Health = (short)m_Player->GetHealth();
		Health.m_Food = m_Player->GetFood();
		Health.m_Saturation = m_Player->GetFoodSaturation();
		Send(Health);

		World->UnlockEntities();
	}
}





void cClientHandle::Send( const cPacket & a_Packet, ENUM_PRIORITY a_Priority /* = E_PRIORITY_NORMAL */ )
{
	if( m_bKicking ) return; // Don't add more packets if player is getting kicked anyway

	bool bSignalSemaphore = true;
	cCSLock Lock(mSendCriticalSection);
	if (a_Priority == E_PRIORITY_NORMAL)
	{
		if (a_Packet.m_PacketID == E_REL_ENT_MOVE_LOOK)
		{
			PacketList & Packets = mPendingNrmSendPackets;
			for (PacketList::iterator itr = Packets.begin(); itr != Packets.end(); ++itr)
			{
				bool bBreak = false;
				switch ((*itr)->m_PacketID)
				{
					case E_REL_ENT_MOVE_LOOK:
					{
						const cPacket_RelativeEntityMoveLook* ThisPacketData = reinterpret_cast< const cPacket_RelativeEntityMoveLook* >(&a_Packet);
						cPacket_RelativeEntityMoveLook* PacketData = reinterpret_cast< cPacket_RelativeEntityMoveLook* >(*itr);
						if( ThisPacketData->m_UniqueID == PacketData->m_UniqueID )
						{
							//LOGINFO("Optimized by removing double packet");
							Packets.erase( itr );
							bBreak = true;
							bSignalSemaphore = false; // Because 1 packet is removed, semaphore count is the same
							delete PacketData;
							break;
						}
						break;
					}  // case E_REL_END_MOVE_LOOK
				}  // switch (*itr -> Packet type)
				if (bBreak)
				{
					break;
				}
			}  // for itr - Packets[]
		}  // if (E_REL_ENT_MOVE_LOOK
		mPendingNrmSendPackets.push_back(a_Packet.Clone());
	}
	else if( a_Priority == E_PRIORITY_LOW )
	{
		mPendingLowSendPackets.push_back( a_Packet.Clone() );
	}
	Lock.Unlock();
	if (bSignalSemaphore)
	{
		mSemaphore.Signal();
	}
}





void cClientHandle::SendThread( void *lpParam )
{
	cClientHandle* self = (cClientHandle*)lpParam;
	PacketList & NrmSendPackets = self->mPendingNrmSendPackets;
	PacketList & LowSendPackets = self->mPendingLowSendPackets;


	while (self->m_bKeepThreadGoing && self->mSocket.IsValid())
	{
		self->mSemaphore.Wait();
		cCSLock Lock(self->mSendCriticalSection);
		if (NrmSendPackets.size() + LowSendPackets.size() > MAX_SEMAPHORES)
		{
			LOGERROR("ERROR: Too many packets in queue for player %s !!", self->mUsername.c_str());
			cPacket_Disconnect DC("Too many packets in queue.");
			DC.Send(self->mSocket);

			cSleep::MilliSleep( 1000 ); // Give packet some time to be received

			Lock.Unlock();
			self->Destroy();
			break;
		}
		
		if (NrmSendPackets.size() == 0 && LowSendPackets.size() == 0)
		{
			assert(!self->m_bKeepThreadGoing);
			if (self->m_bKeepThreadGoing)
			{
				LOGERROR("ERROR: Semaphore was signaled while no packets to send");
			}
			continue;
		}
		if (NrmSendPackets.size() > MAX_SEMAPHORES / 2)
		{
			LOGINFO("Pending packets: %i Last: 0x%02x", NrmSendPackets.size(), (*NrmSendPackets.rbegin())->m_PacketID );
		}

		cPacket * Packet = NULL;
		if (!NrmSendPackets.empty())
		{
			Packet = *NrmSendPackets.begin();
			NrmSendPackets.erase( NrmSendPackets.begin() );
		}
		else if (!LowSendPackets.empty())
		{
			Packet = *LowSendPackets.begin();
			LowSendPackets.erase( LowSendPackets.begin() );
		}
		Lock.Unlock();

		cCSLock SocketLock(self->mSocketCriticalSection);
		if (!self->mSocket.IsValid())
		{
			break;
		}

		bool bSuccess = Packet->Send(self->mSocket);
		SocketLock.Unlock();
		
		if (!bSuccess)
		{
			LOGERROR("ERROR: While sending packet 0x%02x to client \"%s\"", Packet->m_PacketID, self->mUsername.c_str());
			delete Packet;
			self->Destroy();
			break;
		}
		delete Packet;

		if (self->m_bKicking && (NrmSendPackets.size() + LowSendPackets.size() == 0) ) // Disconnect player after all packets have been sent
		{
			cSleep::MilliSleep( 1000 ); // Give all packets some time to be received
			self->Destroy();
			break;
		}
	}

	return;
}





void cClientHandle::ReceiveThread( void *lpParam )
{
	LOG("ReceiveThread");

	cClientHandle* self = (cClientHandle*)lpParam;


	char temp = 0;
	int iStat = 0;

	cSocket socket = self->GetSocket();

	while( self->m_bKeepThreadGoing )
	{
		iStat = socket.Receive( &temp, 1, 0 );
		if( cSocket::IsSocketError(iStat) || iStat == 0 )
		{
			LOG("CLIENT DISCONNECTED (%i bytes):%s", iStat, GetWSAError().c_str() );
			break;
		}
		else
		{
			cPacket* pPacket = self->mPacketMap[(unsigned char)temp];
			if (pPacket)
			{
				if (pPacket->Parse(socket))
				{
					self->AddPacket(pPacket);
					//self->HandlePendingPackets();
				}
				else
				{
					LOGERROR("Something went wrong during PacketID 0x%02x (%s)", temp, cSocket::GetLastErrorString() );
					LOG("CLIENT %s DISCONNECTED", self->mUsername.c_str());
					break;
				}
			}
			else
			{
				LOG("Unknown packet: 0x%02x \'%c\' %i", (unsigned char)temp, (unsigned char)temp, (unsigned char)temp );

				AString Reason;
				Printf(Reason, "[C->S] Unknown PacketID: 0x%02x", (unsigned char)temp );
				cPacket_Disconnect DC(Reason);
				DC.Send( socket );

				cSleep::MilliSleep( 1000 ); // Give packet some time to be received
				break;
			}
		}
	}

	self->Destroy();

	LOG("ReceiveThread STOPPED");
	return;
}





const AString & cClientHandle::GetUsername(void) const
{
	return mUsername;
}





const cSocket & cClientHandle::GetSocket()
{
	return mSocket;
}