From e92b9e7ecbdf2918aab59d4eeb7bb5966430b264 Mon Sep 17 00:00:00 2001 From: "madmaxoft@gmail.com" Date: Fri, 24 Aug 2012 07:58:26 +0000 Subject: [PATCH] Monster classes don't use cPackets. Chat messages are sent / broadcast without cPackets. BlockEntities don't use cPackets. git-svn-id: http://mc-server.googlecode.com/svn/trunk@783 0a769ca7-a7f5-676a-18bf-c427514a06d6 --- source/Bindings.cpp | 219 ++++++++----------- source/Bindings.h | 2 +- source/ChunkSender.cpp | 19 +- source/ChunkSender.h | 22 +- source/cBlockEntity.h | 23 +- source/cChestEntity.cpp | 7 +- source/cChestEntity.h | 2 +- source/cChunk.cpp | 59 ++++- source/cChunk.h | 4 + source/cChunkMap.cpp | 50 +++++ source/cChunkMap.h | 8 + source/cClientHandle.cpp | 77 +++++++ source/cClientHandle.h | 6 + source/cEntity.cpp | 47 +--- source/cEntity.h | 9 +- source/cFurnaceEntity.cpp | 10 + source/cFurnaceEntity.h | 2 + source/cFurnaceWindow.cpp | 2 - source/cInventory.cpp | 11 +- source/cInventory.h | 3 +- source/cMonster.cpp | 15 +- source/cMonster.h | 17 +- source/cPickup.cpp | 81 ++----- source/cPickup.h | 21 +- source/cPiston.cpp | 1 - source/cPlayer.cpp | 52 ++--- source/cPlayer.h | 10 +- source/cServer.cpp | 46 ++-- source/cServer.h | 3 +- source/cSignEntity.cpp | 14 +- source/cSignEntity.h | 3 +- source/cWorld.cpp | 35 ++- source/cWorld.h | 7 + source/packets/cPacket_PickupSpawn.cpp | 26 +-- source/packets/cPacket_PickupSpawn.h | 35 +-- source/packets/cPacket_SpawnMob.cpp | 12 +- source/packets/cPacket_SpawnMob.h | 24 +- source/packets/cPacket_UpdateSign.h | 2 +- source/squirrelbindings/SquirrelBindings.cpp | 2 - 39 files changed, 562 insertions(+), 426 deletions(-) diff --git a/source/Bindings.cpp b/source/Bindings.cpp index 1505df071..a143eac8e 100644 --- a/source/Bindings.cpp +++ b/source/Bindings.cpp @@ -1,6 +1,6 @@ /* ** Lua binding: AllToLua -** Generated automatically by tolua++-1.0.92 on 08/23/12 22:41:28. +** Generated automatically by tolua++-1.0.92 on 08/24/12 09:56:22. */ #ifndef __cplusplus @@ -171,18 +171,17 @@ static void tolua_reg_types (lua_State* tolua_S) tolua_usertype(tolua_S,"cServer"); tolua_usertype(tolua_S,"cRoot"); tolua_usertype(tolua_S,"cLuaItems"); - tolua_usertype(tolua_S,"cCraftingGrid"); tolua_usertype(tolua_S,"cPlugin::CommandStruct"); tolua_usertype(tolua_S,"cPickup"); tolua_usertype(tolua_S,"cItems"); - tolua_usertype(tolua_S,"cLuaChunk"); + tolua_usertype(tolua_S,"cCraftingGrid"); tolua_usertype(tolua_S,"cClientHandle"); - tolua_usertype(tolua_S,"cGroup"); - tolua_usertype(tolua_S,"cFurnaceRecipe"); - tolua_usertype(tolua_S,"cTracer"); - tolua_usertype(tolua_S,"cChatColor"); tolua_usertype(tolua_S,"cMCLogger"); - tolua_usertype(tolua_S,"cPacket_PickupSpawn"); + tolua_usertype(tolua_S,"cFurnaceRecipe"); + tolua_usertype(tolua_S,"cGroup"); + tolua_usertype(tolua_S,"cChatColor"); + tolua_usertype(tolua_S,"cTracer"); + tolua_usertype(tolua_S,"cLuaChunk"); tolua_usertype(tolua_S,"Lua__cWebPlugin"); tolua_usertype(tolua_S,"Lua__cPawn"); tolua_usertype(tolua_S,"cCuboid"); @@ -4811,7 +4810,7 @@ static int tolua_AllToLua_cEntity_SpawnOn00(lua_State* tolua_S) tolua_Error tolua_err; if ( !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) || - !tolua_isusertype(tolua_S,2,"cClientHandle",0,&tolua_err) || + (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"cClientHandle",0,&tolua_err)) || !tolua_isnoobj(tolua_S,3,&tolua_err) ) goto tolua_lerror; @@ -4824,7 +4823,7 @@ static int tolua_AllToLua_cEntity_SpawnOn00(lua_State* tolua_S) if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SpawnOn'", NULL); #endif { - self->SpawnOn(a_Client); + self->SpawnOn(*a_Client); } } return 0; @@ -4891,6 +4890,14 @@ public: return ( void )0; }; }; + void SpawnOn( cClientHandle& a_Client) { + if (push_method("SpawnOn", tolua_AllToLua_cEntity_SpawnOn00)) { + tolua_pushusertype(lua_state, (void*)&a_Client, "cClientHandle"); + ToluaBase::dbcall(lua_state, 2, 0); + } else { + return ( void ) cEntity:: SpawnOn(a_Client); + }; + }; void cEntity__Initialize( cWorld* a_World) { return ( void )cEntity::Initialize(a_World); @@ -4903,6 +4910,9 @@ public: }; const char* cEntity__GetClass( void ) { return ( const char* )cEntity::GetClass(); + }; + void cEntity__SpawnOn( cClientHandle& a_Client) { + return ( void )cEntity::SpawnOn(a_Client); }; Lua__cEntity( const double& a_X, const double& a_Y, const double& a_Z): cEntity(a_X,a_Y,a_Z){}; }; @@ -5071,6 +5081,39 @@ static int tolua_AllToLua_Lua__cEntity_cEntity__GetClass00(lua_State* tolua_S) } #endif //#ifndef TOLUA_DISABLE +/* method: cEntity__SpawnOn of class Lua__cEntity */ +#ifndef TOLUA_DISABLE_tolua_AllToLua_Lua__cEntity_cEntity__SpawnOn00 +static int tolua_AllToLua_Lua__cEntity_cEntity__SpawnOn00(lua_State* tolua_S) +{ +#ifndef TOLUA_RELEASE + tolua_Error tolua_err; + if ( + !tolua_isusertype(tolua_S,1,"Lua__cEntity",0,&tolua_err) || + (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"cClientHandle",0,&tolua_err)) || + !tolua_isnoobj(tolua_S,3,&tolua_err) + ) + goto tolua_lerror; + else +#endif + { + Lua__cEntity* self = (Lua__cEntity*) tolua_tousertype(tolua_S,1,0); + cClientHandle* a_Client = ((cClientHandle*) tolua_tousertype(tolua_S,2,0)); +#ifndef TOLUA_RELEASE + if (!self) tolua_error(tolua_S,"invalid 'self' in function 'cEntity__SpawnOn'", NULL); +#endif + { + self->cEntity__SpawnOn(*a_Client); + } + } + return 0; +#ifndef TOLUA_RELEASE + tolua_lerror: + tolua_error(tolua_S,"#ferror in function 'cEntity__SpawnOn'.",&tolua_err); + return 0; +#endif +} +#endif //#ifndef TOLUA_DISABLE + /* method: new of class Lua__cEntity */ #ifndef TOLUA_DISABLE_tolua_AllToLua_Lua__cEntity_new00 static int tolua_AllToLua_Lua__cEntity_new00(lua_State* tolua_S) @@ -5543,6 +5586,14 @@ public: return ( void )0; }; }; + void SpawnOn( cClientHandle& a_Client) { + if (push_method("SpawnOn", tolua_AllToLua_cEntity_SpawnOn00)) { + tolua_pushusertype(lua_state, (void*)&a_Client, "cClientHandle"); + ToluaBase::dbcall(lua_state, 2, 0); + } else { + return ( void ) cPawn:: SpawnOn(a_Client); + }; + }; void cPawn__TeleportToEntity( cEntity* a_Entity) { return ( void )cPawn::TeleportToEntity(a_Entity); @@ -5568,6 +5619,9 @@ public: const char* cPawn__GetClass( void ) { return ( const char* )cPawn::GetClass(); }; + void cPawn__SpawnOn( cClientHandle& a_Client) { + return ( void )cPawn::SpawnOn(a_Client); + }; }; /* method: tolua__set_instance of class Lua__cPawn */ @@ -6026,14 +6080,14 @@ static int tolua_AllToLua_cPlayer_GetGameMode00(lua_State* tolua_S) #ifndef TOLUA_RELEASE tolua_Error tolua_err; if ( - !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) || + !tolua_isusertype(tolua_S,1,"const cPlayer",0,&tolua_err) || !tolua_isnoobj(tolua_S,2,&tolua_err) ) goto tolua_lerror; else #endif { - cPlayer* self = (cPlayer*) tolua_tousertype(tolua_S,1,0); + const cPlayer* self = (const cPlayer*) tolua_tousertype(tolua_S,1,0); #ifndef TOLUA_RELEASE if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetGameMode'", NULL); #endif @@ -6975,6 +7029,14 @@ public: return ( void )0; }; }; + void SpawnOn( cClientHandle& a_Client) { + if (push_method("SpawnOn", tolua_AllToLua_cEntity_SpawnOn00)) { + tolua_pushusertype(lua_state, (void*)&a_Client, "cClientHandle"); + ToluaBase::dbcall(lua_state, 2, 0); + } else { + return ( void ) cPlayer:: SpawnOn(a_Client); + }; + }; void cPlayer__Initialize( cWorld* a_World) { return ( void )cPlayer::Initialize(a_World); @@ -7003,6 +7065,9 @@ public: const char* cPlayer__GetClass( void ) { return ( const char* )cPlayer::GetClass(); }; + void cPlayer__SpawnOn( cClientHandle& a_Client) { + return ( void )cPlayer::SpawnOn(a_Client); + }; }; /* method: tolua__set_instance of class Lua__cPlayer */ @@ -10735,7 +10800,7 @@ static int tolua_AllToLua_cServer_SendMessage00(lua_State* tolua_S) tolua_Error tolua_err; if ( !tolua_isusertype(tolua_S,1,"cServer",0,&tolua_err) || - !tolua_isstring(tolua_S,2,0,&tolua_err) || + !tolua_iscppstring(tolua_S,2,0,&tolua_err) || !tolua_isusertype(tolua_S,3,"cPlayer",1,&tolua_err) || !tolua_isboolean(tolua_S,4,1,&tolua_err) || !tolua_isnoobj(tolua_S,5,&tolua_err) @@ -10745,17 +10810,18 @@ static int tolua_AllToLua_cServer_SendMessage00(lua_State* tolua_S) #endif { cServer* self = (cServer*) tolua_tousertype(tolua_S,1,0); - const char* a_Message = ((const char*) tolua_tostring(tolua_S,2,0)); - cPlayer* a_Player = ((cPlayer*) tolua_tousertype(tolua_S,3,0)); + const AString a_Message = ((const AString) tolua_tocppstring(tolua_S,2,0)); + cPlayer* a_Player = ((cPlayer*) tolua_tousertype(tolua_S,3,NULL)); bool a_bExclude = ((bool) tolua_toboolean(tolua_S,4,false)); #ifndef TOLUA_RELEASE if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SendMessage'", NULL); #endif { self->SendMessage(a_Message,a_Player,a_bExclude); + tolua_pushcppstring(tolua_S,(const char*)a_Message); } } - return 0; + return 1; #ifndef TOLUA_RELEASE tolua_lerror: tolua_error(tolua_S,"#ferror in function 'SendMessage'.",&tolua_err); @@ -13637,57 +13703,6 @@ static int tolua_AllToLua_cPickup_new00_local(lua_State* tolua_S) } #endif //#ifndef TOLUA_DISABLE -/* method: new of class cPickup */ -#ifndef TOLUA_DISABLE_tolua_AllToLua_cPickup_new01 -static int tolua_AllToLua_cPickup_new01(lua_State* tolua_S) -{ - tolua_Error tolua_err; - if ( - !tolua_isusertable(tolua_S,1,"cPickup",0,&tolua_err) || - !tolua_isusertype(tolua_S,2,"cPacket_PickupSpawn",0,&tolua_err) || - !tolua_isnoobj(tolua_S,3,&tolua_err) - ) - goto tolua_lerror; - else - { - cPacket_PickupSpawn* a_PickupSpawnPacket = ((cPacket_PickupSpawn*) tolua_tousertype(tolua_S,2,0)); - { - cPickup* tolua_ret = (cPickup*) Mtolua_new((cPickup)(a_PickupSpawnPacket)); - tolua_pushusertype(tolua_S,(void*)tolua_ret,"cPickup"); - } - } - return 1; -tolua_lerror: - return tolua_AllToLua_cPickup_new00(tolua_S); -} -#endif //#ifndef TOLUA_DISABLE - -/* method: new_local of class cPickup */ -#ifndef TOLUA_DISABLE_tolua_AllToLua_cPickup_new01_local -static int tolua_AllToLua_cPickup_new01_local(lua_State* tolua_S) -{ - tolua_Error tolua_err; - if ( - !tolua_isusertable(tolua_S,1,"cPickup",0,&tolua_err) || - !tolua_isusertype(tolua_S,2,"cPacket_PickupSpawn",0,&tolua_err) || - !tolua_isnoobj(tolua_S,3,&tolua_err) - ) - goto tolua_lerror; - else - { - cPacket_PickupSpawn* a_PickupSpawnPacket = ((cPacket_PickupSpawn*) tolua_tousertype(tolua_S,2,0)); - { - cPickup* tolua_ret = (cPickup*) Mtolua_new((cPickup)(a_PickupSpawnPacket)); - tolua_pushusertype(tolua_S,(void*)tolua_ret,"cPickup"); - tolua_register_gc(tolua_S,lua_gettop(tolua_S)); - } - } - return 1; -tolua_lerror: - return tolua_AllToLua_cPickup_new00_local(tolua_S); -} -#endif //#ifndef TOLUA_DISABLE - /* method: delete of class cPickup */ #ifndef TOLUA_DISABLE_tolua_AllToLua_cPickup_delete00 static int tolua_AllToLua_cPickup_delete00(lua_State* tolua_S) @@ -13849,6 +13864,14 @@ public: return ( void )0; }; }; + void SpawnOn( cClientHandle& a_Client) { + if (push_method("SpawnOn", tolua_AllToLua_cEntity_SpawnOn00)) { + tolua_pushusertype(lua_state, (void*)&a_Client, "cClientHandle"); + ToluaBase::dbcall(lua_state, 2, 0); + } else { + return ( void ) cPickup:: SpawnOn(a_Client); + }; + }; bool cPickup__CollectedBy( cPlayer* a_Dest) { return ( bool )cPickup::CollectedBy(a_Dest); @@ -13864,9 +13887,11 @@ public: }; const char* cPickup__GetClass( void ) { return ( const char* )cPickup::GetClass(); + }; + void cPickup__SpawnOn( cClientHandle& a_Client) { + return ( void )cPickup::SpawnOn(a_Client); }; Lua__cPickup( int a_X, int a_Y, int a_Z, const cItem& a_Item, float a_SpeedX = 0.f, float a_SpeedY = 0.f, float a_SpeedZ = 0.f): cPickup(a_X,a_Y,a_Z,a_Item,a_SpeedX,a_SpeedY,a_SpeedZ){}; - Lua__cPickup( cPacket_PickupSpawn* a_PickupSpawnPacket): cPickup(a_PickupSpawnPacket){}; }; /* method: tolua__set_instance of class Lua__cPickup */ @@ -14021,57 +14046,6 @@ static int tolua_AllToLua_Lua__cPickup_new00_local(lua_State* tolua_S) } #endif //#ifndef TOLUA_DISABLE -/* method: new of class Lua__cPickup */ -#ifndef TOLUA_DISABLE_tolua_AllToLua_Lua__cPickup_new01 -static int tolua_AllToLua_Lua__cPickup_new01(lua_State* tolua_S) -{ - tolua_Error tolua_err; - if ( - !tolua_isusertable(tolua_S,1,"Lua__cPickup",0,&tolua_err) || - !tolua_isusertype(tolua_S,2,"cPacket_PickupSpawn",0,&tolua_err) || - !tolua_isnoobj(tolua_S,3,&tolua_err) - ) - goto tolua_lerror; - else - { - cPacket_PickupSpawn* a_PickupSpawnPacket = ((cPacket_PickupSpawn*) tolua_tousertype(tolua_S,2,0)); - { - Lua__cPickup* tolua_ret = (Lua__cPickup*) Mtolua_new((Lua__cPickup)(a_PickupSpawnPacket)); - tolua_pushusertype(tolua_S,(void*)tolua_ret,"Lua__cPickup"); - } - } - return 1; -tolua_lerror: - return tolua_AllToLua_Lua__cPickup_new00(tolua_S); -} -#endif //#ifndef TOLUA_DISABLE - -/* method: new_local of class Lua__cPickup */ -#ifndef TOLUA_DISABLE_tolua_AllToLua_Lua__cPickup_new01_local -static int tolua_AllToLua_Lua__cPickup_new01_local(lua_State* tolua_S) -{ - tolua_Error tolua_err; - if ( - !tolua_isusertable(tolua_S,1,"Lua__cPickup",0,&tolua_err) || - !tolua_isusertype(tolua_S,2,"cPacket_PickupSpawn",0,&tolua_err) || - !tolua_isnoobj(tolua_S,3,&tolua_err) - ) - goto tolua_lerror; - else - { - cPacket_PickupSpawn* a_PickupSpawnPacket = ((cPacket_PickupSpawn*) tolua_tousertype(tolua_S,2,0)); - { - Lua__cPickup* tolua_ret = (Lua__cPickup*) Mtolua_new((Lua__cPickup)(a_PickupSpawnPacket)); - tolua_pushusertype(tolua_S,(void*)tolua_ret,"Lua__cPickup"); - tolua_register_gc(tolua_S,lua_gettop(tolua_S)); - } - } - return 1; -tolua_lerror: - return tolua_AllToLua_Lua__cPickup_new00_local(tolua_S); -} -#endif //#ifndef TOLUA_DISABLE - /* method: delete of class Lua__cPickup */ #ifndef TOLUA_DISABLE_tolua_AllToLua_Lua__cPickup_delete00 static int tolua_AllToLua_Lua__cPickup_delete00(lua_State* tolua_S) @@ -21323,6 +21297,7 @@ TOLUA_API int tolua_AllToLua_open (lua_State* tolua_S) tolua_function(tolua_S,"cEntity__GetEntityType",tolua_AllToLua_Lua__cEntity_cEntity__GetEntityType00); tolua_function(tolua_S,"cEntity__IsA",tolua_AllToLua_Lua__cEntity_cEntity__IsA00); tolua_function(tolua_S,"cEntity__GetClass",tolua_AllToLua_Lua__cEntity_cEntity__GetClass00); + tolua_function(tolua_S,"cEntity__SpawnOn",tolua_AllToLua_Lua__cEntity_cEntity__SpawnOn00); tolua_function(tolua_S,"new",tolua_AllToLua_Lua__cEntity_new00); tolua_function(tolua_S,"new_local",tolua_AllToLua_Lua__cEntity_new00_local); tolua_function(tolua_S,".call",tolua_AllToLua_Lua__cEntity_new00_local); @@ -21664,9 +21639,6 @@ TOLUA_API int tolua_AllToLua_open (lua_State* tolua_S) tolua_function(tolua_S,"new",tolua_AllToLua_cPickup_new00); tolua_function(tolua_S,"new_local",tolua_AllToLua_cPickup_new00_local); tolua_function(tolua_S,".call",tolua_AllToLua_cPickup_new00_local); - tolua_function(tolua_S,"new",tolua_AllToLua_cPickup_new01); - tolua_function(tolua_S,"new_local",tolua_AllToLua_cPickup_new01_local); - tolua_function(tolua_S,".call",tolua_AllToLua_cPickup_new01_local); tolua_function(tolua_S,"delete",tolua_AllToLua_cPickup_delete00); tolua_function(tolua_S,"GetItem",tolua_AllToLua_cPickup_GetItem00); tolua_function(tolua_S,"CollectedBy",tolua_AllToLua_cPickup_CollectedBy00); @@ -21682,9 +21654,6 @@ TOLUA_API int tolua_AllToLua_open (lua_State* tolua_S) tolua_function(tolua_S,"new",tolua_AllToLua_Lua__cPickup_new00); tolua_function(tolua_S,"new_local",tolua_AllToLua_Lua__cPickup_new00_local); tolua_function(tolua_S,".call",tolua_AllToLua_Lua__cPickup_new00_local); - tolua_function(tolua_S,"new",tolua_AllToLua_Lua__cPickup_new01); - tolua_function(tolua_S,"new_local",tolua_AllToLua_Lua__cPickup_new01_local); - tolua_function(tolua_S,".call",tolua_AllToLua_Lua__cPickup_new01_local); tolua_function(tolua_S,"delete",tolua_AllToLua_Lua__cPickup_delete00); tolua_endmodule(tolua_S); tolua_cclass(tolua_S,"cRoot","cRoot","",NULL); diff --git a/source/Bindings.h b/source/Bindings.h index 156288560..32fdaa629 100644 --- a/source/Bindings.h +++ b/source/Bindings.h @@ -1,6 +1,6 @@ /* ** Lua binding: AllToLua -** Generated automatically by tolua++-1.0.92 on 08/23/12 22:41:28. +** Generated automatically by tolua++-1.0.92 on 08/24/12 09:56:22. */ /* Exported function */ diff --git a/source/ChunkSender.cpp b/source/ChunkSender.cpp index e88ed6f31..cefc6458f 100644 --- a/source/ChunkSender.cpp +++ b/source/ChunkSender.cpp @@ -237,20 +237,21 @@ void cChunkSender::SendChunk(int a_ChunkX, int a_ChunkY, int a_ChunkZ, cClientHa a_Client->Send(MapChunk); } - // Send entity creation packets: - for (PacketList::iterator itr = m_Packets.begin(); itr != m_Packets.end(); ++itr) + // Send block-entity packets: + for (sBlockCoords::iterator itr = m_BlockEntities.begin(); itr != m_BlockEntities.end(); ++itr) { if (a_Client == NULL) { - m_World->BroadcastToChunk(a_ChunkX, a_ChunkY, a_ChunkZ, **itr); + m_World->BroadcastBlockEntity(itr->m_BlockX, itr->m_BlockY, itr->m_BlockZ); } else { - a_Client->Send(**itr); + m_World->SendBlockEntity(itr->m_BlockX, itr->m_BlockY, itr->m_BlockZ, *a_Client); } - delete *itr; } // for itr - m_Packets[] - m_Packets.clear(); + m_BlockEntities.clear(); + + // TODO: Send entity spawn packets } @@ -259,11 +260,7 @@ void cChunkSender::SendChunk(int a_ChunkX, int a_ChunkY, int a_ChunkZ, cClientHa void cChunkSender::BlockEntity(cBlockEntity * a_Entity) { - cPacket * Packet = a_Entity->GetPacket(); - if (Packet != NULL) - { - m_Packets.push_back(Packet); - } + m_BlockEntities.push_back(sBlockCoord(a_Entity->GetPosX(), a_Entity->GetPosY(), a_Entity->GetPosZ())); } diff --git a/source/ChunkSender.h b/source/ChunkSender.h index 08d97cfca..b1b276a2e 100644 --- a/source/ChunkSender.h +++ b/source/ChunkSender.h @@ -27,7 +27,6 @@ Note that it may be called by world's BroadcastToChunk() if the client is still #include "cIsThread.h" #include "ChunkDef.h" -#include "packets/cPacket.h" @@ -116,9 +115,25 @@ protected: (a_Other.m_Client == m_Client) ); } - }; + } ; typedef std::list sSendChunkList; + struct sBlockCoord + { + int m_BlockX; + int m_BlockY; + int m_BlockZ; + + sBlockCoord(int a_BlockX, int a_BlockY, int a_BlockZ) : + m_BlockX(a_BlockX), + m_BlockY(a_BlockY), + m_BlockZ(a_BlockZ) + { + } + } ; + + typedef std::vector sBlockCoords; + cWorld * m_World; cCriticalSection m_CS; @@ -133,7 +148,8 @@ protected: // Data about the chunk that is being sent: // NOTE that m_BlockData[] is inherited from the cChunkDataCollector unsigned char m_BiomeMap[cChunkDef::Width * cChunkDef::Width]; - PacketList m_Packets; // Accumulator for the entity-packets to send + sBlockCoords m_BlockEntities; // Coords of the block entities to send + // TODO: sEntityIDs m_Entities; // Entity-IDs of the entities to send // cIsThread override: virtual void Execute(void) override; diff --git a/source/cBlockEntity.h b/source/cBlockEntity.h index 0a6494ec6..f5730d67e 100644 --- a/source/cBlockEntity.h +++ b/source/cBlockEntity.h @@ -58,25 +58,10 @@ public: virtual void UsedBy( cPlayer * a_Player ) = 0; - void SendTo( cClientHandle* a_Client ) - { - std::auto_ptr Packet(GetPacket()); - if (Packet.get() == NULL) - { - return; - } - if ( a_Client != NULL ) - { - a_Client->Send(*(Packet.get())); - } - else // broadcast to all chunk clients - { - m_World->BroadcastToChunkOfBlock(m_PosX, m_PosY, m_PosZ, Packet.get()); - } - } - - /// Returns the packet to send to clients to represent this entity; NULL if no packet needed; caller is supposed to delete the packet - virtual cPacket * GetPacket(void) {return NULL; } + /** Sends the packet defining the block entity to the client specified. + To send to all eligible clients, use cWorld::BroadcastBlockEntity() + */ + virtual void SendTo(cClientHandle & a_Client) = 0; protected: int m_PosX; // Position in absolute block coordinates diff --git a/source/cChestEntity.cpp b/source/cChestEntity.cpp index 92a039dd7..a798eff47 100644 --- a/source/cChestEntity.cpp +++ b/source/cChestEntity.cpp @@ -156,11 +156,12 @@ void cChestEntity::SaveToJson( Json::Value& a_Value ) -void cChestEntity::SendTo( cClientHandle* a_Client, cServer* a_Server ) +void cChestEntity::SendTo(cClientHandle & a_Client) { + // The chest entity doesn't need anything sent to the client when it's created / gets in the viewdistance + // All the actual handling is in the cWindow UI code that gets called when the chest is rclked + UNUSED(a_Client); - UNUSED(a_Server); - return; } diff --git a/source/cChestEntity.h b/source/cChestEntity.h index c97eef5ad..9b747c184 100644 --- a/source/cChestEntity.h +++ b/source/cChestEntity.h @@ -39,7 +39,7 @@ public: bool LoadFromJson( const Json::Value& a_Value ); virtual void SaveToJson(Json::Value& a_Value ) override; - void SendTo( cClientHandle* a_Client, cServer* a_Server ); + virtual void SendTo(cClientHandle & a_Client) override; virtual void UsedBy( cPlayer * a_Player ) override; diff --git a/source/cChunk.cpp b/source/cChunk.cpp index 001c795eb..e528edf24 100644 --- a/source/cChunk.cpp +++ b/source/cChunk.cpp @@ -1230,7 +1230,6 @@ void cChunk::AddBlockEntity( cBlockEntity* a_BlockEntity ) cBlockEntity * cChunk::GetBlockEntity(int a_X, int a_Y, int a_Z) { - // Assumes that the m_CSBlockList is already locked, we're being called from SetBlock() for (cBlockEntityList::iterator itr = m_BlockEntities.begin(); itr != m_BlockEntities.end(); ++itr) { if ( @@ -1308,7 +1307,7 @@ void cChunk::UpdateSign(int a_PosX, int a_PosY, int a_PosZ, const AString & a_Li { MarkDirty(); (reinterpret_cast(*itr))->SetLines(a_Line1, a_Line2, a_Line3, a_Line4); - (*itr)->SendTo(NULL); + m_World->BroadcastBlockEntity(a_PosX, a_PosY, a_PosZ); } } // for itr - m_BlockEntities[] } @@ -1342,8 +1341,8 @@ bool cChunk::AddClient(cClientHandle* a_Client) for (cEntityList::iterator itr = m_Entities.begin(); itr != m_Entities.end(); ++itr ) { - LOGD("cChunk: Entity #%d (%s) at [%i, %i, %i] spawning for player \"%s\"", (*itr)->GetUniqueID(), (*itr)->GetClass(), m_PosX, m_PosY, m_PosZ, a_Client->GetUsername().c_str() ); - (*itr)->SpawnOn( a_Client ); + LOGD("cChunk: Entity #%d (%s) at [%i, %i, %i] spawning for player \"%s\"", (*itr)->GetUniqueID(), (*itr)->GetClass(), m_PosX, m_PosY, m_PosZ, a_Client->GetUsername().c_str()); + (*itr)->SpawnOn(*a_Client); } return true; } @@ -1915,6 +1914,58 @@ void cChunk::BroadcastMetadata(const cPawn & a_Pawn, const cClientHandle * a_Exc +void cChunk::BroadcastSpawn(cEntity & a_Entity, const cClientHandle * a_Exclude) +{ + for (cClientHandleList::iterator itr = m_LoadedByClient.begin(); itr != m_LoadedByClient.end(); ++itr ) + { + if (*itr == a_Exclude) + { + continue; + } + a_Entity.SpawnOn(*(*itr)); + } // for itr - LoadedByClient[] +} + + + + + +void cChunk::BroadcastBlockEntity(int a_BlockX, int a_BlockY, int a_BlockZ, const cClientHandle * a_Exclude) +{ + // We can operate on entity pointers, we're inside the ChunkMap's CS lock which guards the list + cBlockEntity * Entity = GetBlockEntity(a_BlockX, a_BlockY, a_BlockZ); + if (Entity == NULL) + { + return; + } + for (cClientHandleList::iterator itr = m_LoadedByClient.begin(); itr != m_LoadedByClient.end(); ++itr ) + { + if (*itr == a_Exclude) + { + continue; + } + Entity->SendTo(*(*itr)); + } // for itr - LoadedByClient[] +} + + + + + +void cChunk::SendBlockEntity(int a_BlockX, int a_BlockY, int a_BlockZ, cClientHandle & a_Client) +{ + cBlockEntity * Entity = GetBlockEntity(a_BlockX, a_BlockY, a_BlockZ); + if (Entity == NULL) + { + return; + } + Entity->SendTo(a_Client); +} + + + + + void cChunk::PositionToWorldPosition(int a_ChunkX, int a_ChunkY, int a_ChunkZ, int & a_X, int & a_Y, int & a_Z) { a_Y = a_ChunkY; diff --git a/source/cChunk.h b/source/cChunk.h index 1678bbf91..3f821e8ff 100644 --- a/source/cChunk.h +++ b/source/cChunk.h @@ -186,6 +186,10 @@ public: void BroadcastDestroyEntity (const cEntity & a_Entity, const cClientHandle * a_Exclude = NULL); void BroadcastEntityStatus (const cEntity & a_Entity, char a_Status, const cClientHandle * a_Exclude = NULL); void BroadcastMetadata (const cPawn & a_Pawn, const cClientHandle * a_Exclude = NULL); + void BroadcastSpawn (cEntity & a_Entity, const cClientHandle * a_Exclude = NULL); + void BroadcastBlockEntity (int a_BlockX, int a_BlockY, int a_BlockZ, const cClientHandle * a_Exclude = NULL); + + void SendBlockEntity (int a_BlockX, int a_BlockY, int a_BlockZ, cClientHandle & a_Client); void PositionToWorldPosition(int a_ChunkX, int a_ChunkY, int a_ChunkZ, int & a_X, int & a_Y, int & a_Z); Vector3i PositionToWorldPosition( const Vector3i & a_InChunkPos ) { return PositionToWorldPosition( a_InChunkPos.x, a_InChunkPos.y, a_InChunkPos.z ); } diff --git a/source/cChunkMap.cpp b/source/cChunkMap.cpp index c6220bf76..b8e8b05c6 100644 --- a/source/cChunkMap.cpp +++ b/source/cChunkMap.cpp @@ -435,6 +435,56 @@ void cChunkMap::BroadcastMetadata(const cPawn & a_Pawn, const cClientHandle * a_ +void cChunkMap::BroadcastSpawn(cEntity & a_Entity, const cClientHandle * a_Exclude) +{ + cCSLock Lock(m_CSLayers); + cChunkPtr Chunk = GetChunkNoGen(a_Entity.GetChunkX(), a_Entity.GetChunkY(), a_Entity.GetChunkZ()); + if (Chunk == NULL) + { + return; + } + // It's perfectly legal to broadcast packets even to invalid chunks! + Chunk->BroadcastSpawn(a_Entity, a_Exclude); +} + + + + + +void cChunkMap::BroadcastBlockEntity(int a_BlockX, int a_BlockY, int a_BlockZ, const cClientHandle * a_Exclude) +{ + cCSLock Lock(m_CSLayers); + int ChunkX, ChunkZ; + cChunkDef::BlockToChunk(a_BlockX, a_BlockY, a_BlockZ, ChunkX, ChunkZ); + cChunkPtr Chunk = GetChunkNoGen(ChunkX, 0, ChunkZ); + if ((Chunk == NULL) || !Chunk->IsValid()) + { + return; + } + Chunk->BroadcastBlockEntity(a_BlockX, a_BlockY, a_BlockZ, a_Exclude); +} + + + + + +void cChunkMap::SendBlockEntity(int a_BlockX, int a_BlockY, int a_BlockZ, cClientHandle & a_Client) +{ + cCSLock Lock(m_CSLayers); + int ChunkX, ChunkZ; + cChunkDef::BlockToChunk(a_BlockX, a_BlockY, a_BlockZ, ChunkX, ChunkZ); + cChunkPtr Chunk = GetChunkNoGen(ChunkX, 0, ChunkZ); + if ((Chunk == NULL) || !Chunk->IsValid()) + { + return; + } + Chunk->SendBlockEntity(a_BlockX, a_BlockY, a_BlockZ, a_Client); +} + + + + + void cChunkMap::UseBlockEntity(cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ) { // a_Player rclked block entity at the coords specified, handle it diff --git a/source/cChunkMap.h b/source/cChunkMap.h index 69867cd2f..f2fc9685a 100644 --- a/source/cChunkMap.h +++ b/source/cChunkMap.h @@ -75,6 +75,14 @@ public: void BroadcastMetadata(const cPawn & a_Pawn, const cClientHandle * a_Exclude = NULL); + void BroadcastSpawn(cEntity & a_Entity, const cClientHandle * a_Exclude = NULL); + + /// Broadcasts the block entity, if it is at the coords specified, to all clients except a_Exclude + void BroadcastBlockEntity(int a_BlockX, int a_BlockY, int a_BlockZ, const cClientHandle * a_Exclude); + + /// Sends the block entity, if it is at the coords specified, to a_Client + void SendBlockEntity(int a_BlockX, int a_BlockY, int a_BlockZ, cClientHandle & a_Client); + /// a_Player rclked block entity at the coords specified, handle it void UseBlockEntity(cPlayer * a_Player, int a_X, int a_Y, int a_Z); diff --git a/source/cClientHandle.cpp b/source/cClientHandle.cpp index ed4d13a61..5c63cce57 100644 --- a/source/cClientHandle.cpp +++ b/source/cClientHandle.cpp @@ -1818,6 +1818,83 @@ void cClientHandle::SendInventoryProgress(char a_WindowID, short a_ProgressBar, +void cClientHandle::SendPlayerSpawn(const cPlayer & a_Player) +{ + cPacket_NamedEntitySpawn SpawnPacket; + SpawnPacket.m_UniqueID = a_Player.GetUniqueID(); + SpawnPacket.m_PlayerName = a_Player.GetName(); + SpawnPacket.m_PosX = (int)(a_Player.GetPosX() * 32); + SpawnPacket.m_PosY = (int)(a_Player.GetPosY() * 32); + SpawnPacket.m_PosZ = (int)(a_Player.GetPosZ() * 32); + SpawnPacket.m_Rotation = (char)((a_Player.GetRot().x / 360.f) * 256); + SpawnPacket.m_Pitch = (char)((a_Player.GetRot().y / 360.f) * 256); + const cItem & HeldItem = a_Player.GetEquippedItem(); + SpawnPacket.m_CurrentItem = HeldItem.IsEmpty() ? 0 : HeldItem.m_ItemType; // Unlike -1 in inventory, the named entity packet uses 0 for "empty" + Send(SpawnPacket); +} + + + + + +void cClientHandle::SendPickupSpawn(const cPickup & a_Pickup) +{ + cPacket_PickupSpawn PickupSpawn; + PickupSpawn.m_UniqueID = a_Pickup.GetUniqueID(); + PickupSpawn.m_ItemType = a_Pickup.GetItem()->m_ItemType; + PickupSpawn.m_ItemCount = a_Pickup.GetItem()->m_ItemCount; + PickupSpawn.m_ItemDamage = a_Pickup.GetItem()->m_ItemHealth; + PickupSpawn.m_PosX = (int) (a_Pickup.GetPosX() * 32); + PickupSpawn.m_PosY = (int) (a_Pickup.GetPosY() * 32); + PickupSpawn.m_PosZ = (int) (a_Pickup.GetPosZ() * 32); + PickupSpawn.m_Rotation = (char)(a_Pickup.GetSpeed().x * 8); + PickupSpawn.m_Pitch = (char)(a_Pickup.GetSpeed().y * 8); + PickupSpawn.m_Roll = (char)(a_Pickup.GetSpeed().z * 8); + Send(PickupSpawn); +} + + + + + +void cClientHandle::SendSpawnMob(const cMonster & a_Mob) +{ + cPacket_SpawnMob Spawn; + Spawn.m_UniqueID = a_Mob.GetUniqueID(); + Spawn.m_Type = a_Mob.GetMobType(); + Spawn.m_Pos = ((Vector3i)(a_Mob.GetPosition())) * 32; + Spawn.m_Yaw = 0; + Spawn.m_Pitch = 0; + Spawn.m_MetaDataSize = 1; + Spawn.m_MetaData = new char[Spawn.m_MetaDataSize]; + Spawn.m_MetaData[0] = 0x7f; // not on fire/crouching/riding + Send(Spawn); +} + + + + + +void cClientHandle::SendUpdateSign( + int a_BlockX, int a_BlockY, int a_BlockZ, + const AString & a_Line1, const AString & a_Line2, const AString & a_Line3, const AString & a_Line4 +) +{ + cPacket_UpdateSign us; + us.m_BlockX = a_BlockX; + us.m_BlockY = a_BlockY; + us.m_BlockZ = a_BlockZ; + us.m_Line1 = a_Line1; + us.m_Line2 = a_Line2; + us.m_Line3 = a_Line3; + us.m_Line4 = a_Line4; + Send(us); +} + + + + + void cClientHandle::CheckIfWorldDownloaded(void) { if (m_State != csDownloadingWorld) diff --git a/source/cClientHandle.h b/source/cClientHandle.h index bc644227f..ae2bea6c5 100644 --- a/source/cClientHandle.h +++ b/source/cClientHandle.h @@ -33,6 +33,8 @@ class cRedstone; class cInventory; class cWindow; class cPawn; +class cPickup; +class cMonster; @@ -107,6 +109,10 @@ public: void SendEntityStatus(const cEntity & a_Entity, char a_Status); void SendMetadata(const cPawn & a_Entity); void SendInventoryProgress(char a_WindowID, short a_Progressbar, short a_Value); + void SendPlayerSpawn(const cPlayer & a_Player); + void SendPickupSpawn(const cPickup & a_Pickup); + void SendSpawnMob (const cMonster & a_Mob); + void SendUpdateSign (int a_BlockX, int a_BlockY, int a_BlockZ, const AString & a_Line1, const AString & a_Line2, const AString & a_Line3, const AString & a_Line4); const AString & GetUsername(void) const; //tolua_export diff --git a/source/cEntity.cpp b/source/cEntity.cpp index a906737cf..12af1c0b7 100644 --- a/source/cEntity.cpp +++ b/source/cEntity.cpp @@ -68,7 +68,13 @@ cEntity::~cEntity() -void cEntity::Initialize( cWorld* a_World ) +CLASS_DEF_GETCLASS(cEntity); + + + + + +void cEntity::Initialize(cWorld * a_World) { m_World = a_World; m_World->AddEntity( this ); @@ -118,31 +124,17 @@ void cEntity::MoveToCorrectChunk(bool a_bIgnoreOldChunk) virtual void Added(cClientHandle * a_Client) override { - if (m_Spawn == NULL) - { - m_Spawn = m_Entity->GetSpawnPacket(); // Only create the packet when needed - } - if (m_Spawn != NULL) - { - a_Client->Send(*m_Spawn); - } + m_Entity->SpawnOn(*a_Client); } - cPacket * m_Spawn; bool m_IgnoreOldChunk; cEntity * m_Entity; public: cMover(cEntity * a_Entity, bool a_IgnoreOldChunk) : - m_Spawn(NULL), m_IgnoreOldChunk(a_IgnoreOldChunk), m_Entity(a_Entity) {} - - ~cMover() - { - delete m_Spawn; - } } Mover(this, a_bIgnoreOldChunk); m_World->CompareChunkClients(m_ChunkX, m_ChunkY, m_ChunkZ, ChunkX, ChunkY, ChunkZ, Mover); @@ -194,29 +186,6 @@ void cEntity::RemoveFromChunk(void) -void cEntity::SpawnOn(cClientHandle * a_Client) -{ - std::auto_ptr SpawnPacket(GetSpawnPacket()); - if (SpawnPacket.get() == NULL) - { - return; - } - - if (a_Client == NULL) - { - m_World->BroadcastToChunk(m_ChunkX, m_ChunkY, m_ChunkZ, *SpawnPacket.get(), NULL); - } - else - { - a_Client->Send(*(SpawnPacket.get())); - } -} - - - - - -CLASS_DEF_GETCLASS( cEntity ); bool cEntity::IsA( const char* a_EntityType ) { //LOG("IsA( cEntity ) : %s", a_EntityType); diff --git a/source/cEntity.h b/source/cEntity.h index ed32cdf4b..50955f9ce 100644 --- a/source/cEntity.h +++ b/source/cEntity.h @@ -66,7 +66,7 @@ public: cEntity(const double & a_X, const double & a_Y, const double & a_Z); virtual ~cEntity(); - virtual void Initialize( cWorld* a_World ); + virtual void Initialize(cWorld * a_World); enum eEntityType { @@ -114,8 +114,11 @@ public: virtual void Tick(float a_Dt) = 0; //tolua_export - virtual cPacket * GetSpawnPacket(void) const {ASSERT(!"GetSpawnedPacket unimplemented!"); return NULL; }; // _X: Needs to be implemented due to Lua bindings - void SpawnOn (cClientHandle * a_Client); // tolua_export + /** Descendants override this function to send a command to the specified client to spawn the entity on the client. + To spawn on all eligible clients, use cChunkMap::BroadcastSpawnEntity() + Needs to have a default implementation due to Lua bindings. + */ + virtual void SpawnOn(cClientHandle & a_Client) {ASSERT(!"SpawnOn() unimplemented!"); } // tolua_export void WrapRotation(); diff --git a/source/cFurnaceEntity.cpp b/source/cFurnaceEntity.cpp index 4b3c1d04e..5f0840913 100644 --- a/source/cFurnaceEntity.cpp +++ b/source/cFurnaceEntity.cpp @@ -386,3 +386,13 @@ void cFurnaceEntity::SaveToJson( Json::Value& a_Value ) + +void cFurnaceEntity::SendTo(cClientHandle & a_Client) +{ + // Nothing needs to be sent + UNUSED(a_Client); +} + + + + diff --git a/source/cFurnaceEntity.h b/source/cFurnaceEntity.h index d133561a1..953644097 100644 --- a/source/cFurnaceEntity.h +++ b/source/cFurnaceEntity.h @@ -35,6 +35,8 @@ public: bool LoadFromJson(const Json::Value& a_Value ); virtual void SaveToJson(Json::Value& a_Value ) override; + virtual void SendTo(cClientHandle & a_Client) override; + // Returns true if there's any change, forcing the chunk to go dirty. bool Tick( float a_Dt ); diff --git a/source/cFurnaceWindow.cpp b/source/cFurnaceWindow.cpp index 480eaee1c..683bf7166 100644 --- a/source/cFurnaceWindow.cpp +++ b/source/cFurnaceWindow.cpp @@ -6,8 +6,6 @@ #include "cFurnaceEntity.h" #include "cPlayer.h" -#include "packets/cPacket_WindowClick.h" - diff --git a/source/cInventory.cpp b/source/cInventory.cpp index 7122a697c..cd74cad41 100644 --- a/source/cInventory.cpp +++ b/source/cInventory.cpp @@ -235,7 +235,7 @@ void cInventory::SetEquippedSlot( int a_SlotNum ) -cItem & cInventory::GetEquippedItem() +cItem & cInventory::GetEquippedItem(void) { cItem* Item = GetFromHotBar( m_EquippedSlot ); if( Item ) @@ -254,6 +254,15 @@ cItem & cInventory::GetEquippedItem() +const cItem & cInventory::GetEquippedItem(void) const +{ + return *m_EquippedItem; +} + + + + + void cInventory::SendWholeInventory(cClientHandle * a_Client) { a_Client->SendWholeInventory(*this); diff --git a/source/cInventory.h b/source/cInventory.h index 7513df969..bb8519828 100644 --- a/source/cInventory.h +++ b/source/cInventory.h @@ -47,7 +47,8 @@ public: cItem* GetSlots() const { return m_Slots; } cItem* GetFromHotBar( int a_SlotNum ); //tolua_export - cItem & GetEquippedItem(); //tolua_export + cItem & GetEquippedItem(void); //tolua_export + const cItem & GetEquippedItem(void) const; void SetEquippedSlot( int a_SlotNum ); //tolua_export short GetEquippedSlot() { return m_EquippedSlot; } //tolua_export diff --git a/source/cMonster.cpp b/source/cMonster.cpp index a7c05977e..24d790dc3 100644 --- a/source/cMonster.cpp +++ b/source/cMonster.cpp @@ -11,8 +11,6 @@ #include "cMonsterConfig.h" #include "MersenneTwister.h" -#include "packets/cPacket_SpawnMob.h" - #include "Vector3f.h" #include "Vector3i.h" #include "Vector3d.h" @@ -78,18 +76,9 @@ bool cMonster::IsA( const char* a_EntityType ) -cPacket * cMonster::GetSpawnPacket(void) const +void cMonster::SpawnOn(cClientHandle & a_Client) { - cPacket_SpawnMob * Spawn = new cPacket_SpawnMob; - Spawn->m_UniqueID = GetUniqueID(); - Spawn->m_Type = m_MobType; - *Spawn->m_Pos = ((Vector3i)(m_Pos)) * 32; - Spawn->m_Yaw = 0; - Spawn->m_Pitch = 0; - Spawn->m_MetaDataSize = 1; - Spawn->m_MetaData = new char[Spawn->m_MetaDataSize]; - Spawn->m_MetaData[0] = 0x7f; // not on fire/crouching/riding - return Spawn; + a_Client.SendSpawnMob(*this); } diff --git a/source/cMonster.h b/source/cMonster.h index d46cd9205..f16b7aa56 100644 --- a/source/cMonster.h +++ b/source/cMonster.h @@ -27,22 +27,23 @@ public: virtual bool IsA( const char* a_EntityType ); - virtual cPacket * GetSpawnPacket(void) const override; + virtual void SpawnOn(cClientHandle & a_ClientHandle) override; virtual void Tick(float a_Dt) override; virtual void HandlePhysics(float a_Dt); - virtual void ReplicateMovement(); + virtual void ReplicateMovement(void); - virtual void TakeDamage( int a_Damage, cEntity* a_Instigator ); - virtual void KilledBy( cEntity* a_Killer ); + virtual void TakeDamage(int a_Damage, cEntity * a_Instigator) override; + virtual void KilledBy(cEntity * a_Killer) override; - virtual void MoveToPosition( const Vector3f & a_Position ); - virtual bool ReachedDestination(); + virtual void MoveToPosition(const Vector3f & a_Position); + virtual bool ReachedDestination(void); + + char GetMobType(void) const {return m_MobType; } - const char *GetState(); + const char * GetState(); void SetState(const AString & str); - static void ListMonsters(); virtual void CheckEventSeePlayer(); virtual void EventSeePlayer(cEntity *); diff --git a/source/cPickup.cpp b/source/cPickup.cpp index d643c9d88..dd0da9372 100644 --- a/source/cPickup.cpp +++ b/source/cPickup.cpp @@ -17,8 +17,6 @@ #include "cRoot.h" #include "cTracer.h" -#include "packets/cPacket_TeleportEntity.h" -#include "packets/cPacket_PickupSpawn.h" #include "packets/cPacket_CollectItem.h" #include "Vector3d.h" @@ -30,10 +28,9 @@ CLASS_DEFINITION( cPickup, cEntity ) -cPickup::~cPickup() -{ - delete m_Item; -} + + + cPickup::cPickup(int a_X, int a_Y, int a_Z, const cItem & a_Item, float a_SpeedX /* = 0.f */, float a_SpeedY /* = 0.f */, float a_SpeedZ /* = 0.f */) : cEntity( ((double)(a_X))/32, ((double)(a_Y))/32, ((double)(a_Z))/32 ) @@ -44,18 +41,7 @@ cPickup::cPickup(int a_X, int a_Y, int a_Z, const cItem & a_Item, float a_SpeedX , m_Item( new cItem( a_Item ) ) , m_bCollected( false ) { - - //LOG("New pickup: ID(%i) Amount(%i) Health(%i)", m_Item.m_ItemID, m_Item.m_ItemCount, m_Item.m_ItemHealth ); - - // Spawn it on clients - if (!a_Item.IsEmpty()) - { - std::auto_ptr PickupSpawn(GetSpawnPacket()); - if (PickupSpawn.get() != NULL) - { - cRoot::Get()->GetServer()->Broadcast(*(PickupSpawn.get())); - } - } + // LOGD("New pickup: ID(%i) Amount(%i) Health(%i)", m_Item.m_ItemID, m_Item.m_ItemCount, m_Item.m_ItemHealth ); m_EntityType = eEntityType_Pickup; } @@ -64,59 +50,28 @@ cPickup::cPickup(int a_X, int a_Y, int a_Z, const cItem & a_Item, float a_SpeedX -cPickup::cPickup(cPacket_PickupSpawn* a_PickupSpawnPacket) - : cEntity( ((double)a_PickupSpawnPacket->m_PosX)/32, ((double)a_PickupSpawnPacket->m_PosY)/32, ((double)a_PickupSpawnPacket->m_PosZ)/32 ) - , m_Speed( new Vector3f() ) - , m_ResultingSpeed(new Vector3f()) - , m_WaterSpeed(new Vector3f()) - , m_bOnGround( false ) - , m_bReplicated( false ) - , m_Timer( 0.f ) - , m_bCollected( false ) +cPickup::~cPickup() { - a_PickupSpawnPacket->m_UniqueID = m_UniqueID; - - m_Item = new cItem(); - m_Item->m_ItemID = (ENUM_ITEM_ID)a_PickupSpawnPacket->m_Item; - m_Item->m_ItemCount = a_PickupSpawnPacket->m_Count; - m_Item->m_ItemHealth = 0x0; - - m_Speed.x = (float)(a_PickupSpawnPacket->m_Rotation) / 8; - m_Speed.y = (float)(a_PickupSpawnPacket->m_Pitch) / 8; - m_Speed.z = (float)(a_PickupSpawnPacket->m_Roll) / 8; - - // Spawn it on clients - if (a_PickupSpawnPacket->m_Item != E_ITEM_EMPTY) - { - cRoot::Get()->GetServer()->Broadcast( *a_PickupSpawnPacket ); - } - - m_EntityType = eEntityType_Pickup; + delete m_Item; } -cPacket * cPickup::GetSpawnPacket(void) const +void cPickup::Initialize(cWorld * a_World) { - if (m_Item->IsEmpty()) - { - return NULL; - } - - cPacket_PickupSpawn * PickupSpawn = new cPacket_PickupSpawn; - PickupSpawn->m_UniqueID = m_UniqueID; - PickupSpawn->m_Item = (short)m_Item->m_ItemID; - PickupSpawn->m_Count = m_Item->m_ItemCount; - PickupSpawn->m_Health = m_Item->m_ItemHealth; - PickupSpawn->m_PosX = (int) (m_Pos.x * 32); - PickupSpawn->m_PosY = (int) (m_Pos.y * 32); - PickupSpawn->m_PosZ = (int) (m_Pos.z * 32); - PickupSpawn->m_Rotation = (char)(m_Speed.x * 8); - PickupSpawn->m_Pitch = (char)(m_Speed.y * 8); - PickupSpawn->m_Roll = (char)(m_Speed.z * 8); - return PickupSpawn; + super::Initialize(a_World); + a_World->BroadcastSpawn(*this); +} + + + + + +void cPickup::SpawnOn(cClientHandle & a_Client) +{ + a_Client.SendPickupSpawn(*this); } diff --git a/source/cPickup.h b/source/cPickup.h index a13767738..06d5fe301 100644 --- a/source/cPickup.h +++ b/source/cPickup.h @@ -14,24 +14,35 @@ class cItem; -class cPickup : public cEntity //tolua_export -{ //tolua_export +// tolua_begin +class cPickup : + public cEntity +{ + // tolua_end + typedef cEntity super; + // tolua_begin + public: + // tolua_end CLASS_PROTOTYPE(); cPickup(int a_X, int a_Y, int a_Z, const cItem & a_Item, float a_SpeedX = 0.f, float a_SpeedY = 0.f, float a_SpeedZ = 0.f); //tolua_export - cPickup(cPacket_PickupSpawn * a_PickupSpawnPacket); //tolua_export ~cPickup(); //tolua_export + + virtual void Initialize(cWorld * a_World) override; - cItem * GetItem() { return m_Item; } //tolua_export + cItem * GetItem(void) {return m_Item; } //tolua_export + const cItem * GetItem(void) const {return m_Item; } - virtual cPacket * GetSpawnPacket(void) const override; + virtual void SpawnOn(cClientHandle & a_ClientHandle) override; virtual bool CollectedBy( cPlayer* a_Dest ); //tolua_export void Tick(float a_Dt); void HandlePhysics(float a_Dt); + const Vector3f & GetSpeed(void) const {return m_Speed; } + private: Vector3f m_Speed; diff --git a/source/cPiston.cpp b/source/cPiston.cpp index b314cffe1..464db8911 100644 --- a/source/cPiston.cpp +++ b/source/cPiston.cpp @@ -11,7 +11,6 @@ #include "cClientHandle.h" #include "cWorld.h" #include "BlockID.h" -#include "packets/cPacket_BlockAction.h" #include "cServer.h" #include "blocks/Block.h" diff --git a/source/cPlayer.cpp b/source/cPlayer.cpp index 14163a798..2a52d7da8 100644 --- a/source/cPlayer.cpp +++ b/source/cPlayer.cpp @@ -21,8 +21,6 @@ #include "cTimer.h" #include "MersenneTwister.h" -#include "packets/cPacket_NamedEntitySpawn.h" - #include "Vector3d.h" #include "Vector3f.h" @@ -102,16 +100,6 @@ cPlayer::cPlayer(cClientHandle* a_Client, const AString & a_PlayerName) -void cPlayer::Initialize( cWorld* a_World ) -{ - cPawn::Initialize( a_World ); - GetWorld()->AddPlayer( this ); -} - - - - - cPlayer::~cPlayer(void) { LOG("Deleting cPlayer \"%s\" at %p, ID %d", m_PlayerName.c_str(), this, GetUniqueID()); @@ -134,6 +122,16 @@ cPlayer::~cPlayer(void) +void cPlayer::Initialize( cWorld* a_World ) +{ + cPawn::Initialize( a_World ); + GetWorld()->AddPlayer( this ); +} + + + + + void cPlayer::Destroyed() { CloseWindow(-1); @@ -144,28 +142,18 @@ void cPlayer::Destroyed() -cPacket * cPlayer::GetSpawnPacket(void) const +void cPlayer::SpawnOn(cClientHandle & a_Client) { - LOGD("cPlayer::GetSpawnPacket for \"%s\" at pos {%.2f, %.2f, %.2f}", - m_PlayerName.c_str(), m_Pos.x, m_Pos.y, m_Pos.z + /* + LOGD("cPlayer::SpawnOn(%s) for \"%s\" at pos {%.2f, %.2f, %.2f}", + a_Client.GetUsername().c_str(), m_PlayerName.c_str(), m_Pos.x, m_Pos.y, m_Pos.z ); - - if (!m_bVisible ) + */ + + if (m_bVisible) { - return NULL; + a_Client.SendPlayerSpawn(*this); } - - cPacket_NamedEntitySpawn * SpawnPacket = new cPacket_NamedEntitySpawn; - SpawnPacket->m_UniqueID = m_UniqueID; - SpawnPacket->m_PlayerName = m_PlayerName; - SpawnPacket->m_PosX = (int)(m_Pos.x * 32); - SpawnPacket->m_PosY = (int)(m_Pos.y * 32); - SpawnPacket->m_PosZ = (int)(m_Pos.z * 32); - SpawnPacket->m_Rotation = (char)((m_Rot.x / 360.f) * 256); - SpawnPacket->m_Pitch = (char)((m_Rot.y / 360.f) * 256); - short ItemID = (short)m_Inventory->GetEquippedItem().m_ItemID; - SpawnPacket->m_CurrentItem = (ItemID > 0) ? ItemID : 0; // Unlike -1 in inventory, the named entity packet uses 0 for "none" - return SpawnPacket; } @@ -603,7 +591,7 @@ void cPlayer::SetVisible(bool a_bVisible) if (a_bVisible && !m_bVisible) // Make visible { m_bVisible = true; - SpawnOn(NULL); // Spawn on all clients + m_World->BroadcastSpawn(*this); } if (!a_bVisible && m_bVisible) { @@ -620,7 +608,7 @@ void cPlayer::AddToGroup( const char* a_GroupName ) { cGroup* Group = cRoot::Get()->GetGroupManager()->GetGroup( a_GroupName ); m_Groups.push_back( Group ); - LOG("Added %s to group %s", m_PlayerName.c_str(), a_GroupName ); + LOGD("Added %s to group %s", m_PlayerName.c_str(), a_GroupName ); ResolveGroups(); ResolvePermissions(); } diff --git a/source/cPlayer.h b/source/cPlayer.h index ba8e15880..91aa9c831 100644 --- a/source/cPlayer.h +++ b/source/cPlayer.h @@ -31,7 +31,8 @@ public: virtual void Initialize( cWorld* a_World ); //tolua_export - virtual cPacket * GetSpawnPacket(void) const override; + virtual void SpawnOn(cClientHandle & a_Client) override; + virtual void Tick(float a_Dt) override; void SetTouchGround( bool a_bTouchGround ); @@ -42,11 +43,14 @@ public: inline bool GetFlying() { return m_bTouchGround; } //tolua_export inline bool IsOnGround(void) const {return m_bTouchGround; } // tolua_export inline const double GetStance(void) const { return m_Pos.y + 1.62; } //tolua_export // TODO: Proper stance when crouching etc. - inline cInventory & GetInventory() { if(GetGameMode() == eGameMode_Survival) return *m_Inventory; else return *m_CreativeInventory; } //tolua_export + inline cInventory & GetInventory(void) { if (GetGameMode() == eGameMode_Survival) return *m_Inventory; else return *m_CreativeInventory; } //tolua_export + inline const cInventory & GetInventory(void) const { if (GetGameMode() == eGameMode_Survival) return *m_Inventory; else return *m_CreativeInventory; } + + inline const cItem & GetEquippedItem(void) const {return GetInventory().GetEquippedItem(); } virtual void TeleportTo( const double & a_PosX, const double & a_PosY, const double & a_PosZ ); //tolua_export - eGameMode GetGameMode() { return m_GameMode; } //tolua_export + eGameMode GetGameMode(void) const { return m_GameMode; } //tolua_export std::string GetIP() { return m_IP; } //tolua_export float GetLastBlockActionTime() { return m_LastBlockActionTime; } //tolua_export int GetLastBlockActionCnt() { return m_LastBlockActionCnt; } //tolua_export diff --git a/source/cServer.cpp b/source/cServer.cpp index ef626614a..162512f24 100644 --- a/source/cServer.cpp +++ b/source/cServer.cpp @@ -27,8 +27,6 @@ #include "../iniFile/iniFile.h" #include "Vector3f.h" -#include "packets/cPacket_Chat.h" - #include #include #include @@ -286,16 +284,33 @@ cServer::~cServer() // TODO - Need to modify this or something, so it broadcasts to all worlds? And move this to cWorld? -void cServer::Broadcast( const cPacket & a_Packet, cClientHandle* a_Exclude /* = 0 */ ) +void cServer::Broadcast(const cPacket & a_Packet, cClientHandle * a_Exclude) { cCSLock Lock(m_CSClients); - for( ClientList::iterator itr = m_Clients.begin(); itr != m_Clients.end(); ++itr) + for (ClientList::iterator itr = m_Clients.begin(); itr != m_Clients.end(); ++itr) { if ((*itr == a_Exclude) || !(*itr)->IsLoggedIn()) { continue; } - (*itr)->Send( a_Packet ); + (*itr)->Send(a_Packet); + } +} + + + + + +void cServer::BroadcastChat(const AString & a_Message, const cClientHandle * a_Exclude) +{ + cCSLock Lock(m_CSClients); + for (ClientList::iterator itr = m_Clients.begin(); itr != m_Clients.end(); ++itr) + { + if ((*itr == a_Exclude) || !(*itr)->IsLoggedIn()) + { + continue; + } + (*itr)->SendChat(a_Message); } } @@ -520,9 +535,10 @@ void cServer::ServerCommand(const AString & a_Cmd) { if (split[0].compare("say") == 0) { - AString Message = cChatColor::Purple + "[SERVER] " + a_Cmd.substr(a_Cmd.find_first_of("say") + 4); - LOG("%s", Message.c_str() ); - Broadcast(cPacket_Chat(Message)); + AString ToSay = a_Cmd.substr(a_Cmd.find_first_of("say") + 4); + AString Message = cChatColor::Purple + "[SERVER] " + ToSay; + LOG("[SERVER]: %s", ToSay.c_str()); + BroadcastChat(Message); return; } } @@ -534,17 +550,19 @@ void cServer::ServerCommand(const AString & a_Cmd) -void cServer::SendMessage( const char* a_Message, cPlayer* a_Player /* = 0 */, bool a_bExclude /* = false */ ) +void cServer::SendMessage(const AString & a_Message, cPlayer * a_Player /* = NULL */, bool a_bExclude /* = false */ ) { - cPacket_Chat Chat( a_Message ); - if( a_Player && !a_bExclude ) + if ((a_Player != NULL) && !a_bExclude) { - cClientHandle* Client = a_Player->GetClientHandle(); - if( Client ) Client->Send( Chat ); + cClientHandle * Client = a_Player->GetClientHandle(); + if (Client != NULL) + { + Client->SendChat(a_Message); + } return; } - Broadcast( Chat, (a_Player)?a_Player->GetClientHandle():0 ); + BroadcastChat(a_Message, (a_Player != NULL) ? a_Player->GetClientHandle() : NULL); } diff --git a/source/cServer.h b/source/cServer.h index 52094e2f7..e80d0927e 100644 --- a/source/cServer.h +++ b/source/cServer.h @@ -39,6 +39,7 @@ public: //tolua_export void StartListenClient(); // Listen to client void Broadcast(const cPacket & a_Packet, cClientHandle* a_Exclude = NULL); + void BroadcastChat(const AString & a_Message, const cClientHandle * a_Exclude = NULL); bool Tick(float a_Dt); @@ -48,7 +49,7 @@ public: //tolua_export void ServerCommand(const AString & a_Cmd); //tolua_export void Shutdown(); - void SendMessage( const char* a_Message, cPlayer* a_Player = 0, bool a_bExclude = false ); //tolua_export + void SendMessage(const AString & a_Message, cPlayer * a_Player = NULL, bool a_bExclude = false ); // tolua_export void KickUser(int a_ClientID, const AString & a_Reason); void AuthenticateUser(int a_ClientID); // Called by cAuthenticator to auth the specified user diff --git a/source/cSignEntity.cpp b/source/cSignEntity.cpp index eefcf4ccd..6caff7add 100644 --- a/source/cSignEntity.cpp +++ b/source/cSignEntity.cpp @@ -8,8 +8,6 @@ #include "cWorld.h" #include "cRoot.h" -#include "packets/cPacket_UpdateSign.h" - #include @@ -80,17 +78,9 @@ AString cSignEntity::GetLine( int a_Index ) const -cPacket * cSignEntity::GetPacket(void) +void cSignEntity::SendTo(cClientHandle & a_Client) { - cPacket_UpdateSign * Sign = new cPacket_UpdateSign; - Sign->m_BlockX = m_PosX; - Sign->m_BlockY = (short)m_PosY; - Sign->m_BlockZ = m_PosZ; - Sign->m_Line1 = m_Line[0]; - Sign->m_Line2 = m_Line[1]; - Sign->m_Line3 = m_Line[2]; - Sign->m_Line4 = m_Line[3]; - return Sign; + a_Client.SendUpdateSign(m_PosX, m_PosY, m_PosZ, m_Line[0], m_Line[1], m_Line[2], m_Line[3]); } diff --git a/source/cSignEntity.h b/source/cSignEntity.h index 5f6e60889..8d9cd5016 100644 --- a/source/cSignEntity.h +++ b/source/cSignEntity.h @@ -32,8 +32,7 @@ public: AString GetLine( int a_Index ) const; virtual void UsedBy( cPlayer * a_Player ) override; - - virtual cPacket * GetPacket(void) override; + virtual void SendTo(cClientHandle & a_Client) override; private: diff --git a/source/cWorld.cpp b/source/cWorld.cpp index f12f9f1a8..691d41889 100644 --- a/source/cWorld.cpp +++ b/source/cWorld.cpp @@ -723,9 +723,9 @@ void cWorld::TickSpawnMobs(float a_Dt) if( Monster ) { - Monster->Initialize( this ); - Monster->TeleportTo( SpawnPos.x, (double)(Height) + 2, SpawnPos.z ); - Monster->SpawnOn(0); + Monster->Initialize(this); + Monster->TeleportTo(SpawnPos.x, (double)(Height) + 2, SpawnPos.z); + BroadcastSpawn(*Monster); } } @@ -1134,7 +1134,7 @@ void cWorld::GetBlockTypeMeta(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYP void cWorld::SpawnItemPickups(const cItems & a_Pickups, double a_BlockX, double a_BlockY, double a_BlockZ, double a_FlyAwaySpeed) { MTRand r1; - a_FlyAwaySpeed /= 1000; // Pre-divide, so that we can don't have to divide each time inside the loop + a_FlyAwaySpeed /= 1000; // Pre-divide, so that we don't have to divide each time inside the loop for (cItems::const_iterator itr = a_Pickups.begin(); itr != a_Pickups.end(); ++itr) { float SpeedX = (float)(a_FlyAwaySpeed * (r1.randInt(1000) - 500)); @@ -1390,6 +1390,33 @@ void cWorld::BroadcastMetadata(const cPawn & a_Pawn, const cClientHandle * a_Exc +void cWorld::BroadcastSpawn(cEntity & a_Entity, const cClientHandle * a_Exclude) +{ + m_ChunkMap->BroadcastSpawn(a_Entity, a_Exclude); +} + + + + + +void cWorld::BroadcastBlockEntity(int a_BlockX, int a_BlockY, int a_BlockZ, const cClientHandle * a_Exclude) +{ + m_ChunkMap->BroadcastBlockEntity(a_BlockX, a_BlockY, a_BlockZ, a_Exclude); +} + + + + + +void cWorld::SendBlockEntity(int a_BlockX, int a_BlockY, int a_BlockZ, cClientHandle & a_Client) +{ + m_ChunkMap->SendBlockEntity(a_BlockX, a_BlockY, a_BlockZ, a_Client); +} + + + + + void cWorld::MarkChunkDirty (int a_ChunkX, int a_ChunkY, int a_ChunkZ) { m_ChunkMap->MarkChunkDirty (a_ChunkX, a_ChunkY, a_ChunkZ); diff --git a/source/cWorld.h b/source/cWorld.h index 6cac25b66..16d96eabf 100644 --- a/source/cWorld.h +++ b/source/cWorld.h @@ -90,6 +90,13 @@ public: void BroadcastDestroyEntity (const cEntity & a_Entity, const cClientHandle * a_Exclude = NULL); void BroadcastEntityStatus (const cEntity & a_Entity, char a_Status, const cClientHandle * a_Exclude = NULL); void BroadcastMetadata (const cPawn & a_Pawn, const cClientHandle * a_Exclude = NULL); + void BroadcastSpawn (cEntity & a_Entity, const cClientHandle * a_Exclude = NULL); + + /// If there is a block entity at the specified coods, sends it to all clients except a_Exclude + void BroadcastBlockEntity (int a_BlockX, int a_BlockY, int a_BlockZ, const cClientHandle * a_Exclude = NULL); + + /// If there is a block entity at the specified coords, sends it to the client specified + void SendBlockEntity(int a_BlockX, int a_BlockY, int a_BlockZ, cClientHandle & a_Client); void MarkChunkDirty (int a_ChunkX, int a_ChunkY, int a_ChunkZ); void MarkChunkSaving(int a_ChunkX, int a_ChunkY, int a_ChunkZ); diff --git a/source/packets/cPacket_PickupSpawn.cpp b/source/packets/cPacket_PickupSpawn.cpp index 0a858ba76..1d937cd6c 100644 --- a/source/packets/cPacket_PickupSpawn.cpp +++ b/source/packets/cPacket_PickupSpawn.cpp @@ -10,16 +10,16 @@ int cPacket_PickupSpawn::Parse(cByteBuffer & a_Buffer) { int TotalBytes = 0; - HANDLE_PACKET_READ(ReadBEInt, m_UniqueID, TotalBytes); - HANDLE_PACKET_READ(ReadBEShort, m_Item, TotalBytes); - HANDLE_PACKET_READ(ReadChar, m_Count, TotalBytes); - HANDLE_PACKET_READ(ReadBEShort, m_Health, TotalBytes); - HANDLE_PACKET_READ(ReadBEInt, m_PosX, TotalBytes); - HANDLE_PACKET_READ(ReadBEInt, m_PosY, TotalBytes); - HANDLE_PACKET_READ(ReadBEInt, m_PosZ, TotalBytes); - HANDLE_PACKET_READ(ReadChar, m_Rotation, TotalBytes); - HANDLE_PACKET_READ(ReadChar, m_Pitch, TotalBytes); - HANDLE_PACKET_READ(ReadChar, m_Roll, TotalBytes); + HANDLE_PACKET_READ(ReadBEInt, m_UniqueID, TotalBytes); + HANDLE_PACKET_READ(ReadBEShort, m_ItemType, TotalBytes); + HANDLE_PACKET_READ(ReadChar, m_ItemCount, TotalBytes); + HANDLE_PACKET_READ(ReadBEShort, m_ItemDamage, TotalBytes); + HANDLE_PACKET_READ(ReadBEInt, m_PosX, TotalBytes); + HANDLE_PACKET_READ(ReadBEInt, m_PosY, TotalBytes); + HANDLE_PACKET_READ(ReadBEInt, m_PosZ, TotalBytes); + HANDLE_PACKET_READ(ReadChar, m_Rotation, TotalBytes); + HANDLE_PACKET_READ(ReadChar, m_Pitch, TotalBytes); + HANDLE_PACKET_READ(ReadChar, m_Roll, TotalBytes); return TotalBytes; } @@ -31,9 +31,9 @@ void cPacket_PickupSpawn::Serialize(AString & a_Data) const { AppendByte (a_Data, m_PacketID); AppendInteger(a_Data, m_UniqueID); - AppendShort (a_Data, m_Item); - AppendByte (a_Data, m_Count); - AppendShort (a_Data, m_Health); + AppendShort (a_Data, m_ItemType); + AppendByte (a_Data, m_ItemCount); + AppendShort (a_Data, m_ItemDamage); AppendInteger(a_Data, m_PosX); AppendInteger(a_Data, m_PosY); AppendInteger(a_Data, m_PosZ); diff --git a/source/packets/cPacket_PickupSpawn.h b/source/packets/cPacket_PickupSpawn.h index ea004b730..91bbba65e 100644 --- a/source/packets/cPacket_PickupSpawn.h +++ b/source/packets/cPacket_PickupSpawn.h @@ -12,33 +12,34 @@ class cPacket_PickupSpawn : public cPacket public: cPacket_PickupSpawn() : m_UniqueID( 0 ) - , m_Item( 0 ) - , m_Count( 0 ) - , m_Health( 0 ) + , m_ItemType( 0 ) + , m_ItemCount( 0 ) + , m_ItemDamage( 0 ) , m_PosX( 0 ) , m_PosY( 0 ) , m_PosZ( 0 ) , m_Rotation( 0 ) , m_Pitch( 0 ) , m_Roll( 0 ) - { m_PacketID = E_PICKUP_SPAWN; } + { + m_PacketID = E_PICKUP_SPAWN; + } + virtual cPacket* Clone() const { return new cPacket_PickupSpawn(*this); } - virtual int Parse(cByteBuffer & a_Buffer) override; + virtual int Parse(cByteBuffer & a_Buffer) override; virtual void Serialize(AString & a_Data) const override; - int m_UniqueID; - short m_Item; - char m_Count; - short m_Health; - int m_PosX; - int m_PosY; - int m_PosZ; - char m_Rotation; - char m_Pitch; - char m_Roll; - - static const unsigned int c_Size = 1 + 4 + 2 + 1 + 2 + 4 + 4 + 4 + 1 + 1 + 1; + int m_UniqueID; + short m_ItemType; + char m_ItemCount; + short m_ItemDamage; + int m_PosX; + int m_PosY; + int m_PosZ; + char m_Rotation; + char m_Pitch; + char m_Roll; }; diff --git a/source/packets/cPacket_SpawnMob.cpp b/source/packets/cPacket_SpawnMob.cpp index 47339c7e0..e00952561 100644 --- a/source/packets/cPacket_SpawnMob.cpp +++ b/source/packets/cPacket_SpawnMob.cpp @@ -11,7 +11,6 @@ cPacket_SpawnMob::~cPacket_SpawnMob() { if( m_MetaData ) delete [] m_MetaData; - delete m_Pos; } @@ -21,7 +20,6 @@ cPacket_SpawnMob::~cPacket_SpawnMob() cPacket_SpawnMob::cPacket_SpawnMob() : m_UniqueID( 0 ) , m_Type( 0 ) - , m_Pos( new Vector3i() ) , m_Yaw( 0 ) , m_Pitch( 0 ) , m_MetaDataSize( 0 ) @@ -37,12 +35,10 @@ cPacket_SpawnMob::cPacket_SpawnMob() cPacket_SpawnMob::cPacket_SpawnMob( const cPacket_SpawnMob & a_Clone ) { - m_Pos = new Vector3i(); - m_PacketID = E_SPAWN_MOB; m_UniqueID = a_Clone.m_UniqueID; m_Type = a_Clone.m_Type; - *m_Pos = *a_Clone.m_Pos; + m_Pos = a_Clone.m_Pos; m_Yaw = a_Clone.m_Yaw; m_Pitch = a_Clone.m_Pitch; m_HeadYaw = a_Clone.m_HeadYaw; @@ -61,9 +57,9 @@ void cPacket_SpawnMob::Serialize(AString & a_Data) const AppendByte (a_Data, m_PacketID); AppendInteger (a_Data, m_UniqueID); AppendByte (a_Data, m_Type); - AppendInteger (a_Data, m_Pos->x); - AppendInteger (a_Data, m_Pos->y); - AppendInteger (a_Data, m_Pos->z); + AppendInteger (a_Data, m_Pos.x); + AppendInteger (a_Data, m_Pos.y); + AppendInteger (a_Data, m_Pos.z); AppendByte (a_Data, m_Yaw); AppendByte (a_Data, m_Pitch); AppendByte (a_Data, m_HeadYaw); diff --git a/source/packets/cPacket_SpawnMob.h b/source/packets/cPacket_SpawnMob.h index bc7fbe235..9661da771 100644 --- a/source/packets/cPacket_SpawnMob.h +++ b/source/packets/cPacket_SpawnMob.h @@ -2,18 +2,14 @@ #pragma once #include "cPacket.h" +#include "../Vector3i.h" -class Vector3i; - - - - - -class cPacket_SpawnMob : public cPacket +class cPacket_SpawnMob : + public cPacket { public: cPacket_SpawnMob(); @@ -23,15 +19,15 @@ public: virtual void Serialize(AString & a_Data) const override; - int m_UniqueID; - char m_Type; - Vector3i* m_Pos; - char m_Yaw; - char m_Pitch; - char m_HeadYaw; + int m_UniqueID; + char m_Type; + Vector3i m_Pos; + char m_Yaw; + char m_Pitch; + char m_HeadYaw; unsigned int m_MetaDataSize; - char * m_MetaData; + char * m_MetaData; }; diff --git a/source/packets/cPacket_UpdateSign.h b/source/packets/cPacket_UpdateSign.h index 110ae8253..0704a926a 100644 --- a/source/packets/cPacket_UpdateSign.h +++ b/source/packets/cPacket_UpdateSign.h @@ -18,7 +18,7 @@ public: m_PacketID = E_UPDATE_SIGN; } - virtual cPacket * Clone() const { return new cPacket_UpdateSign( *this ); } + virtual cPacket * Clone() const { return new cPacket_UpdateSign( *this); } virtual int Parse(cByteBuffer & a_Buffer) override; virtual void Serialize(AString & a_Data) const override; diff --git a/source/squirrelbindings/SquirrelBindings.cpp b/source/squirrelbindings/SquirrelBindings.cpp index 3d1f3ff30..206d8bbcd 100644 --- a/source/squirrelbindings/SquirrelBindings.cpp +++ b/source/squirrelbindings/SquirrelBindings.cpp @@ -65,8 +65,6 @@ void BindSquirrel(HSQUIRRELVM vm) .Func("GetUniqueID", &cEntity::GetUniqueID) .Func("IsDestroyed", &cEntity::IsDestroyed) .Func("Destroy", &cEntity::Destroy) - .Func("SpawnOn", &cEntity::SpawnOn) - ); ConstTable().Enum("MetaData", Enumeration()