diff options
Diffstat (limited to '')
| -rw-r--r-- | source/cClientHandle.cpp | 1082 |
1 files changed, 1082 insertions, 0 deletions
diff --git a/source/cClientHandle.cpp b/source/cClientHandle.cpp new file mode 100644 index 000000000..f274795c1 --- /dev/null +++ b/source/cClientHandle.cpp @@ -0,0 +1,1082 @@ +#ifndef _WIN32
+#include <cstring>
+#include <semaphore.h>
+#include <errno.h>
+#endif
+
+#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 "cMCLogger.h"
+#include "cWindow.h"
+#include "cCraftingWindow.h"
+#include "cItem.h"
+#include "cTorch.h"
+#include "cStairs.h"
+#include "cLadder.h"
+#include "cSign.h"
+#include "cBlockToPickup.h"
+#include "cMonster.h"
+#include "cChatColor.h"
+#include "cThread.h"
+#include "cSocket.h"
+
+#include "cTracer.h"
+#include "Vector3f.h"
+#include "Vector3d.h"
+
+#include "cCriticalSection.h"
+#include "cSemaphore.h"
+#include "cEvent.h"
+#include "cSleep.h"
+#include "cRoot.h"
+
+#include "cBlockingTCPLink.h"
+#include "cAuthenticator.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_UseEntity.h"
+#include "packets/cPacket_WindowClose.h"
+#include "packets/cPacket_13.h"
+#include "packets/cPacket_UpdateSign.h"
+#include "packets/cPacket_Ping.h"
+
+
+#define MAX_SEMAPHORES (2000)
+
+typedef std::list<cPacket*> PacketList;
+
+struct cClientHandle::sClientHandleState
+{
+ sClientHandleState()
+ : ProtocolVersion( 0 )
+ , pReceiveThread( 0 )
+ , pSendThread( 0 )
+ , pAuthenticateThread( 0 )
+ , pSemaphore( 0 )
+ {
+ for( int i = 0; i < 256; ++i )
+ PacketMap[i] = 0;
+ }
+ int ProtocolVersion;
+ std::string Username;
+ std::string Password;
+
+ PacketList PendingParsePackets;
+ PacketList PendingNrmSendPackets;
+ PacketList PendingLowSendPackets;
+
+ cThread* pReceiveThread;
+ cThread* pSendThread;
+ cThread* pAuthenticateThread;
+
+ cSocket Socket;
+
+ cCriticalSection CriticalSection;
+ cCriticalSection SendCriticalSection;
+ cCriticalSection SocketCriticalSection;
+ cSemaphore* pSemaphore;
+
+ cPacket* PacketMap[256];
+};
+
+cClientHandle::cClientHandle(const cSocket & a_Socket)
+ : m_bDestroyed( false )
+ , m_Player( 0 )
+ , m_bKicking( false )
+ , m_TimeLastPacket( cWorld::GetTime() )
+ , m_bLoggedIn( false )
+ , m_bKeepThreadGoing( true )
+ , m_pState( new sClientHandleState )
+{
+ LOG("cClientHandle::cClientHandle");
+
+ m_pState->Socket = a_Socket;
+
+ m_pState->pSemaphore = new cSemaphore( MAX_SEMAPHORES, 0 );
+
+ // All the packets that can be received from the client
+ m_pState->PacketMap[E_KEEP_ALIVE] = new cPacket_KeepAlive;
+ m_pState->PacketMap[E_HANDSHAKE] = new cPacket_Handshake;
+ m_pState->PacketMap[E_LOGIN] = new cPacket_Login;
+ m_pState->PacketMap[E_PLAYERPOS] = new cPacket_PlayerPosition;
+ m_pState->PacketMap[E_PLAYERLOOK] = new cPacket_PlayerLook;
+ m_pState->PacketMap[E_PLAYERMOVELOOK] = new cPacket_PlayerMoveLook;
+ m_pState->PacketMap[E_CHAT] = new cPacket_Chat;
+ m_pState->PacketMap[E_ANIMATION] = new cPacket_ArmAnim;
+ m_pState->PacketMap[E_FLYING] = new cPacket_Flying;
+ m_pState->PacketMap[E_BLOCK_DIG] = new cPacket_BlockDig;
+ m_pState->PacketMap[E_BLOCK_PLACE] = new cPacket_BlockPlace;
+ m_pState->PacketMap[E_DISCONNECT] = new cPacket_Disconnect;
+ m_pState->PacketMap[E_ITEM_SWITCH] = new cPacket_ItemSwitch;
+ m_pState->PacketMap[E_ENTITY_EQUIPMENT] = new cPacket_EntityEquipment;
+ m_pState->PacketMap[E_PICKUP_SPAWN] = new cPacket_PickupSpawn;
+ m_pState->PacketMap[E_USE_ENTITY] = new cPacket_UseEntity;
+ m_pState->PacketMap[E_WINDOW_CLOSE] = new cPacket_WindowClose;
+ m_pState->PacketMap[E_WINDOW_CLICK] = new cPacket_WindowClick;
+ m_pState->PacketMap[E_PACKET_13] = new cPacket_13;
+ m_pState->PacketMap[E_UPDATE_SIGN] = new cPacket_UpdateSign;
+ m_pState->PacketMap[E_RESPAWN] = new cPacket_Respawn;
+ m_pState->PacketMap[E_PING] = new cPacket_Ping;
+
+ memset( m_LoadedChunks, 0x00, sizeof(cChunk*)*VIEWDISTANCE*VIEWDISTANCE );
+
+ //////////////////////////////////////////////////////////////////////////
+ m_pState->pReceiveThread = new cThread( ReceiveThread, this );
+ m_pState->pSendThread = new cThread( SendThread, this );
+ m_pState->pReceiveThread->Start( true );
+ m_pState->pSendThread->Start( true );
+ //////////////////////////////////////////////////////////////////////////
+
+ LOG("New ClientHandle" );
+}
+
+cClientHandle::~cClientHandle()
+{
+ LOG("Deleting client %s", GetUsername() );
+
+ for(unsigned int i = 0; i < VIEWDISTANCE*VIEWDISTANCE; i++)
+ {
+ if( m_LoadedChunks[i] ) m_LoadedChunks[i]->RemoveClient( this );
+ }
+
+ // First stop sending thread
+ m_bKeepThreadGoing = false;
+
+ m_pState->SocketCriticalSection.Lock();
+ if( m_pState->Socket )
+ {
+ cPacket_Disconnect Disconnect;
+ Disconnect.m_Reason = "Server shut down? Kthnxbai";
+ Disconnect.Send( m_pState->Socket );
+
+ closesocket( m_pState->Socket );
+ m_pState->Socket = 0;
+ }
+ m_pState->SocketCriticalSection.Unlock();
+
+ m_pState->pSemaphore->Signal();
+ delete m_pState->pAuthenticateThread;
+ delete m_pState->pReceiveThread;
+ delete m_pState->pSendThread;
+ delete m_pState->pSemaphore;
+
+ while( !m_pState->PendingParsePackets.empty() )
+ {
+ delete *m_pState->PendingParsePackets.begin();
+ m_pState->PendingParsePackets.erase( m_pState->PendingParsePackets.begin() );
+ }
+ while( !m_pState->PendingNrmSendPackets.empty() )
+ {
+ delete *m_pState->PendingNrmSendPackets.begin();
+ m_pState->PendingNrmSendPackets.erase( m_pState->PendingNrmSendPackets.begin() );
+ }
+ if(m_Player)
+ {
+ m_Player->SetClientHandle( 0 );
+ m_Player->Destroy();
+ m_Player = 0;
+ }
+ for(int i = 0; i < 256; i++)
+ {
+ if( m_pState->PacketMap[i] )
+ delete m_pState->PacketMap[i];
+ }
+
+ delete m_pState;
+}
+
+void cClientHandle::Destroy()
+{
+ m_bDestroyed = true;
+ m_pState->SocketCriticalSection.Lock();
+ if( m_pState->Socket )
+ {
+ closesocket( m_pState->Socket );
+ m_pState->Socket = 0;
+ }
+ m_pState->SocketCriticalSection.Unlock();
+}
+
+void cClientHandle::Kick( const char* a_Reason )
+{
+ Send( cPacket_Disconnect( a_Reason ) );
+ m_bKicking = true;
+}
+
+void cClientHandle::StreamChunks()
+{
+ if( !m_bLoggedIn )
+ return;
+ int ChunkPosX = (int)m_Player->GetPosX() / 16;
+ if( m_Player->GetPosX() < 0 ) ChunkPosX -= 1;
+ int ChunkPosZ = (int)m_Player->GetPosZ() / 16;
+ if( m_Player->GetPosZ() < 0 ) ChunkPosZ -= 1;
+
+ cChunk* NeededChunks[VIEWDISTANCE*VIEWDISTANCE];
+ for(int x = 0; x < VIEWDISTANCE; x++)
+ {
+ for(int z = 0; z < VIEWDISTANCE; z++)
+ {
+ NeededChunks[x + z*VIEWDISTANCE] = cRoot::Get()->GetWorld()->GetChunk( x + ChunkPosX-(VIEWDISTANCE-1)/2, 0, z + ChunkPosZ-(VIEWDISTANCE-1)/2 );
+ }
+ }
+
+ cChunk* MissingChunks[VIEWDISTANCE*VIEWDISTANCE];
+ memset( MissingChunks, 0, VIEWDISTANCE*VIEWDISTANCE*sizeof(cChunk*) );
+ unsigned int MissIndex = 0;
+ for(int i = 0; i < VIEWDISTANCE*VIEWDISTANCE; i++) // Handshake loop - touch each chunk once
+ {
+ 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
+ for(int x = 0; x < VIEWDISTANCE; x++)
+ {
+ for(int z = 0; z < VIEWDISTANCE; z++)
+ {
+ cChunk* Chunk = m_LoadedChunks[x + z*VIEWDISTANCE];
+ if( Chunk )
+ {
+ 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 );
+ }
+ }
+ }
+ }
+
+ StreamChunksSmart( MissingChunks, MissIndex );
+
+ memcpy( m_LoadedChunks, NeededChunks, VIEWDISTANCE*VIEWDISTANCE*sizeof(cChunk*) );
+ }
+}
+
+void cClientHandle::StreamChunksSmart( cChunk** a_Chunks, unsigned int a_NumChunks )
+{
+ int X = (int)m_Player->GetPosX() / 16;
+ int Y = (int)m_Player->GetPosY() / 128;
+ int Z = (int)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 );
+ a_Chunks[ClosestIdx] = 0;
+ }
+ }
+}
+
+void cClientHandle::AddPacket(cPacket * a_Packet)
+{
+ m_pState->CriticalSection.Lock();
+ m_pState->PendingParsePackets.push_back( a_Packet->Clone() );
+ m_pState->CriticalSection.Unlock();
+}
+
+void cClientHandle::RemovePacket( cPacket * a_Packet )
+{
+ delete a_Packet;
+ m_pState->PendingParsePackets.remove( a_Packet );
+}
+
+void cClientHandle::HandlePendingPackets()
+{
+ m_pState->CriticalSection.Lock();
+ while( m_pState->PendingParsePackets.begin() != m_pState->PendingParsePackets.end() )
+ {
+ HandlePacket( *m_pState->PendingParsePackets.begin() );
+ RemovePacket( *m_pState->PendingParsePackets.begin() );
+ }
+ m_pState->CriticalSection.Unlock();
+}
+
+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_PING: // Somebody tries to retreive information about the server
+ {
+ LOGINFO("Got ping");
+ char NumPlayers[8];
+ sprintf_s(NumPlayers, 8, "%i", cRoot::Get()->GetWorld()->GetNumPlayers() );
+ std::string response = std::string("Should be able to connect now!" + cChatColor::Delimiter + NumPlayers + cChatColor::Delimiter + "9001" );
+ Kick( response.c_str() );
+ }
+ break;
+ case E_HANDSHAKE:
+ {
+ cPacket_Handshake* PacketData = reinterpret_cast<cPacket_Handshake*>(a_Packet);
+ m_pState->Username = PacketData->m_Username;
+ LOG("HANDSHAKE %s", GetUsername() );
+ cPacket_Chat Connecting(m_pState->Username + " 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() );
+ cPacket_Login* PacketData = reinterpret_cast<cPacket_Login*>(a_Packet);
+ if( m_pState->Username.compare( PacketData->m_Username ) != 0 )
+ {
+ Kick("Login Username does not match Handshake username!");
+ return;
+ }
+ //m_Password = PacketData->m_Password;
+
+ if( cRoot::Get()->GetPluginManager()->CallHook( cPluginManager::E_PLUGIN_LOGIN, 1, PacketData ) )
+ {
+ Destroy();
+ return;
+ }
+
+ if( m_pState->pAuthenticateThread ) delete m_pState->pAuthenticateThread;
+ m_pState->pAuthenticateThread = new cThread( AuthenticateThread, this );
+ m_pState->pAuthenticateThread->Start( true );
+ }
+ break;
+ case E_PLAYERMOVELOOK: // After this is received we're safe to send anything
+ {
+ if( !m_Player )
+ {
+ Kick("Received wrong packet! Check your login sequence!");
+ 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( m_pState->Username + " joined the game!");
+ cRoot::Get()->GetServer()->Broadcast( Joined, this );
+ }
+
+ // Now initialize player (adds to entity list etc.)
+ m_Player->Initialize();
+
+ // Broadcasts to all but this ( this is actually handled in cChunk.cpp, after entity is added to the chunk )
+ //m_Player->SpawnOn( 0 );
+
+ // Send all already connected players to new player
+ //cRoot::Get()->GetServer()->SendAllEntitiesTo( this );
+
+ // Then we can start doing more stuffs! :D
+ m_bLoggedIn = true;
+ LOG("%s completely logged in", GetUsername() );
+ StreamChunks();
+ }
+ break;
+ case E_KEEP_ALIVE:
+ break;
+ default:
+ {
+ LOG("INVALID RESPONSE FOR LOGIN: needed 0x%02x got 0x%02x", E_PLAYERMOVELOOK, a_Packet->m_PacketID );
+ Kick("INVALID RESPONSE FOR LOGIN: needed 0x0d!");
+ }
+ break;
+ }
+ }
+ else // m_bLoggedIn == true
+ {
+ switch( a_Packet->m_PacketID )
+ {
+ 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:
+ {
+ 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 = cRoot::Get()->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];
+
+ cItem PickupItem;
+ if( bBroken ) // 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 = 1;
+ }
+ if(!cRoot::Get()->GetPluginManager()->CallHook( cPluginManager::E_PLUGIN_BLOCK_DIG, 2, PacketData, m_Player, &PickupItem ) )
+ {
+ if( bBroken ) // Block broken
+ {
+ if( cRoot::Get()->GetWorld()->DigBlock( PacketData->m_PosX, PacketData->m_PosY, PacketData->m_PosZ, PickupItem ) )
+ {
+ m_Player->GetInventory().GetEquippedItem().m_ItemHealth ++;
+ LOG("Health: %i", m_Player->GetInventory().GetEquippedItem().m_ItemHealth);
+ }
+ }
+ }
+ else
+ {
+ cRoot::Get()->GetWorld()->SendBlockTo( PacketData->m_PosX, PacketData->m_PosY, PacketData->m_PosZ, m_Player );
+ }
+ }
+ }
+ break;
+ case E_BLOCK_PLACE:
+ {
+ 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() );
+ 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 );
+ cRoot::Get()->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;
+ if( PacketData->m_Direction >= 0 )
+ {
+ ENUM_BLOCK_ID BlockID = (ENUM_BLOCK_ID)cRoot::Get()->GetWorld()->GetBlock( PacketData->m_PosX, PacketData->m_PosY, PacketData->m_PosZ );
+ switch( BlockID )
+ {
+ 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 = cRoot::Get()->GetWorld()->GetBlockEntity( PacketData->m_PosX, PacketData->m_PosY, PacketData->m_PosZ );
+ if( BlockEntity )
+ {
+ BlockEntity->UsedBy( *m_Player );
+ }
+ }
+ 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;
+
+ // Hacked in edible items go!~
+ bool bEat = false;
+ switch( Item.m_ItemID )
+ {
+ case E_ITEM_APPLE:
+ m_Player->Heal( 4 ); // 2 hearts
+ bEat = true;
+ break;
+ case E_ITEM_GOLDEN_APPLE:
+ m_Player->Heal( 20 ); // 10 hearts
+ bEat = true;
+ break;
+ case E_ITEM_MUSHROOM_SOUP:
+ m_Player->Heal( 10 ); // 5 hearts
+ bEat = true;
+ break;
+ case E_ITEM_BREAD:
+ m_Player->Heal( 5 ); // 2.5 hearts
+ bEat = true;
+ break;
+ case E_ITEM_RAW_MEAT:
+ m_Player->Heal( 3 ); // 1.5 hearts
+ bEat = true;
+ break;
+ case E_ITEM_COOKED_MEAT:
+ m_Player->Heal( 8 ); // 4 hearts
+ bEat = true;
+ break;
+ case E_ITEM_RAW_FISH:
+ m_Player->Heal( 2 ); // 1 heart
+ bEat = true;
+ break;
+ case E_ITEM_COOKED_FISH:
+ m_Player->Heal( 5 ); // 2.5 hearts
+ bEat = true;
+ break;
+ default:
+ break;
+ };
+
+ if( bEat )
+ {
+ m_Player->GetInventory().RemoveItem( Item );
+ break;
+ }
+
+ if( PacketData->m_Direction < 0 ) // clicked in air
+ break;
+
+ char MetaData = (char)Equipped.m_ItemHealth;
+ switch( PacketData->m_ItemType ) // Special handling for special items
+ {
+ case E_BLOCK_TORCH:
+ MetaData = cTorch::DirectionToMetaData( PacketData->m_Direction );
+ break;
+ case E_BLOCK_COBBLESTONE_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;
+ default:
+ break;
+ };
+
+ if( IsValidBlock( PacketData->m_ItemType) )
+ {
+ if( m_Player->GetInventory().RemoveItem( Item ) )
+ {
+ int X = PacketData->m_PosX;
+ char Y = PacketData->m_PosY;
+ int Z = PacketData->m_PosZ;
+ AddDirection( X, Y, Z, PacketData->m_Direction );
+
+ cRoot::Get()->GetWorld()->SetBlock( X, Y, Z, (char)PacketData->m_ItemType, MetaData );
+ }
+ }
+ }
+ /*
+ // 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_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();
+ }
+ }
+ break;
+ 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() + m_pState->Username + cChatColor::White + "> " );
+ cRoot::Get()->GetServer()->Broadcast( *PacketData );
+ }
+ }
+ break;
+ 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_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_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_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_WINDOW_CLOSE:
+ {
+ cPacket_WindowClose* PacketData = reinterpret_cast<cPacket_WindowClose*>(a_Packet);
+ if( PacketData->m_Close > 0 ) // Don't care about closing inventory
+ {
+ m_Player->CloseWindow();
+ }
+ }
+ break;
+ 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_UPDATE_SIGN:
+ {
+ cPacket_UpdateSign* PacketData = reinterpret_cast<cPacket_UpdateSign*>(a_Packet);
+ cWorld* World = cRoot::Get()->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_USE_ENTITY:
+ {
+ cPacket_UseEntity* PacketData = reinterpret_cast<cPacket_UseEntity*>(a_Packet);
+ if( PacketData->m_bLeftClick )
+ {
+ cWorld* World = cRoot::Get()->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_RESPAWN:
+ {
+ m_Player->Respawn();
+ }
+ break;
+ case E_DISCONNECT:
+ {
+ LOG("Received d/c packet from %s", GetUsername() );
+ 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( m_pState->Username + " disconnected: " + PacketData->m_Reason );
+ cRoot::Get()->GetServer()->Broadcast( DisconnectMessage );
+ }
+ Destroy();
+ return;
+ }
+ break;
+ default:
+ break;
+ }
+ }
+}
+
+void cClientHandle::AuthenticateThread( void* a_Param )
+{
+ cClientHandle* self = (cClientHandle*)a_Param;
+
+ cAuthenticator Authenticator;
+ if( !Authenticator.Authenticate( self->GetUsername(), cRoot::Get()->GetServer()->GetServerID() ) )
+ {
+ self->Kick("You could not be authenticated, sorry buddy!");
+ return;
+ }
+
+ self->SendLoginResponse();
+}
+
+void cClientHandle::SendLoginResponse()
+{
+ cWorld* World = cRoot::Get()->GetWorld();
+ World->LockEntities();
+ // Spawn player (only serversided, so data is loaded)
+ m_Player = new cPlayer( this, GetUsername() ); // !!DO NOT INITIALIZE!! <- is done after receiving MoveLook Packet
+
+ 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_MapSeed = 0;
+ LoginResponse.m_Dimension = 0;
+ Send( LoginResponse );
+
+ // Send position
+ Send( cPacket_PlayerMoveLook( m_Player ) );
+
+ // Send time
+ Send( cPacket_TimeUpdate( (cRoot::Get()->GetWorld()->GetWorldTime() ) ) );
+
+ // Send inventory
+ m_Player->GetInventory().SendWholeInventory( this );
+
+ // Send health
+ Send( cPacket_UpdateHealth( (short)m_Player->GetHealth() ) );
+ World->UnlockEntities();
+}
+
+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( m_pState->Socket );
+
+ cSleep::MilliSleep( 1000 ); // Give packet some time to be received
+
+ Destroy();
+ }
+}
+
+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;
+ m_pState->SendCriticalSection.Lock();
+ if( a_Priority == E_PRIORITY_NORMAL )
+ {
+ if( a_Packet.m_PacketID == E_REL_ENT_MOVE_LOOK )
+ {
+ PacketList & Packets = m_pState->PendingNrmSendPackets;
+ for( std::list<cPacket*>::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
+ break;
+ }
+ }
+ break;
+ default:
+ break;
+ }
+ if( bBreak )
+ break;
+ }
+ }
+ m_pState->PendingNrmSendPackets.push_back( a_Packet.Clone() );
+ }
+ else if( a_Priority == E_PRIORITY_LOW ) m_pState->PendingLowSendPackets.push_back( a_Packet.Clone() );
+ m_pState->SendCriticalSection.Unlock();
+ if( bSignalSemaphore )
+ m_pState->pSemaphore->Signal();
+}
+
+void cClientHandle::SendThread( void *lpParam )
+{
+ cClientHandle* self = (cClientHandle*)lpParam;
+ sClientHandleState* m_pState = self->m_pState;
+ PacketList & NrmSendPackets = m_pState->PendingNrmSendPackets;
+ PacketList & LowSendPackets = m_pState->PendingLowSendPackets;
+
+
+ while( self->m_bKeepThreadGoing && m_pState->Socket )
+ {
+ m_pState->pSemaphore->Wait();
+ m_pState->SendCriticalSection.Lock();
+ //LOG("Pending packets: %i", m_PendingPackets.size() );
+ if( NrmSendPackets.size() + LowSendPackets.size() > MAX_SEMAPHORES )
+ {
+ LOGERROR("ERROR: Too many packets in queue for player %s !!", self->GetUsername() );
+ cPacket_Disconnect DC("Too many packets in queue.");
+ DC.Send( m_pState->Socket );
+
+ cSleep::MilliSleep( 1000 ); // Give packet some time to be received
+
+ self->Destroy();
+ m_pState->SendCriticalSection.Unlock();
+ break;
+ }
+ if( NrmSendPackets.size() == 0 && LowSendPackets.size() == 0 )
+ {
+ if( self->m_bKeepThreadGoing ) LOGERROR("ERROR: Semaphore was signaled while PendingSendPackets.size == 0");
+ m_pState->SendCriticalSection.Unlock();
+ continue;
+ }
+ if( NrmSendPackets.size() > MAX_SEMAPHORES/2 )
+ {
+ LOGINFO("Pending packets: %i Last: 0x%02x", NrmSendPackets.size(), (*NrmSendPackets.rbegin())->m_PacketID );
+ }
+
+ cPacket* Packet = 0;
+ if( NrmSendPackets.size() > 0 )
+ {
+ Packet = *NrmSendPackets.begin();
+ NrmSendPackets.erase( NrmSendPackets.begin() );
+ }
+ else if( LowSendPackets.size() > 0 )
+ {
+ Packet = *LowSendPackets.begin();
+ LowSendPackets.erase( LowSendPackets.begin() );
+ }
+ m_pState->SendCriticalSection.Unlock();
+
+ m_pState->SocketCriticalSection.Lock();
+ if( !m_pState->Socket )
+ {
+ m_pState->SocketCriticalSection.Unlock();
+ break;
+ }
+ bool bSuccess = Packet->Send( m_pState->Socket );
+ m_pState->SocketCriticalSection.Unlock();
+ if( !bSuccess )
+ {
+ LOGERROR("ERROR: While sending packet 0x%02x", Packet->m_PacketID );
+ 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;
+}
+
+
+extern std::string GetWSAError();
+
+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 = recv(socket, &temp, 1, 0);
+ if( cSocket::IsSocketError(iStat) || iStat == 0 )
+ {
+ LOG("CLIENT DISCONNECTED (%i bytes):%s", iStat, GetWSAError().c_str() );
+ break;
+ }
+ else
+ {
+ cPacket* pPacket = self->m_pState->PacketMap[ (unsigned char)temp ];
+ if( pPacket )
+ {
+ if( pPacket->Parse( socket ) )
+ {
+ self->AddPacket( pPacket );
+ //self->HandlePendingPackets();
+ }
+ else
+ {
+#ifndef _WIN32
+ LOGERROR("Something went wrong during PacketID 0x%02x (%i)", temp, errno );
+#else
+ LOGERROR("Something went wrong during PacketID 0x%02x (%s)", temp, GetWSAError().c_str() );
+#endif
+ LOG("CLIENT %s DISCONNECTED", self->GetUsername() );
+ break;
+ }
+ }
+ else
+ {
+ LOG("Unknown packet: 0x%2x %c %i", (unsigned char)temp, (unsigned char)temp, (unsigned char)temp );
+
+
+ char c_Str[128];
+#ifdef _WIN32
+ sprintf_s( c_Str, "[C->S] Unknown PacketID: 0x%2x", (unsigned char)temp );
+#else
+ sprintf( c_Str, "[C->S] Unknown PacketID: 0x%2x", (unsigned char)temp );
+#endif
+ cPacket_Disconnect DC(c_Str);
+ DC.Send( socket );
+
+ cSleep::MilliSleep( 1000 ); // Give packet some time to be received
+ break;
+ }
+ }
+ }
+
+ self->Destroy();
+
+ LOG("ReceiveThread STOPPED");
+ return;
+}
+
+
+const char* cClientHandle::GetUsername()
+{
+ return m_pState->Username.c_str();
+}
+
+const cSocket & cClientHandle::GetSocket()
+{
+ return m_pState->Socket;
+}
\ No newline at end of file |