flewkey/cuberite-2a
1
0
Fork 0
Code Releases Activity

Packet refactoring, phase two, partial. Rewritten a few packet handling functions not to use cPacket-descendant objects.

Browse Source 
This breaks plugin API! Plugins need to modify their hook functions to match those used in the Core plugin

git-svn-id: http://mc-server.googlecode.com/svn/trunk@750 0a769ca7-a7f5-676a-18bf-c427514a06d6
This commit is contained in:
madmaxoft@gmail.com 2012-08-18 09:56:28 +00:00
parent 2cae4b24d8
commit 2691e8daed
50 changed files with 2299 additions and 2704 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
Plugins/Core/onblockdig.lua
View File

@ -1,9 +1,8 @@
function OnBlockDig( Block, Player ) function OnBlockDig(Player, BlockX, BlockY, BlockZ, BlockFace, Status, OldBlockType, OldBlockMeta)
-- dont check if the direction is in the air -- dont check if the direction is in the air
if Block.m_Direction ~= -1 then if (BlockFace ~= -1) then
if( Player:HasPermission("core.build") == false ) then if (Player:HasPermission("core.build") == false) then
return true return true
end end
end end

111
Plugins/Core/onblockplace.lua
View File

@ -1,60 +1,63 @@
function OnBlockPlace( Block, Player ) function OnBlockPlace(Player, BlockX, BlockY, BlockZ, BlockFace, HeldItem)
-- dont check if the direction is in the air -- dont check if the direction is in the air
if Block.m_Direction ~= -1 then if (BlockFace == -1) then
return false
if( Player:HasPermission("core.build") == false ) then
return true
end
local X = Block.m_PosX
local Y = Block.m_PosY
local Z = Block.m_PosZ
X, Y, Z = AddDirection( X, Y, Z, Block.m_Direction )
if( Y >= 256 or Y < 0 ) then
return true
end
local CheckCollision = function( Player )
-- drop the decimals, we only care about the full block X,Y,Z
local PlayerX = math.floor(Player:GetPosX(), 0)
local PlayerY = math.floor(Player:GetPosY(), 0)
local PlayerZ = math.floor(Player:GetPosZ(), 0)
local BlockX = Block.m_PosX
local BlockY = Block.m_PosY
local BlockZ = Block.m_PosZ
-- player height is 2 blocks, so we check the position and then offset it up one
-- so they can't place a block on there face
local collision = false
if Block.m_Direction == 0 then if PlayerY == BlockY-2 and PlayerX == BlockX and PlayerZ == BlockZ then collision = true end end
if Block.m_Direction == 1 then if PlayerY == BlockY+1 and PlayerX == BlockX and PlayerZ == BlockZ then collision = true end end
if Block.m_Direction == 2 then if PlayerY == BlockY and PlayerX == BlockX and PlayerZ == BlockZ-1 then collision = true end end
if Block.m_Direction == 2 then if PlayerY+1 == BlockY and PlayerX == BlockX and PlayerZ == BlockZ-1 then collision = true end end
if Block.m_Direction == 3 then if PlayerY == BlockY and PlayerX == BlockX and PlayerZ == BlockZ+1 then collision = true end end
if Block.m_Direction == 3 then if PlayerY+1 == BlockY and PlayerX == BlockX and PlayerZ == BlockZ+1 then collision = true end end
if Block.m_Direction == 4 then if PlayerY == BlockY and PlayerX == BlockX-1 and PlayerZ == BlockZ then collision = true end end
if Block.m_Direction == 4 then if PlayerY+1 == BlockY and PlayerX == BlockX-1 and PlayerZ == BlockZ then collision = true end end
if Block.m_Direction == 5 then if PlayerY == BlockY and PlayerX == BlockX+1 and PlayerZ == BlockZ then collision = true end end
if Block.m_Direction == 5 then if PlayerY+1 == BlockY and PlayerX == BlockX+1 and PlayerZ == BlockZ then collision = true end end
return collision
end
if( Player:GetWorld():ForEachPlayer( CheckCollision ) == false ) then
return true
else
return false
end
end end
return false if( Player:HasPermission("core.build") == false ) then
return true
end
-- TODO: If the placed block is not a block (torch etc.), allow it without checking for collisions
local X = BlockX
local Y = BlockY
local Z = BlockZ
X, Y, Z = AddDirection(X, Y, Z, BlockFace)
if (Y >= 256 or Y < 0) then
return true
end
local CheckCollision = function(Player)
-- drop the decimals, we only care about the full block X,Y,Z
local PlayerX = math.floor(Player:GetPosX(), 0)
local PlayerY = math.floor(Player:GetPosY(), 0)
local PlayerZ = math.floor(Player:GetPosZ(), 0)
-- player height is 2 blocks, so we check the position and then offset it up one
-- so they can't place a block in anyone's face
local collision = false
if ((BlockFace == BLOCK_FACE_TOP) and (PlayerY == BlockY - 2) and (PlayerX == BlockX) and (PlayerZ == BlockZ)) then
collision = true
end
if ((BlockFace == BLOCK_FACE_BOTTOM) and (PlayerY == BlockY + 1) and (PlayerX == BlockX) and (PlayerZ == BlockZ)) then
collision = true
end
if ((BlockFace == BLOCK_FACE_NORTH) and (PlayerX == BlockX) and (PlayerZ == BlockZ - 1)) then
if ((PlayerY == BlockY) or (PlayerY + 1 == BlockY)) then collision = true end
end
if ((BlockFace == BLOCK_FACE_SOUTH) and (PlayerX == BlockX) and (PlayerZ == BlockZ + 1)) then
if ((PlayerY == BlockY) or (PlayerY + 1 == BlockY)) then collision = true end
end
if ((BlockFace == BLOCK_FACE_WEST) and (PlayerX == BlockX - 1) and (PlayerZ == BlockZ)) then
if ((PlayerY == BlockY) or (PlayerY + 1 == BlockY)) then collision = true end
end
if ((BlockFace == BLOCK_FACE_EAST) and (PlayerX == BlockX + 1) and (PlayerZ == BlockZ)) then
if ((PlayerY == BlockY) or (PlayerY + 1 == BlockY)) then collision = true end
end
return collision
end
if (Player:GetWorld():ForEachPlayer(CheckCollision) == false) then
return true
end
return false
end end

3
source/AllToLua.pkg
View File

@ -45,9 +45,6 @@ $cfile "cMCLogger.h"
$cfile "cTracer.h" $cfile "cTracer.h"
$cfile "cGroup.h" $cfile "cGroup.h"
$cfile "BlockArea.h" $cfile "BlockArea.h"
$cfile "packets/cPacket_Login.h"
$cfile "packets/cPacket_BlockDig.h"
$cfile "packets/cPacket_BlockPlace.h"
$cfile "cLuaChunk.h" $cfile "cLuaChunk.h"
$cfile "CraftingRecipes.h" $cfile "CraftingRecipes.h"
$cfile "LuaItems.h" $cfile "LuaItems.h"

3244
source/Bindings.cpp
View File

File diff suppressed because it is too large Load Diff

2
source/Bindings.h
View File

@ -1,6 +1,6 @@
/* /*
** Lua binding: AllToLua ** Lua binding: AllToLua
** Generated automatically by tolua++-1.0.92 on 08/11/12 21:48:17. ** Generated automatically by tolua++-1.0.92 on 08/18/12 11:57:21.
*/ */
/* Exported function */ /* Exported function */

14
source/ByteBuffer.cpp
View File

@ -292,6 +292,20 @@ bool cByteBuffer::ReadUTF16String(AString & a_String, int a_NumChars)
bool cByteBuffer::SkipRead(int a_Count)
{
if (!CanReadBytes(a_Count))
{
return false;
}
AdvanceReadPos(a_Count);
return true;
}
void cByteBuffer::CommitRead(void) void cByteBuffer::CommitRead(void)
{ {
m_DataStart = m_ReadPos; m_DataStart = m_ReadPos;

4
source/ByteBuffer.h
View File

@ -65,8 +65,8 @@ public:
/// Reads 2 * a_NumChars bytes and interprets it as a UTF16 string, converting it into UTF8 string a_String /// Reads 2 * a_NumChars bytes and interprets it as a UTF16 string, converting it into UTF8 string a_String
bool ReadUTF16String(AString & a_String, int a_NumChars); bool ReadUTF16String(AString & a_String, int a_NumChars);
/// Skips reading by a_Count bytes /// Skips reading by a_Count bytes; returns false if not enough bytes in the ringbuffer
void SkipRead(int a_Count); bool SkipRead(int a_Count);
/// Removes the bytes that have been read from the ringbuffer /// Removes the bytes that have been read from the ringbuffer
void CommitRead(void); void CommitRead(void);

14
source/Defines.h
View File

@ -11,7 +11,6 @@ extern unsigned char g_BlockSpreadLightFalloff[];
extern bool g_BlockTransparent[]; extern bool g_BlockTransparent[];
// one hit break blocks // one hit break blocks
extern bool g_BlockOneHitDig[]; extern bool g_BlockOneHitDig[];
//tolua_end
//--DO NOT DELETE THIS COMMENT-- //tolua_export //--DO NOT DELETE THIS COMMENT-- //tolua_export
@ -19,16 +18,27 @@ extern bool g_BlockOneHitDig[];
// Block face constants, used in PlayerDigging and PlayerBlockPlacement packets
enum enum
{ {
BLOCK_FACE_BOTTOM = 0, // Interacting with the bottom face of the block BLOCK_FACE_BOTTOM = 0, // Interacting with the bottom face of the block
BLOCK_FACE_TOP = 1, // Interacting with the top face of the block BLOCK_FACE_TOP = 1, // Interacting with the top face of the block
BLOCK_FACE_NORTH = 2, // Interacting with the northern face of the block BLOCK_FACE_NORTH = 2, // Interacting with the northern face of the block
BLOCK_FACE_SOUTH = 3, // Interacting with the southern face of the block BLOCK_FACE_SOUTH = 3, // Interacting with the southern face of the block
BLOCK_FACE_EAST = 5, // Interacting with the eastern face of the block
BLOCK_FACE_WEST = 4, // Interacting with the western face of the block BLOCK_FACE_WEST = 4, // Interacting with the western face of the block
BLOCK_FACE_EAST = 5, // Interacting with the eastern face of the block
} ; } ;
// PlayerDigging status constants:
enum
{
DIG_STATUS_STARTED = 0,
DIG_STATUS_FINISHED = 2,
DIG_STATUS_DROP_HELD = 4,
DIG_STATUS_SHOOT_EAT = 5,
} ;
//tolua_end

315
source/cClientHandle.cpp
View File

@ -66,6 +66,7 @@
#include "packets/cPacket_NamedEntitySpawn.h" #include "packets/cPacket_NamedEntitySpawn.h"
#include "packets/cPacket_MapChunk.h" #include "packets/cPacket_MapChunk.h"
#include "packets/cPacket_PreChunk.h" #include "packets/cPacket_PreChunk.h"
#include "packets/cPacket_InventorySlot.h"
// DEBUG: // DEBUG:
#include "packets/cPacket_BlockChange.h" #include "packets/cPacket_BlockChange.h"
@ -492,6 +493,11 @@ void cClientHandle::RemoveFromAllChunks()
void cClientHandle::HandlePacket(cPacket * a_Packet) void cClientHandle::HandlePacket(cPacket * a_Packet)
{ {
// TODO: _X: This function will get out-sourced into a separate cProtocol class
// and the switch statements will be split into virtual functions of that class
// Therefore I keep this function huge and untidy for the time being
// ( http://forum.mc-server.org/showthread.php?tid=524 )
m_TimeLastPacket = cWorld::GetTime(); m_TimeLastPacket = cWorld::GetTime();
// LOG("Recv packet 0x%02x from client \"%s\" (\"%s\")", a_Packet->m_PacketID, m_Socket.GetIPString().c_str(), m_Username.c_str()); // LOG("Recv packet 0x%02x from client \"%s\" (\"%s\")", a_Packet->m_PacketID, m_Socket.GetIPString().c_str(), m_Username.c_str());
@ -513,8 +519,18 @@ void cClientHandle::HandlePacket(cPacket * a_Packet)
break; break;
} }
case E_PING: HandlePing (); break; case E_PING: HandlePing (); break;
case E_HANDSHAKE: HandleHandshake(reinterpret_cast<cPacket_Handshake *>(a_Packet)); break; case E_HANDSHAKE:
case E_LOGIN: HandleLogin (reinterpret_cast<cPacket_Login *> (a_Packet)); break; {
cPacket_Handshake * Handshake = reinterpret_cast<cPacket_Handshake *>(a_Packet);
HandleHandshake(Handshake->m_Username);
break;
}
case E_LOGIN:
{
cPacket_Login * Login = reinterpret_cast<cPacket_Login *>(a_Packet);
HandleLogin(Login->m_ProtocolVersion, Login->m_Username);
break;
}
// Ignored packets: // Ignored packets:
case E_PLAYERLOOK: case E_PLAYERLOOK:
@ -522,7 +538,7 @@ void cClientHandle::HandlePacket(cPacket * a_Packet)
case E_PLAYERMOVELOOK: case E_PLAYERMOVELOOK:
case E_PLAYERPOS: case E_PLAYERPOS:
case E_KEEP_ALIVE: break; case E_KEEP_ALIVE: break;
default: HandleUnexpectedPacket(a_Packet); break; default: HandleUnexpectedPacket(a_Packet->m_PacketID); break;
} // switch (PacketType) } // switch (PacketType)
break; break;
} // case csConnected } // case csConnected
@ -540,7 +556,7 @@ void cClientHandle::HandlePacket(cPacket * a_Packet)
case E_PLAYERMOVELOOK: case E_PLAYERMOVELOOK:
case E_PLAYERPOS: break; case E_PLAYERPOS: break;
default: HandleUnexpectedPacket(a_Packet); break; default: HandleUnexpectedPacket(a_Packet->m_PacketID); break;
} }
break; break;
} }
@ -558,7 +574,7 @@ void cClientHandle::HandlePacket(cPacket * a_Packet)
case E_PLAYERMOVELOOK: case E_PLAYERMOVELOOK:
case E_PLAYERPOS: break; case E_PLAYERPOS: break;
default: HandleUnexpectedPacket(a_Packet); break; default: HandleUnexpectedPacket(a_Packet->m_PacketID); break;
} }
break; break;
} }
@ -574,11 +590,16 @@ void cClientHandle::HandlePacket(cPacket * a_Packet)
case E_PLAYERLOOK: case E_PLAYERLOOK:
case E_PLAYERPOS: break; case E_PLAYERPOS: break;
case E_PLAYERMOVELOOK: HandleMoveLookConfirm(reinterpret_cast<cPacket_PlayerMoveLook *>(a_Packet)); break; case E_PLAYERMOVELOOK:
{
cPacket_PlayerMoveLook * MoveLook = reinterpret_cast<cPacket_PlayerMoveLook *>(a_Packet);
HandleMoveLookConfirm(MoveLook->m_PosX, MoveLook->m_PosY, MoveLook->m_PosZ);
break;
}
default: default:
{ {
HandleUnexpectedPacket(a_Packet); HandleUnexpectedPacket(a_Packet->m_PacketID);
break; break;
} }
} // switch (PacketType) } // switch (PacketType)
@ -589,10 +610,30 @@ void cClientHandle::HandlePacket(cPacket * a_Packet)
{ {
switch (a_Packet->m_PacketID) switch (a_Packet->m_PacketID)
{ {
case E_CREATIVE_INVENTORY_ACTION: HandleCreativeInventory(reinterpret_cast<cPacket_CreativeInventoryAction *>(a_Packet)); break; case E_CREATIVE_INVENTORY_ACTION:
case E_PLAYERPOS: HandlePlayerPos (reinterpret_cast<cPacket_PlayerPosition *> (a_Packet)); break; {
case E_BLOCK_DIG: HandleBlockDig (reinterpret_cast<cPacket_BlockDig *> (a_Packet)); break; cPacket_CreativeInventoryAction * cia = reinterpret_cast<cPacket_CreativeInventoryAction *>(a_Packet);
case E_BLOCK_PLACE: HandleBlockPlace (reinterpret_cast<cPacket_BlockPlace *> (a_Packet)); break; HandleCreativeInventory(cia->m_SlotNum, cia->m_ClickedItem);
break;
}
case E_PLAYERPOS:
{
cPacket_PlayerPosition * pp = reinterpret_cast<cPacket_PlayerPosition *>(a_Packet);
HandlePlayerPos(pp->m_PosX, pp->m_PosY, pp->m_PosZ, pp->m_Stance, pp->m_IsOnGround);
break;
}
case E_BLOCK_DIG:
{
cPacket_BlockDig * bd = reinterpret_cast<cPacket_BlockDig *>(a_Packet);
HandleBlockDig(bd->m_PosX, bd->m_PosY, bd->m_PosZ, bd->m_Direction, bd->m_Status);
break;
}
case E_BLOCK_PLACE:
{
cPacket_BlockPlace * bp = reinterpret_cast<cPacket_BlockPlace *>(a_Packet);
HandleBlockPlace(bp->m_PosX, bp->m_PosY, bp->m_PosZ, bp->m_Direction, bp->m_HeldItem);
break;
}
case E_PICKUP_SPAWN: HandlePickupSpawn (reinterpret_cast<cPacket_PickupSpawn *> (a_Packet)); break; case E_PICKUP_SPAWN: HandlePickupSpawn (reinterpret_cast<cPacket_PickupSpawn *> (a_Packet)); break;
case E_CHAT: HandleChat (reinterpret_cast<cPacket_Chat *> (a_Packet)); break; case E_CHAT: HandleChat (reinterpret_cast<cPacket_Chat *> (a_Packet)); break;
case E_PLAYERLOOK: HandlePlayerLook (reinterpret_cast<cPacket_PlayerLook *> (a_Packet)); break; case E_PLAYERLOOK: HandlePlayerLook (reinterpret_cast<cPacket_PlayerLook *> (a_Packet)); break;
@ -600,7 +641,12 @@ void cClientHandle::HandlePacket(cPacket * a_Packet)
case E_ANIMATION: HandleAnimation (reinterpret_cast<cPacket_ArmAnim *> (a_Packet)); break; case E_ANIMATION: HandleAnimation (reinterpret_cast<cPacket_ArmAnim *> (a_Packet)); break;
case E_ITEM_SWITCH: HandleItemSwitch (reinterpret_cast<cPacket_ItemSwitch *> (a_Packet)); break; case E_ITEM_SWITCH: HandleItemSwitch (reinterpret_cast<cPacket_ItemSwitch *> (a_Packet)); break;
case E_WINDOW_CLOSE: HandleWindowClose (reinterpret_cast<cPacket_WindowClose *> (a_Packet)); break; case E_WINDOW_CLOSE: HandleWindowClose (reinterpret_cast<cPacket_WindowClose *> (a_Packet)); break;
case E_WINDOW_CLICK: HandleWindowClick (reinterpret_cast<cPacket_WindowClick *> (a_Packet)); break; case E_WINDOW_CLICK:
{
cPacket_WindowClick * wc = reinterpret_cast<cPacket_WindowClick *>(a_Packet);
HandleWindowClick(wc->m_WindowID, wc->m_SlotNum, wc->m_IsRightClick, wc->m_IsShiftPressed, wc->m_HeldItem);
break;
}
case E_UPDATE_SIGN: HandleUpdateSign (reinterpret_cast<cPacket_UpdateSign *> (a_Packet)); break; case E_UPDATE_SIGN: HandleUpdateSign (reinterpret_cast<cPacket_UpdateSign *> (a_Packet)); break;
case E_USE_ENTITY: HandleUseEntity (reinterpret_cast<cPacket_UseEntity *> (a_Packet)); break; case E_USE_ENTITY: HandleUseEntity (reinterpret_cast<cPacket_UseEntity *> (a_Packet)); break;
case E_RESPAWN: HandleRespawn(); break; case E_RESPAWN: HandleRespawn(); break;
@ -634,17 +680,17 @@ void cClientHandle::HandlePing(void)
void cClientHandle::HandleHandshake(cPacket_Handshake * a_Packet) void cClientHandle::HandleHandshake(const AString & a_Username)
{ {
AStringVector UserData = StringSplit( a_Packet->m_Username, ";" ); // "FakeTruth;localhost:25565" AStringVector UserData = StringSplit(a_Username, ";"); // "FakeTruth;localhost:25565"
if( UserData.size() == 0 ) if (UserData.empty())
{ {
Kick("Could not receive username"); Kick("Did not receive username");
return; return;
} }
m_Username = UserData[0]; m_Username = UserData[0];
LOG("HANDSHAKE %s", m_Username.c_str()); LOGD("HANDSHAKE %s", m_Username.c_str());
if (cRoot::Get()->GetDefaultWorld()->GetNumPlayers() >= cRoot::Get()->GetDefaultWorld()->GetMaxPlayers()) if (cRoot::Get()->GetDefaultWorld()->GetNumPlayers() >= cRoot::Get()->GetDefaultWorld()->GetMaxPlayers())
{ {
@ -654,9 +700,7 @@ void cClientHandle::HandleHandshake(cPacket_Handshake * a_Packet)
cPacket_Chat Connecting(m_Username + " is connecting."); cPacket_Chat Connecting(m_Username + " is connecting.");
cRoot::Get()->GetServer()->Broadcast(Connecting, this); cRoot::Get()->GetServer()->Broadcast(Connecting, this);
cPacket_Handshake Handshake; SendHandshake(cRoot::Get()->GetServer()->GetServerID());
Handshake.m_Username = cRoot::Get()->GetServer()->GetServerID();
Send(Handshake);
LOG("User \"%s\" was sent a handshake", m_Username.c_str()); LOG("User \"%s\" was sent a handshake", m_Username.c_str());
} }
@ -664,23 +708,23 @@ void cClientHandle::HandleHandshake(cPacket_Handshake * a_Packet)
void cClientHandle::HandleLogin(cPacket_Login * a_Packet) void cClientHandle::HandleLogin(int a_ProtocolVersion, const AString & a_Username)
{ {
LOG("LOGIN %s", m_Username.c_str()); LOGD("LOGIN %s", a_Username.c_str());
if (a_Packet->m_ProtocolVersion < m_ProtocolVersion) if (a_ProtocolVersion < m_ProtocolVersion)
{ {
Kick("Your client is outdated!"); Kick("Your client is outdated!");
return; return;
} }
else if (a_Packet->m_ProtocolVersion > m_ProtocolVersion) else if (a_ProtocolVersion > m_ProtocolVersion)
{ {
Kick("Your client version is higher than the server!"); Kick("Your client version is higher than the server!");
return; return;
} }
if (m_Username.compare(a_Packet->m_Username) != 0) if (m_Username.compare(a_Username) != 0)
{ {
LOGWARNING("Login Username (\"%s\") does not match Handshake username (\"%s\") for client \"%s\")", LOGWARNING("Login Username (\"%s\") does not match Handshake username (\"%s\") for client @ \"%s\")",
a_Packet->m_Username.c_str(), a_Username.c_str(),
m_Username.c_str(), m_Username.c_str(),
m_Socket.GetIPString().c_str() m_Socket.GetIPString().c_str()
); );
@ -688,7 +732,7 @@ void cClientHandle::HandleLogin(cPacket_Login * a_Packet)
return; return;
} }
if (cRoot::Get()->GetPluginManager()->CallHook(cPluginManager::HOOK_LOGIN, 1, a_Packet)) if (cRoot::Get()->GetPluginManager()->CallHookLogin(this, a_ProtocolVersion, a_Username))
{ {
Destroy(); Destroy();
return; return;
@ -703,12 +747,12 @@ void cClientHandle::HandleLogin(cPacket_Login * a_Packet)
void cClientHandle::HandleUnexpectedPacket(cPacket * a_Packet) void cClientHandle::HandleUnexpectedPacket(int a_PacketType)
{ {
LOGWARNING( LOGWARNING(
"Invalid packet in state %d: 0x%02x from client \"%s\", username \"%s\"", "Invalid packet in state %d: 0x%02x from client \"%s\", username \"%s\"",
m_State, m_State,
a_Packet->m_PacketID, a_PacketType,
m_Socket.GetIPString().c_str(), m_Socket.GetIPString().c_str(),
m_Username.c_str() m_Username.c_str()
); );
@ -719,9 +763,9 @@ void cClientHandle::HandleUnexpectedPacket(cPacket * a_Packet)
void cClientHandle::HandleMoveLookConfirm(cPacket_PlayerMoveLook * a_Packet) void cClientHandle::HandleMoveLookConfirm(double a_PosX, double a_PosY, double a_PosZ)
{ {
Vector3d ReceivedPosition = Vector3d(a_Packet->m_PosX, a_Packet->m_PosY, a_Packet->m_PosZ); Vector3d ReceivedPosition = Vector3d(a_PosX, a_PosY, a_PosZ);
// Test the distance between points with a small/large enough value instead of comparing directly. Floating point inaccuracies might screw stuff up // Test the distance between points with a small/large enough value instead of comparing directly. Floating point inaccuracies might screw stuff up
double Dist = (ReceivedPosition - m_ConfirmPosition).SqrLength(); double Dist = (ReceivedPosition - m_ConfirmPosition).SqrLength();
@ -746,12 +790,12 @@ void cClientHandle::HandleMoveLookConfirm(cPacket_PlayerMoveLook * a_Packet)
void cClientHandle::HandleCreativeInventory(cPacket_CreativeInventoryAction * a_Packet) void cClientHandle::HandleCreativeInventory(short a_SlotNum, const cItem & a_HeldItem)
{ {
// This is for creative Inventory changes // This is for creative Inventory changes
if (m_Player->GetGameMode() == 1) if (m_Player->GetGameMode() == 1)
{ {
m_Player->GetInventory().Clicked(a_Packet); m_Player->GetInventory().Clicked(a_SlotNum, false, false, a_HeldItem);
} }
else else
{ {
@ -763,84 +807,86 @@ void cClientHandle::HandleCreativeInventory(cPacket_CreativeInventoryAction * a_
void cClientHandle::HandlePlayerPos(cPacket_PlayerPosition * a_Packet) void cClientHandle::HandlePlayerPos(double a_PosX, double a_PosY, double a_PosZ, double a_Stance, bool a_IsOnGround)
{ {
// LOG("recv player pos: %0.2f %0.2f %0.2f", PacketData->m_PosX, PacketData->m_PosY, PacketData->m_PosZ); // LOG("recv player pos: %0.2f %0.2f %0.2f", PacketData->m_PosX, PacketData->m_PosY, PacketData->m_PosZ);
m_Player->MoveTo(Vector3d(a_Packet->m_PosX, a_Packet->m_PosY, a_Packet->m_PosZ)); m_Player->MoveTo(Vector3d(a_PosX, a_PosY, a_PosZ));
m_Player->SetStance(a_Packet->m_Stance); m_Player->SetStance(a_Stance);
m_Player->SetTouchGround(a_Packet->m_bFlying); m_Player->SetTouchGround(a_IsOnGround);
} }
void cClientHandle::HandleBlockDig(cPacket_BlockDig * a_Packet) void cClientHandle::HandleBlockDig(int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, char a_Status)
{ {
if (!CheckBlockInteractionsRate()) if (!CheckBlockInteractionsRate())
{ {
return; return;
} }
LOGD("OnBlockDig: {%i, %i, %i} Dir: %i Stat: %i", LOGD("OnBlockDig: {%i, %i, %i}; Face: %i; Stat: %i",
a_Packet->m_PosX, a_Packet->m_PosY, a_Packet->m_PosZ, a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, a_Status
a_Packet->m_Direction, a_Packet->m_Status
); );
// Do we want plugins to disable tossing items? Probably no, so toss item before asking plugins for permission // Do we want plugins to disable tossing items? Probably no, so toss item before asking plugins for permission
if (a_Packet->m_Status == 0x04) // Drop held item if (a_Status == DIG_STATUS_DROP_HELD) // Drop held item
{ {
m_Player->TossItem(false); m_Player->TossItem(false);
return; return;
} }
if (a_Packet->m_Status == 0x05) if (a_Status == DIG_STATUS_SHOOT_EAT)
{ {
LOGINFO("BlockDig: Status 5 not implemented"); LOGINFO("BlockDig: Status SHOOT/EAT not implemented");
return;
} }
cWorld* World = m_Player->GetWorld(); cWorld * World = m_Player->GetWorld();
BLOCKTYPE OldBlock = World->GetBlock(a_Packet->m_PosX, a_Packet->m_PosY, a_Packet->m_PosZ); BLOCKTYPE OldBlock;
NIBBLETYPE OldMeta = World->GetBlockMeta(a_Packet->m_PosX, a_Packet->m_PosY, a_Packet->m_PosZ); NIBBLETYPE OldMeta;
World->GetBlockTypeMeta(a_BlockX, a_BlockY, a_BlockZ, OldBlock, OldMeta);
if (cRoot::Get()->GetPluginManager()->CallHook(cPluginManager::HOOK_BLOCK_DIG, 4, a_Packet, m_Player, OldBlock, OldMeta)) if (cRoot::Get()->GetPluginManager()->CallHookBlockDig(m_Player, a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, a_Status, OldBlock, OldMeta))
{ {
// The plugin doesn't agree with the digging, replace the block on the client and quit: // The plugin doesn't agree with the digging, replace the block on the client and quit:
World->SendBlockTo(a_Packet->m_PosX, a_Packet->m_PosY, a_Packet->m_PosZ, m_Player); World->SendBlockTo(a_BlockX, a_BlockY, a_BlockZ, m_Player);
return; return;
} }
bool bBroken = ( bool bBroken = (
(a_Packet->m_Status == 0x02) || (a_Status == DIG_STATUS_FINISHED) ||
(g_BlockOneHitDig[(int)OldBlock]) || (g_BlockOneHitDig[(int)OldBlock]) ||
((a_Packet->m_Status == 0x00) && (m_Player->GetGameMode() == 1)) ((a_Status == DIG_STATUS_STARTED) && (m_Player->GetGameMode() == 1))
); );
cItem &Equipped = m_Player->GetInventory().GetEquippedItem(); cItem & Equipped = m_Player->GetInventory().GetEquippedItem();
cItemHandler * ItemHandler = cItemHandler::GetItemHandler(Equipped.m_ItemID);
cItemHandler *ItemHandler = cItemHandler::GetItemHandler(Equipped.m_ItemID); if (bBroken)
if(bBroken)
{ {
ItemHandler->OnBlockDestroyed(World, m_Player, &Equipped, a_Packet->m_PosX, a_Packet->m_PosY, a_Packet->m_PosZ); ItemHandler->OnBlockDestroyed(World, m_Player, &Equipped, a_BlockX, a_BlockY, a_BlockZ);
BlockHandler(OldBlock)->OnDestroyedByPlayer(World, m_Player, a_Packet->m_PosX, a_Packet->m_PosY, a_Packet->m_PosZ); BlockHandler(OldBlock)->OnDestroyedByPlayer(World, m_Player, a_BlockX, a_BlockY, a_BlockZ);
World->DigBlock(a_Packet->m_PosX, a_Packet->m_PosY, a_Packet->m_PosZ); World->DigBlock(a_BlockX, a_BlockY, a_BlockZ);
}else{ }
cBlockHandler *Handler = cBlockHandler::GetBlockHandler(OldBlock); else
Handler->OnClick(World, m_Player, a_Packet->m_PosX, a_Packet->m_PosY, a_Packet->m_PosZ); {
cBlockHandler * Handler = cBlockHandler::GetBlockHandler(OldBlock);
Handler->OnClick(World, m_Player, a_BlockX, a_BlockY, a_BlockZ);
ItemHandler->OnDiggingBlock(World, m_Player, &Equipped, a_Packet->m_PosX, a_Packet->m_PosY, a_Packet->m_PosZ, a_Packet->m_Direction); ItemHandler->OnDiggingBlock(World, m_Player, &Equipped, a_BlockX, a_BlockY, a_BlockZ, a_BlockFace);
//Check for clickthrough-blocks: // Check for clickthrough-blocks:
int pX = a_Packet->m_PosX; int pX = a_BlockX;
unsigned char pY = a_Packet->m_PosY; unsigned char pY = a_BlockY;
int pZ = a_Packet->m_PosZ; int pZ = a_BlockZ;
AddDirection(pX, pY, pZ, a_Packet->m_Direction); AddDirection(pX, pY, pZ, a_BlockFace);
Handler = cBlockHandler::GetBlockHandler(World->GetBlock(pX, pY, pZ)); Handler = cBlockHandler::GetBlockHandler(World->GetBlock(pX, pY, pZ));
if(Handler->IsClickedThrough()) if (Handler->IsClickedThrough())
{ {
Handler->OnClick(World, m_Player, pX, pY, pZ); Handler->OnClick(World, m_Player, pX, pY, pZ);
} }
@ -851,9 +897,8 @@ void cClientHandle::HandleBlockDig(cPacket_BlockDig * a_Packet)
void cClientHandle::HandleBlockPlace(cPacket_BlockPlace * a_Packet) void cClientHandle::HandleBlockPlace(int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, const cItem & a_HeldItem)
{ {
if (!CheckBlockInteractionsRate()) if (!CheckBlockInteractionsRate())
{ {
return; return;
@ -861,94 +906,105 @@ void cClientHandle::HandleBlockPlace(cPacket_BlockPlace * a_Packet)
cItem & Equipped = m_Player->GetInventory().GetEquippedItem(); cItem & Equipped = m_Player->GetInventory().GetEquippedItem();
if ((Equipped.m_ItemID != a_Packet->m_ItemType)) // Not valid if ((Equipped.m_ItemID != a_HeldItem.m_ItemType)) // Not valid
{ {
LOGWARN("Player %s tried to place a block that was not equipped (exp %d, got %d)", LOGWARN("Player %s tried to place a block that was not equipped (exp %d, got %d)",
m_Username.c_str(), Equipped.m_ItemID, a_Packet->m_ItemType m_Username.c_str(), Equipped.m_ItemType, a_HeldItem.m_ItemType
); );
// TODO: We should probably send the current world block to the client, so that it can immediately "let the user know" that they haven't placed the block
// Let's send the current world block to the client, so that it can immediately "let the user know" that they haven't placed the block
if (a_BlockFace > -1)
{
AddDirection(a_BlockX, a_BlockY, a_BlockZ, a_BlockFace);
m_Player->GetWorld()->SendBlockTo(a_BlockX, a_BlockY, a_BlockZ, m_Player);
}
return; return;
} }
if (cRoot::Get()->GetPluginManager()->CallHook(cPluginManager::HOOK_BLOCK_PLACE, 2, a_Packet, m_Player)) if (cRoot::Get()->GetPluginManager()->CallHookBlockPlace(m_Player, a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, a_HeldItem))
{ {
if (a_Packet->m_Direction > -1) if (a_BlockFace > -1)
{ {
AddDirection(a_Packet->m_PosX, a_Packet->m_PosY, a_Packet->m_PosZ, a_Packet->m_Direction); AddDirection(a_BlockX, a_BlockY, a_BlockZ, a_BlockFace);
m_Player->GetWorld()->SendBlockTo(a_Packet->m_PosX, a_Packet->m_PosY, a_Packet->m_PosZ, m_Player); m_Player->GetWorld()->SendBlockTo(a_BlockX, a_BlockY, a_BlockZ, m_Player);
} }
return; return;
} }
cWorld * World = m_Player->GetWorld(); cWorld * World = m_Player->GetWorld();
cBlockHandler *Handler = cBlockHandler::GetBlockHandler(World->GetBlock(a_Packet->m_PosX, a_Packet->m_PosY, a_Packet->m_PosZ)); cBlockHandler *Handler = cBlockHandler::GetBlockHandler(World->GetBlock(a_BlockX, a_BlockY, a_BlockZ));
if (Handler->IsUseable()) if (Handler->IsUseable())
{ {
Handler->OnClick(World, m_Player, a_Packet->m_PosX, a_Packet->m_PosY, a_Packet->m_PosZ); Handler->OnClick(World, m_Player, a_BlockX, a_BlockY, a_BlockZ);
} }
else else
{ {
cItemHandler *ItemHandler = cItemHandler::GetItemHandler(Equipped.m_ItemID); cItemHandler * ItemHandler = cItemHandler::GetItemHandler(Equipped.m_ItemID);
if(ItemHandler->OnItemUse(World, m_Player, &Equipped, a_Packet->m_PosX, a_Packet->m_PosY, a_Packet->m_PosZ, a_Packet->m_Direction)) if (ItemHandler->OnItemUse(World, m_Player, &Equipped, a_BlockX, a_BlockY, a_BlockZ, a_BlockFace))
{ {
//Nothing here :P // Nothing here :P
}else if(ItemHandler->IsPlaceable()) }
else if (ItemHandler->IsPlaceable())
{ {
if (a_Packet->m_Direction < 0) if (a_BlockFace < 0)
{ {
// clicked in air // clicked in air
return; return;
} }
int X = a_Packet->m_PosX; BLOCKTYPE ClickedBlock = World->GetBlock(a_BlockX, a_BlockY, a_BlockZ);
int Y = a_Packet->m_PosY;
int Z = a_Packet->m_PosZ;
char Dir = a_Packet->m_Direction;
BLOCKTYPE ClickedBlock = World->GetBlock(X, Y, Z);
cBlockHandler *Handler = cBlockHandler::GetBlockHandler(ClickedBlock); cBlockHandler *Handler = cBlockHandler::GetBlockHandler(ClickedBlock);
if(Handler->IgnoreBuildCollision()) if(Handler->IgnoreBuildCollision())
{ {
Handler->OnDestroyedByPlayer(World, m_Player, X, Y, Z); Handler->OnDestroyedByPlayer(World, m_Player, a_BlockX, a_BlockY, a_BlockZ);
World->FastSetBlock(X, Y, Z, E_BLOCK_AIR, 0); World->FastSetBlock(a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_AIR, 0);
}else{ }
AddDirection(X, Y, Z, a_Packet->m_Direction); else
//Check for Blocks not allowing placement on top {
if(Dir == 1 && !Handler->AllowBlockOnTop()) AddDirection(a_BlockX, a_BlockY, a_BlockZ, a_BlockFace);
// Check for Blocks not allowing placement on top
if ((a_BlockFace == BLOCK_FACE_TOP) && !Handler->AllowBlockOnTop())
{ {
//Resend the old block // Resend the old block
//Some times the client still places the block O.o // Some times the client still places the block O.o
World->SendBlockTo(X, Y, Z, m_Player); World->SendBlockTo(a_BlockX, a_BlockY, a_BlockZ, m_Player);
return; return;
} }
int PlaceBlock = m_Player->GetWorld()->GetBlock(X, Y, Z); int PlaceBlock = m_Player->GetWorld()->GetBlock(a_BlockX, a_BlockY, a_BlockZ);
if (!BlockHandler(PlaceBlock)->IgnoreBuildCollision()) if (!BlockHandler(PlaceBlock)->IgnoreBuildCollision())
{ {
//tried to place a block *into* another? // Tried to place a block *into* another?
return; // happens when you place a block aiming at side of block like torch or stem return; // Happens when you place a block aiming at side of block like torch or stem
} }
} }
cBlockHandler *NewBlock = BlockHandler(ItemHandler->GetBlockType()); cBlockHandler * NewBlock = BlockHandler(ItemHandler->GetBlockType());
//cannot be placed on the side of an other block // Cannot be placed on the side of an other block
if(Dir != 1 && !NewBlock->CanBePlacedOnSide()) if ((a_BlockFace != BLOCK_FACE_TOP) && !NewBlock->CanBePlacedOnSide())
return;
if(NewBlock->CanBePlacedAt(World, X, Y, Z, Dir))
{ {
ItemHandler->PlaceBlock(World, m_Player, &m_Player->GetInventory().GetEquippedItem(), X, Y, Z, a_Packet->m_Direction);
}else{
World->SendBlockTo(X, Y, Z, m_Player); //Send the old block back to the player
return; return;
} }
} else if(ItemHandler->IsFood()) { if (NewBlock->CanBePlacedAt(World, a_BlockX, a_BlockY, a_BlockZ, a_BlockFace))
{
ItemHandler->PlaceBlock(World, m_Player, &m_Player->GetInventory().GetEquippedItem(), a_BlockX, a_BlockY, a_BlockZ, a_BlockFace);
}
else
{
World->SendBlockTo(a_BlockX, a_BlockY, a_BlockZ, m_Player); // Send the old block back to the player
return;
}
}
else if (ItemHandler->IsFood())
{
cItem Item; cItem Item;
Item.m_ItemID = Equipped.m_ItemID; Item.m_ItemID = Equipped.m_ItemID;
Item.m_ItemCount = 1; Item.m_ItemCount = 1;
@ -1058,11 +1114,11 @@ void cClientHandle::HandleWindowClose(cPacket_WindowClose * a_Packet)
void cClientHandle::HandleWindowClick(cPacket_WindowClick * a_Packet) void cClientHandle::HandleWindowClick(int a_WindowID, short a_SlotNum, bool a_IsRightClick, bool a_IsShiftPressed, const cItem & a_HeldItem)
{ {
if (a_Packet->m_WindowID == 0) if (a_WindowID == 0)
{ {
m_Player->GetInventory().Clicked(a_Packet); m_Player->GetInventory().Clicked(a_SlotNum, a_IsRightClick, a_IsShiftPressed, a_HeldItem);
return; return;
} }
@ -1073,7 +1129,7 @@ void cClientHandle::HandleWindowClick(cPacket_WindowClick * a_Packet)
return; return;
} }
Window->Clicked(a_Packet, *m_Player); Window->Clicked(*m_Player, a_WindowID, a_SlotNum, a_IsRightClick, a_IsShiftPressed, a_HeldItem);
} }
@ -1361,7 +1417,32 @@ void cClientHandle::Send(const cPacket & a_Packet, ENUM_PRIORITY a_Priority /* =
void cClientHandle::SendDisconnect(const AString & a_Reason) void cClientHandle::SendDisconnect(const AString & a_Reason)
{ {
cPacket_Disconnect DC(a_Reason); cPacket_Disconnect DC(a_Reason);
m_Socket.Send(&DC); m_Socket.Send(&DC); // Send it immediately to the socket, bypassing any packet buffers
}
void cClientHandle::SendHandshake(const AString & a_ServerName)
{
cPacket_Handshake Handshake;
Handshake.m_Username = a_ServerName;
Send(Handshake);
}
void cClientHandle::SendInventorySlot(int a_WindowID, short a_SlotNum, const cItem & a_Item)
{
cPacket_InventorySlot Packet;
Packet.m_WindowID = (char)a_WindowID;
Packet.m_SlotNum = a_SlotNum;
Packet.m_ItemID = (short)(a_Item.m_ItemID);
Packet.m_ItemCount = a_Item.m_ItemCount;
Packet.m_ItemUses = a_Item.m_ItemHealth;
} }

20
source/cClientHandle.h
View File

@ -103,6 +103,8 @@ public:
void Send(const cPacket & a_Packet, ENUM_PRIORITY a_Priority = E_PRIORITY_NORMAL); void Send(const cPacket & a_Packet, ENUM_PRIORITY a_Priority = E_PRIORITY_NORMAL);
void SendDisconnect(const AString & a_Reason); void SendDisconnect(const AString & a_Reason);
void SendHandshake (const AString & a_ServerName);
void SendInventorySlot(int a_WindowID, short a_SlotNum, const cItem & a_Item);
const AString & GetUsername(void) const; //tolua_export const AString & GetUsername(void) const; //tolua_export
@ -182,18 +184,18 @@ private:
// Packets handled in csConnected: // Packets handled in csConnected:
void HandlePing (void); void HandlePing (void);
void HandleHandshake (cPacket_Handshake * a_Packet); void HandleHandshake (const AString & a_Username);
void HandleLogin (cPacket_Login * a_Packet); void HandleLogin (int a_ProtocolVersion, const AString & a_Username);
void HandleUnexpectedPacket(cPacket * a_Packet); // the default case -> kick void HandleUnexpectedPacket(int a_PacketType); // the default case -> kick
// Packets handled while in csConfirmingPos: // Packets handled while in csConfirmingPos:
void HandleMoveLookConfirm(cPacket_PlayerMoveLook * a_Packet); // While !m_bPositionConfirmed void HandleMoveLookConfirm(double a_PosX, double a_PosY, double a_PosZ); // While !m_bPositionConfirmed
// Packets handled while in csPlaying: // Packets handled while in csPlaying:
void HandleCreativeInventory(cPacket_CreativeInventoryAction * a_Packet); void HandleCreativeInventory(short a_SlotNum, const cItem & a_HeldItem);
void HandlePlayerPos (cPacket_PlayerPosition * a_Packet); void HandlePlayerPos (double a_PosX, double a_PosY, double a_PosZ, double a_Stance, bool a_IsOnGround);
void HandleBlockDig (cPacket_BlockDig * a_Packet); void HandleBlockDig (int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, char a_Status);
void HandleBlockPlace (cPacket_BlockPlace * a_Packet); void HandleBlockPlace (int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, const cItem & a_HeldItem);
void HandlePickupSpawn (cPacket_PickupSpawn * a_Packet); void HandlePickupSpawn (cPacket_PickupSpawn * a_Packet);
void HandleChat (cPacket_Chat * a_Packet); void HandleChat (cPacket_Chat * a_Packet);
void HandlePlayerLook (cPacket_PlayerLook * a_Packet); void HandlePlayerLook (cPacket_PlayerLook * a_Packet);
@ -201,7 +203,7 @@ private:
void HandleAnimation (cPacket_ArmAnim * a_Packet); void HandleAnimation (cPacket_ArmAnim * a_Packet);
void HandleItemSwitch (cPacket_ItemSwitch * a_Packet); void HandleItemSwitch (cPacket_ItemSwitch * a_Packet);
void HandleWindowClose (cPacket_WindowClose * a_Packet); void HandleWindowClose (cPacket_WindowClose * a_Packet);
void HandleWindowClick (cPacket_WindowClick * a_Packet); void HandleWindowClick (int a_WindowID, short a_SlotNum, bool a_IsRightClick, bool a_IsShiftPressed, const cItem & a_HeldItem);
void HandleUpdateSign (cPacket_UpdateSign * a_Packet); void HandleUpdateSign (cPacket_UpdateSign * a_Packet);
void HandleUseEntity (cPacket_UseEntity * a_Packet); void HandleUseEntity (cPacket_UseEntity * a_Packet);
void HandleRespawn (void); void HandleRespawn (void);

61
source/cCraftingWindow.cpp
View File

@ -10,9 +10,7 @@
#include "cPickup.h" #include "cPickup.h"
#include "cRoot.h" #include "cRoot.h"
#include "cWorld.h" #include "cWorld.h"
#include "items/Item.h"
#include "packets/cPacket_WindowClick.h"
#include "packets/cPacket_InventorySlot.h"
@ -44,33 +42,38 @@ cCraftingWindow::cCraftingWindow( cWindowOwner* a_Owner, bool a_bInventoryVisibl
void cCraftingWindow::Clicked( cPacket_WindowClick* a_ClickPacket, cPlayer & a_Player ) void cCraftingWindow::Clicked(
cPlayer & a_Player,
int a_WindowID, short a_SlotNum, bool a_IsRightClick, bool a_IsShiftPressed,
const cItem & a_HeldItem
)
{ {
bool bDontCook = false; bool bDontCook = false;
cItem * DraggingItem = GetDraggingItem(&a_Player); cItem * DraggingItem = GetDraggingItem(&a_Player);
if ( if (
a_ClickPacket->m_IsShiftPressed && a_IsShiftPressed &&
((DraggingItem == NULL) || DraggingItem->IsEmpty()) ((DraggingItem == NULL) || DraggingItem->IsEmpty())
) )
{ {
ShiftClicked(a_ClickPacket, a_Player); ShiftClicked(a_Player, a_SlotNum);
return; return;
} }
// Override for craft result slot // Override for craft result slot
if (a_ClickPacket->m_SlotNum == 0) if (a_SlotNum == 0)
{ {
LOG("In craft slot: %i x %i !!", GetSlot(0)->m_ItemID, GetSlot(0)->m_ItemCount ); LOGD("Clicked in craft result slot, item there: %d:%d (%d times) !!", GetSlot(0)->m_ItemID, GetSlot(0)->m_ItemHealth, GetSlot(0)->m_ItemCount);
cItem* DraggingItem = GetDraggingItem( &a_Player ); cItem * DraggingItem = GetDraggingItem(&a_Player);
if( DraggingItem->m_ItemID <= 0 ) if (DraggingItem->IsEmpty())
{ {
*DraggingItem = *GetSlot(0); *DraggingItem = *GetSlot(0);
GetSlot(0)->Empty(); GetSlot(0)->Empty();
} }
else if( DraggingItem->Equals( *GetSlot(0) ) ) else if (DraggingItem->IsEqual(*GetSlot(0)))
{ {
if( DraggingItem->m_ItemCount + GetSlot(0)->m_ItemCount <= 64 ) cItemHandler * Handler = ItemHandler(GetSlot(0)->m_ItemID);
if (DraggingItem->m_ItemCount + GetSlot(0)->m_ItemCount <= Handler->GetMaxStackSize())
{ {
DraggingItem->m_ItemCount += GetSlot(0)->m_ItemCount; DraggingItem->m_ItemCount += GetSlot(0)->m_ItemCount;
GetSlot(0)->Empty(); GetSlot(0)->Empty();
@ -84,21 +87,20 @@ void cCraftingWindow::Clicked( cPacket_WindowClick* a_ClickPacket, cPlayer & a_P
{ {
bDontCook = true; bDontCook = true;
} }
LOG("Dragging Dish %i", DraggingItem->m_ItemCount );
} }
else else
{ {
cWindow::Clicked( a_ClickPacket, a_Player ); cWindow::Clicked(a_Player, GetWindowID(), a_SlotNum, a_IsRightClick, a_IsShiftPressed, a_HeldItem);
} }
if ((a_ClickPacket->m_SlotNum >= 0) && (a_ClickPacket->m_SlotNum < 10)) if ((a_SlotNum >= 0) && (a_SlotNum < 10))
{ {
cCraftingGrid Grid(GetSlots() + 1, 3, 3); cCraftingGrid Grid(GetSlots() + 1, 3, 3);
cCraftingRecipe Recipe(Grid); cCraftingRecipe Recipe(Grid);
cRoot::Get()->GetCraftingRecipes()->GetRecipe(&a_Player, Grid, Recipe); cRoot::Get()->GetCraftingRecipes()->GetRecipe(&a_Player, Grid, Recipe);
if ((a_ClickPacket->m_SlotNum == 0) && !bDontCook) if ((a_SlotNum == 0) && !bDontCook)
{ {
// Consume the items from the crafting grid: // Consume the items from the crafting grid:
Recipe.ConsumeIngredients(Grid); Recipe.ConsumeIngredients(Grid);
@ -110,19 +112,13 @@ void cCraftingWindow::Clicked( cPacket_WindowClick* a_ClickPacket, cPlayer & a_P
cRoot::Get()->GetCraftingRecipes()->GetRecipe(&a_Player, Grid, Recipe); cRoot::Get()->GetCraftingRecipes()->GetRecipe(&a_Player, Grid, Recipe);
} }
*GetSlot(0) = Recipe.GetResult(); *GetSlot(0) = Recipe.GetResult();
LOGD("%s cooked: %i x %i !!", a_Player.GetName().c_str(), GetSlot(0)->m_ItemID, GetSlot(0)->m_ItemCount ); LOGD("%s cooked: %d:%d (%d times) !!", a_Player.GetName().c_str(), GetSlot(0)->m_ItemID, GetSlot(0)->m_ItemHealth, GetSlot(0)->m_ItemCount);
} }
SendWholeWindow( a_Player.GetClientHandle() ); SendWholeWindow( a_Player.GetClientHandle() );
a_Player.GetInventory().SendWholeInventory( a_Player.GetClientHandle() ); a_Player.GetInventory().SendWholeInventory( a_Player.GetClientHandle() );
// Separate packet for result =/ Don't know why // Separate packet for result =/ Don't know why
cPacket_InventorySlot Packet; a_Player.GetClientHandle()->SendInventorySlot(GetWindowID(), 0, *GetSlot(0));
Packet.m_WindowID = (char)GetWindowID();
Packet.m_SlotNum = 0;
Packet.m_ItemID = (short)GetSlot(0)->m_ItemID;
Packet.m_ItemCount = GetSlot(0)->m_ItemCount;
Packet.m_ItemUses = (char)GetSlot(0)->m_ItemHealth;
a_Player.GetClientHandle()->Send( Packet );
} }
@ -153,16 +149,15 @@ void cCraftingWindow::Close(cPlayer & a_Player)
void cCraftingWindow::ShiftClicked(cPacket_WindowClick * a_ClickPacket, cPlayer & a_Player) void cCraftingWindow::ShiftClicked(cPlayer & a_Player, short a_SlotNum)
{ {
short Slot = a_ClickPacket->m_SlotNum; if (a_SlotNum == SLOT_CRAFTING_RESULT)
if (Slot == SLOT_CRAFTING_RESULT)
{ {
ShiftClickedCraftingResult(Slot, a_Player); ShiftClickedCraftingResult(a_Player, a_SlotNum);
} }
else if ((Slot >= SLOT_CRAFTING_MIN) && (Slot <= SLOT_CRAFTING_MAX)) else if ((a_SlotNum >= SLOT_CRAFTING_MIN) && (a_SlotNum <= SLOT_CRAFTING_MAX))
{ {
ShiftClickedCraftingGrid(Slot, a_Player); ShiftClickedCraftingGrid(a_Player, a_SlotNum);
} }
else else
{ {
@ -175,7 +170,7 @@ void cCraftingWindow::ShiftClicked(cPacket_WindowClick * a_ClickPacket, cPlayer
void cCraftingWindow::ShiftClickedCraftingResult(short a_Slot, cPlayer & a_Player) void cCraftingWindow::ShiftClickedCraftingResult(cPlayer & a_Player, short a_Slot)
{ {
// Craft until either the recipe changes (due to ingredients) or there's not enough storage for the result // Craft until either the recipe changes (due to ingredients) or there's not enough storage for the result
cInventory & Inventory = a_Player.GetInventory(); cInventory & Inventory = a_Player.GetInventory();
@ -210,7 +205,7 @@ void cCraftingWindow::ShiftClickedCraftingResult(short a_Slot, cPlayer & a_Playe
GetSlots()[SLOT_CRAFTING_RESULT] = Recipe.GetResult(); GetSlots()[SLOT_CRAFTING_RESULT] = Recipe.GetResult();
// If the recipe changed, abort: // If the recipe changed, abort:
if (!Recipe.GetResult().Equals(ResultCopy)) if (!Recipe.GetResult().IsEqual(ResultCopy))
{ {
break; break;
} }
@ -221,7 +216,7 @@ void cCraftingWindow::ShiftClickedCraftingResult(short a_Slot, cPlayer & a_Playe
void cCraftingWindow::ShiftClickedCraftingGrid(short a_Slot, cPlayer & a_Player) void cCraftingWindow::ShiftClickedCraftingGrid(cPlayer & a_Player, short a_Slot)
{ {
cInventory & Inventory = a_Player.GetInventory(); cInventory & Inventory = a_Player.GetInventory();
cItem * Item = GetSlot(a_Slot); cItem * Item = GetSlot(a_Slot);

15
source/cCraftingWindow.h
View File

@ -25,12 +25,17 @@ public:
cCraftingWindow(cWindowOwner * a_Owner, bool a_bInventoryVisible); cCraftingWindow(cWindowOwner * a_Owner, bool a_bInventoryVisible);
virtual void Clicked(cPacket_WindowClick * a_ClickPacket, cPlayer & a_Player); virtual void Clicked(
virtual void Close(cPlayer & a_Player); cPlayer & a_Player,
int a_WindowID, short a_SlotNum, bool a_IsRightClick, bool a_IsShiftPressed,
const cItem & a_HeldItem
) override;
void ShiftClicked(cPacket_WindowClick * a_ClickPacket, cPlayer & a_Player); virtual void Close(cPlayer & a_Player) override;
void ShiftClickedCraftingResult(short a_Slot, cPlayer & a_Player);
void ShiftClickedCraftingGrid (short a_Slot, cPlayer & a_Player); void ShiftClicked(cPlayer & a_Player, short a_SlotNum);
void ShiftClickedCraftingResult(cPlayer & a_Player, short a_SlotNum);
void ShiftClickedCraftingGrid (cPlayer & a_Player, short a_SlotNum);
}; };

63
source/cCreativeInventory.cpp
View File

@ -14,37 +14,50 @@
#include "packets/cPacket_WholeInventory.h" #include "packets/cPacket_WholeInventory.h"
#include "packets/cPacket_InventorySlot.h" #include "packets/cPacket_InventorySlot.h"
cCreativeInventory::~cCreativeInventory()
{
}
cCreativeInventory::cCreativeInventory(cPlayer* a_Owner)
cCreativeInventory::cCreativeInventory(cPlayer * a_Owner)
: cInventory(a_Owner) : cInventory(a_Owner)
{ {
} }
void cCreativeInventory::Clicked( cPacket* a_ClickPacket )
cCreativeInventory::~cCreativeInventory()
{ {
cPacket_CreativeInventoryAction* Packet = reinterpret_cast<cPacket_CreativeInventoryAction *>(a_ClickPacket);
short Slot = Packet->m_Slot;
if (Slot == -1)
{
// object thrown out
m_Owner->TossItem(false, Packet->m_Quantity, Packet->m_ItemID, Packet->m_Damage);
return;
}
if ((Slot < c_HotOffset) || (Slot >= c_NumSlots))
{
LOG("%s: Invalid slot (%d) in CreativeInventoryAction packet. Ignoring...", m_Owner->GetName().c_str(), Slot);
return;
}
cItem * SlotItem = &(this->m_Slots[Slot]);
SlotItem->m_ItemID = (ENUM_ITEM_ID) Packet->m_ItemID;
SlotItem->m_ItemHealth = Packet->m_Damage;
SlotItem->m_ItemCount = Packet->m_Quantity;
} }
void cCreativeInventory::Clicked(
short a_SlotNum, bool a_IsRightClick, bool a_IsShiftPressed,
const cItem & a_HeldItem
)
{
if (a_SlotNum == -1)
{
// object thrown out
m_Owner->TossItem(false, a_HeldItem.m_ItemCount, a_HeldItem.m_ItemType, a_HeldItem.m_ItemDamage);
return;
}
if ((a_SlotNum < c_HotOffset) || (a_SlotNum >= c_NumSlots))
{
LOG("%s: Invalid slot (%d) in cCreativeInventory::Clicked(). Ignoring...", m_Owner->GetName().c_str(), a_SlotNum);
return;
}
m_Slots[a_SlotNum] = a_HeldItem;
}

19
source/cCreativeInventory.h
View File

@ -1,13 +1,22 @@
#pragma once #pragma once
#include "cInventory.h" #include "cInventory.h"
class cCreativeInventory //tolua_export
class cCreativeInventory
: public cInventory : public cInventory
{ //tolua_export {
public: public:
cCreativeInventory(cPlayer* a_Owner); cCreativeInventory(cPlayer * a_Owner);
~cCreativeInventory(); ~cCreativeInventory();
virtual void Clicked( cPacket* a_ClickPacket ); virtual void Clicked(short a_SlotNum, bool a_IsRightClick, bool a_IsShiftPressed, const cItem & a_HeldItem) override;
}; //tolua_export } ;

8
source/cFurnaceEntity.cpp
View File

@ -120,7 +120,7 @@ bool cFurnaceEntity::Tick( float a_Dt )
if ((m_CookingItem != NULL) && ((m_TimeBurned < m_BurnTime) || (m_TimeCooked + a_Dt >= m_CookTime))) if ((m_CookingItem != NULL) && ((m_TimeBurned < m_BurnTime) || (m_TimeCooked + a_Dt >= m_CookTime)))
{ {
if (m_CookingItem->Equals(m_Items[2]) || m_Items[2].IsEmpty()) if (m_CookingItem->IsEqual(m_Items[2]) || m_Items[2].IsEmpty())
{ {
m_TimeCooked += a_Dt; m_TimeCooked += a_Dt;
if ( m_TimeCooked >= m_CookTime ) if ( m_TimeCooked >= m_CookTime )
@ -201,9 +201,9 @@ bool cFurnaceEntity::StartCooking(void)
if( (m_TimeBurned < m_BurnTime) || BurnTime > 0.f ) // burnable material if( (m_TimeBurned < m_BurnTime) || BurnTime > 0.f ) // burnable material
{ {
const cFurnaceRecipe::Recipe* R = FR->GetRecipeFrom( m_Items[0] ); const cFurnaceRecipe::Recipe* R = FR->GetRecipeFrom( m_Items[0] );
if( R ) // cook able ingredient if (R != NULL) // cook able ingredient
{ {
if( m_Items[2].Equals( *R->Out ) || m_Items[2].IsEmpty() ) if (m_Items[2].IsEqual(*R->Out) || m_Items[2].IsEmpty())
{ {
// good to go // good to go
@ -241,7 +241,7 @@ bool cFurnaceEntity::ContinueCooking(void)
const cFurnaceRecipe::Recipe * R = FR->GetRecipeFrom( m_Items[0] ); const cFurnaceRecipe::Recipe * R = FR->GetRecipeFrom( m_Items[0] );
if (R != NULL) // cook able ingredient if (R != NULL) // cook able ingredient
{ {
if (m_Items[2].Equals(*R->Out) || m_Items[2].IsEmpty()) if (m_Items[2].IsEqual(*R->Out) || m_Items[2].IsEmpty())
{ {
// good to go // good to go
if (m_CookingItem == NULL) // Only cook new item if not already cooking if (m_CookingItem == NULL) // Only cook new item if not already cooking

22
source/cFurnaceWindow.cpp
View File

@ -22,21 +22,27 @@ cFurnaceWindow::cFurnaceWindow( cFurnaceEntity* a_Owner )
void cFurnaceWindow::Clicked(cPacket_WindowClick * a_ClickPacket, cPlayer & a_Player) void cFurnaceWindow::Clicked(
cPlayer & a_Player,
int a_WindowID, short a_SlotNum, bool a_IsRightClick, bool a_IsShiftPressed,
const cItem & a_HeldItem
)
{ {
cItem Fuel = *GetSlot( 0 ); cItem Fuel = *GetSlot( 0 );
cWindow::Clicked( a_ClickPacket, a_Player ); cWindow::Clicked(a_Player, a_WindowID, a_SlotNum, a_IsRightClick, a_IsShiftPressed, a_HeldItem);
if (m_Furnace != NULL) if (m_Furnace != NULL)
{ {
if ((a_ClickPacket->m_SlotNum >= 0) && (a_ClickPacket->m_SlotNum <= 2)) // them important slots if ((a_SlotNum >= 0) && (a_SlotNum <= 2)) // them important slots
{ {
if( Fuel.m_ItemID != GetSlot( 0 )->m_ItemID ) if (Fuel.m_ItemID != GetSlot( 0 )->m_ItemID)
m_Furnace->ResetCookTimer();
if( m_Furnace->StartCooking() )
{ {
SendWholeWindow( a_Player.GetClientHandle() ); m_Furnace->ResetCookTimer();
}
if (m_Furnace->StartCooking())
{
SendWholeWindow(a_Player.GetClientHandle());
} }
} }
} }

29
source/cFurnaceWindow.h
View File

@ -1,16 +1,37 @@
#pragma once #pragma once
#include "cWindow.h" #include "cWindow.h"
class cFurnaceEntity; class cFurnaceEntity;
class cWindowOwner; class cWindowOwner;
class cFurnaceWindow : public cWindow
class cFurnaceWindow :
public cWindow
{ {
public: public:
cFurnaceWindow( cFurnaceEntity* a_Owner ); cFurnaceWindow( cFurnaceEntity* a_Owner );
virtual void Clicked( cPacket_WindowClick* a_ClickPacket, cPlayer & a_Player ); virtual void Clicked(
virtual void Close( cPlayer & a_Player ); cPlayer & a_Player,
int a_WindowID, short a_SlotNum, bool a_IsRightClick, bool a_IsShiftPressed,
const cItem & a_HeldItem
) override;
virtual void Close( cPlayer & a_Player ) override;
private: private:
cFurnaceEntity* m_Furnace; cFurnaceEntity * m_Furnace;
}; };

2
source/cInventory.cpp
View File

@ -293,7 +293,7 @@ void cInventory::SendWholeInventoryToAll(void)
void cInventory::SendSlot( int a_SlotNum ) void cInventory::SendSlot( int a_SlotNum )
{ {
cItem* Item = GetSlot( a_SlotNum ); cItem * Item = GetSlot(a_SlotNum);
if (Item != NULL) if (Item != NULL)
{ {
if (Item->IsEmpty()) if (Item->IsEmpty())

2
source/cInventory.h
View File

@ -51,7 +51,7 @@ public:
void SetEquippedSlot( int a_SlotNum ); //tolua_export void SetEquippedSlot( int a_SlotNum ); //tolua_export
short GetEquippedSlot() { return m_EquippedSlot; } //tolua_export short GetEquippedSlot() { return m_EquippedSlot; } //tolua_export
virtual void Clicked( cPacket* a_ClickPacket ) = 0; virtual void Clicked(short a_SlotNum, bool a_IsRightClick, bool a_IsShiftPressed, const cItem & a_HeldItem) = 0;
void SendSlot( int a_SlotNum ); //tolua_export void SendSlot( int a_SlotNum ); //tolua_export

25
source/cItem.cpp
View File

@ -28,24 +28,31 @@ void cItem::FromJson( const Json::Value & a_Value )
} }
} }
bool cItem::IsEnchantable(ENUM_ITEM_ID item)
bool cItem::IsEnchantable(short item)
{ {
if(item >= 256 && item <= 259) if ((item >= 256) && (item <= 259))
return true; return true;
if(item >= 267 && item <= 279) if ((item >= 267) && (item <= 279))
return true; return true;
if(item >= 283 && item <= 286) if ((item >= 283) && (item <= 286))
return true; return true;
if(item >= 290 && item <= 294) if ((item >= 290) && (item <= 294))
return true; return true;
if(item >= 298 && item <= 317) if ((item >= 298) && (item <= 317))
return true; return true;
if(item >= 290 && item <= 294) if ((item >= 290) && (item <= 294))
return true; return true;
if(item == 346 || item == 359 || item == 261) if ((item == 346) || (item == 359) || (item == 261))
return true; return true;
return false; return false;
} }

41
source/cItem.h
View File

@ -39,9 +39,23 @@ public:
{ {
return (m_ItemID <= 0 || m_ItemCount <= 0); return (m_ItemID <= 0 || m_ItemCount <= 0);
} }
bool Equals( cItem & a_Item ) const
// tolua_end
OBSOLETE
// tolua_begin
bool Equals(const cItem & a_Item) const // obsolete, use IsEqual() instead
{ {
return ( (m_ItemID == a_Item.m_ItemID) && (m_ItemHealth == a_Item.m_ItemHealth) ); return IsEqual(a_Item);
}
bool IsEqual(const cItem & a_Item) const
{
return (IsSameType(a_Item) && (m_ItemHealth == a_Item.m_ItemHealth));
}
bool IsSameType(const cItem & a_Item) const
{
return (m_ItemID == a_Item.m_ItemID) || (IsEmpty() && a_Item.IsEmpty());
} }
// TODO Sorry for writing the functions in the header. But somehow it doesn´t worked when I put them into the cpp File :s // TODO Sorry for writing the functions in the header. But somehow it doesn´t worked when I put them into the cpp File :s
@ -100,12 +114,25 @@ public:
void FromJson( const Json::Value & a_Value ); void FromJson( const Json::Value & a_Value );
// tolua_begin // tolua_begin
static bool IsEnchantable(ENUM_ITEM_ID item); static bool IsEnchantable(short a_ItemType);
ENUM_ITEM_ID m_ItemID;
char m_ItemCount;
short m_ItemHealth;
// tolua_end
union
{
// tolua_begin
ENUM_ITEM_ID m_ItemID; // OBSOLETE, use m_ItemType instead
short m_ItemType;
// tolua_end
} ;
char m_ItemCount; // tolua_export
union
{
// tolua_begin
short m_ItemHealth; // OBSOLETE, use m_ItemDamage instead
short m_ItemDamage;
// tolua_end
} ;
// tolua_begin
}; };
// tolua_end // tolua_end

1
source/cPlayer.h
View File

@ -39,6 +39,7 @@ public:
double GetEyeHeight(); //tolua_export double GetEyeHeight(); //tolua_export
Vector3d GetEyePosition(); //tolua_export Vector3d GetEyePosition(); //tolua_export
inline bool GetFlying() { return m_bTouchGround; } //tolua_export inline bool GetFlying() { return m_bTouchGround; } //tolua_export
inline bool IsOnGround(void) const {return m_bTouchGround; } // tolua_export
inline const double & GetStance() { return m_Stance; } //tolua_export inline const double & GetStance() { return m_Stance; } //tolua_export
inline cInventory & GetInventory() { if(GetGameMode() == eGameMode_Survival) return *m_Inventory; else return *m_CreativeInventory; } //tolua_export inline cInventory & GetInventory() { if(GetGameMode() == eGameMode_Survival) return *m_Inventory; else return *m_CreativeInventory; } //tolua_export

199
source/cPlugin.cpp
View File

@ -37,10 +37,16 @@ void cPlugin::Tick(float a_Dt)
bool cPlugin::OnBlockPlace(cPacket_BlockPlace * a_PacketData, cPlayer * a_Player) bool cPlugin::OnBlockDig(cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, char a_Status, BLOCKTYPE a_OldBlock, NIBBLETYPE a_OldMeta)
{ {
UNUSED(a_PacketData);
UNUSED(a_Player); UNUSED(a_Player);
UNUSED(a_BlockX);
UNUSED(a_BlockY);
UNUSED(a_BlockZ);
UNUSED(a_BlockFace);
UNUSED(a_Status);
UNUSED(a_OldBlock);
UNUSED(a_OldMeta);
return false; return false;
} }
@ -48,11 +54,14 @@ bool cPlugin::OnBlockPlace(cPacket_BlockPlace * a_PacketData, cPlayer * a_Player
bool cPlugin::OnBlockDig(cPacket_BlockDig * a_PacketData, cPlayer * a_Player, cItem * a_PickupItem) bool cPlugin::OnBlockPlace(cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, const cItem & a_HeldItem)
{ {
UNUSED(a_PacketData);
UNUSED(a_Player); UNUSED(a_Player);
UNUSED(a_PickupItem); UNUSED(a_BlockX);
UNUSED(a_BlockY);
UNUSED(a_BlockZ);
UNUSED(a_BlockFace);
UNUSED(a_HeldItem);
return false; return false;
} }
@ -60,21 +69,13 @@ bool cPlugin::OnBlockDig(cPacket_BlockDig * a_PacketData, cPlayer * a_Player, cI
bool cPlugin::OnCollectItem(cPickup * a_Pickup, cPlayer * a_Player) bool cPlugin::OnBlockToPickup(BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta, const cPlayer * a_Player, const cItem & a_EquippedItem, cItems & a_Pickups)
{ {
UNUSED(a_Pickup); UNUSED(a_BlockType);
UNUSED(a_Player); UNUSED(a_BlockMeta);
return false;
}
bool cPlugin::OnDisconnect(const AString & a_Reason, cPlayer * a_Player)
{
UNUSED(a_Reason);
UNUSED(a_Player); UNUSED(a_Player);
UNUSED(a_EquippedItem);
UNUSED(a_Pickups);
return false; return false;
} }
@ -93,65 +94,6 @@ bool cPlugin::OnChat(const char * a_Chat, cPlayer * a_Player)
bool cPlugin::OnLogin(cPacket_Login * a_PacketData)
{
UNUSED(a_PacketData);
return false;
}
void cPlugin::OnPlayerSpawn(cPlayer * a_Player)
{
UNUSED(a_Player);
}
bool cPlugin::OnPlayerJoin(cPlayer * a_Player)
{
UNUSED(a_Player);
return false;
}
void cPlugin::OnPlayerMove(cPlayer * a_Player)
{
UNUSED(a_Player);
}
void cPlugin::OnTakeDamage(cPawn * a_Pawn, TakeDamageInfo * a_TakeDamageInfo)
{
UNUSED(a_Pawn);
UNUSED(a_TakeDamageInfo);
}
bool cPlugin::OnKilled(cPawn * a_Killed, cEntity * a_Killer)
{
UNUSED(a_Killed);
UNUSED(a_Killer);
return false;
}
void cPlugin::OnChunkGenerated(cWorld * a_World, int a_ChunkX, int a_ChunkZ) void cPlugin::OnChunkGenerated(cWorld * a_World, int a_ChunkX, int a_ChunkZ)
{ {
UNUSED(a_World); UNUSED(a_World);
@ -176,11 +118,10 @@ bool cPlugin::OnChunkGenerating(cWorld * a_World, int a_ChunkX, int a_ChunkZ, cL
bool cPlugin::OnPreCrafting(const cPlayer * a_Player, const cCraftingGrid * a_Grid, cCraftingRecipe * a_Recipe) bool cPlugin::OnCollectItem(cPickup * a_Pickup, cPlayer * a_Player)
{ {
UNUSED(a_Pickup);
UNUSED(a_Player); UNUSED(a_Player);
UNUSED(a_Grid);
UNUSED(a_Recipe);
return false; return false;
} }
@ -200,6 +141,68 @@ bool cPlugin::OnCraftingNoRecipe(const cPlayer * a_Player, const cCraftingGrid *
bool cPlugin::OnDisconnect(const AString & a_Reason, cPlayer * a_Player)
{
UNUSED(a_Reason);
UNUSED(a_Player);
return false;
}
bool cPlugin::OnKilled(cPawn * a_Killed, cEntity * a_Killer)
{
UNUSED(a_Killed);
UNUSED(a_Killer);
return false;
}
bool cPlugin::OnLogin(cClientHandle * a_Client, int a_ProtocolVersion, const AString & a_Username)
{
UNUSED(a_Client);
UNUSED(a_ProtocolVersion);
UNUSED(a_Username);
return false;
}
bool cPlugin::OnPlayerJoin(cPlayer * a_Player)
{
UNUSED(a_Player);
return false;
}
void cPlugin::OnPlayerMove(cPlayer * a_Player)
{
UNUSED(a_Player);
}
void cPlugin::OnPlayerSpawn(cPlayer * a_Player)
{
UNUSED(a_Player);
}
bool cPlugin::OnPostCrafting(const cPlayer * a_Player, const cCraftingGrid * a_Grid, cCraftingRecipe * a_Recipe) bool cPlugin::OnPostCrafting(const cPlayer * a_Player, const cCraftingGrid * a_Grid, cCraftingRecipe * a_Recipe)
{ {
UNUSED(a_Player); UNUSED(a_Player);
@ -212,13 +215,11 @@ bool cPlugin::OnPostCrafting(const cPlayer * a_Player, const cCraftingGrid * a_G
bool cPlugin::OnBlockToPickup(BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta, const cPlayer * a_Player, const cItem & a_EquippedItem, cItems & a_Pickups) bool cPlugin::OnPreCrafting(const cPlayer * a_Player, const cCraftingGrid * a_Grid, cCraftingRecipe * a_Recipe)
{ {
UNUSED(a_BlockType);
UNUSED(a_BlockMeta);
UNUSED(a_Player); UNUSED(a_Player);
UNUSED(a_EquippedItem); UNUSED(a_Grid);
UNUSED(a_Pickups); UNUSED(a_Recipe);
return false; return false;
} }
@ -226,9 +227,26 @@ bool cPlugin::OnBlockToPickup(BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta, con
bool cPlugin::OnWeatherChanged(cWorld * a_World) void cPlugin::OnTakeDamage(cPawn * a_Pawn, TakeDamageInfo * a_TakeDamageInfo)
{
UNUSED(a_Pawn);
UNUSED(a_TakeDamageInfo);
}
bool cPlugin::OnUpdatedSign(cWorld * a_World, 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)
{ {
UNUSED(a_World); UNUSED(a_World);
UNUSED(a_BlockX);
UNUSED(a_BlockY);
UNUSED(a_BlockZ);
UNUSED(a_Line1);
UNUSED(a_Line2);
UNUSED(a_Line3);
UNUSED(a_Line4);
return false; return false;
} }
@ -253,16 +271,9 @@ bool cPlugin::OnUpdatingSign(cWorld * a_World, int a_BlockX, int a_BlockY, int a
bool cPlugin::OnUpdatedSign(cWorld * a_World, 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) bool cPlugin::OnWeatherChanged(cWorld * a_World)
{ {
UNUSED(a_World); UNUSED(a_World);
UNUSED(a_BlockX);
UNUSED(a_BlockY);
UNUSED(a_BlockZ);
UNUSED(a_Line1);
UNUSED(a_Line2);
UNUSED(a_Line3);
UNUSED(a_Line4);
return false; return false;
} }

32
source/cPlugin.h
View File

@ -46,28 +46,28 @@ public:
/** /**
* On all these functions, return true if you want to override default behavior * On all these functions, return true if you want to override default behavior
* You can also return false, so default behavior is used, but with changed PacketData * You can also return false, so default behavior is used.
**/ **/
virtual bool OnCollectItem (cPickup* a_Pickup, cPlayer* a_Player ); virtual bool OnBlockDig (cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, char a_Status, BLOCKTYPE a_OldBlock, NIBBLETYPE a_OldMeta);
virtual bool OnDisconnect (const AString & a_Reason, cPlayer * a_Player ); virtual bool OnBlockPlace (cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, const cItem & a_HeldItem);
virtual bool OnBlockPlace (cPacket_BlockPlace* a_PacketData, cPlayer* a_Player ); virtual bool OnBlockToPickup (BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta, const cPlayer * a_Player, const cItem & a_EquippedItem, cItems & a_Pickups);
virtual bool OnBlockDig (cPacket_BlockDig * a_PacketData, cPlayer * a_Player, cItem * a_PickupItem); virtual bool OnChat (const char * a_Chat, cPlayer * a_Player );
virtual bool OnChat (const char * a_Chat, cPlayer* a_Player );
virtual bool OnLogin (cPacket_Login* a_PacketData );
virtual void OnPlayerSpawn (cPlayer* a_Player );
virtual bool OnPlayerJoin (cPlayer* a_Player );
virtual void OnPlayerMove (cPlayer* a_Player );
virtual void OnTakeDamage (cPawn* a_Pawn, TakeDamageInfo* a_TakeDamageInfo );
virtual bool OnKilled (cPawn* a_Killed, cEntity* a_Killer );
virtual void OnChunkGenerated (cWorld * a_World, int a_ChunkX, int a_ChunkZ); virtual void OnChunkGenerated (cWorld * a_World, int a_ChunkX, int a_ChunkZ);
virtual bool OnChunkGenerating (cWorld * a_World, int a_ChunkX, int a_ChunkZ, cLuaChunk * a_pLuaChunk); virtual bool OnChunkGenerating (cWorld * a_World, int a_ChunkX, int a_ChunkZ, cLuaChunk * a_pLuaChunk);
virtual bool OnPreCrafting (const cPlayer * a_Player, const cCraftingGrid * a_Grid, cCraftingRecipe * a_Recipe); virtual bool OnCollectItem (cPickup* a_Pickup, cPlayer* a_Player );
virtual bool OnCraftingNoRecipe(const cPlayer * a_Player, const cCraftingGrid * a_Grid, cCraftingRecipe * a_Recipe); virtual bool OnCraftingNoRecipe(const cPlayer * a_Player, const cCraftingGrid * a_Grid, cCraftingRecipe * a_Recipe);
virtual bool OnDisconnect (const AString & a_Reason, cPlayer * a_Player );
virtual bool OnKilled (cPawn* a_Killed, cEntity* a_Killer );
virtual bool OnLogin (cClientHandle * a_Client, int a_ProtocolVersion, const AString & a_Username);
virtual bool OnPlayerJoin (cPlayer* a_Player );
virtual void OnPlayerMove (cPlayer* a_Player );
virtual void OnPlayerSpawn (cPlayer* a_Player );
virtual bool OnPostCrafting (const cPlayer * a_Player, const cCraftingGrid * a_Grid, cCraftingRecipe * a_Recipe); virtual bool OnPostCrafting (const cPlayer * a_Player, const cCraftingGrid * a_Grid, cCraftingRecipe * a_Recipe);
virtual bool OnBlockToPickup (BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta, const cPlayer * a_Player, const cItem & a_EquippedItem, cItems & a_Pickups); virtual bool OnPreCrafting (const cPlayer * a_Player, const cCraftingGrid * a_Grid, cCraftingRecipe * a_Recipe);
virtual bool OnWeatherChanged (cWorld * a_World); virtual void OnTakeDamage (cPawn * a_Pawn, TakeDamageInfo * a_TakeDamageInfo );
virtual bool OnUpdatingSign (cWorld * a_World, int a_BlockX, int a_BlockY, int a_BlockZ, AString & a_Line1, AString & a_Line2, AString & a_Line3, AString & a_Line4);
virtual bool OnUpdatedSign (cWorld * a_World, 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); virtual bool OnUpdatedSign (cWorld * a_World, 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);
virtual bool OnUpdatingSign (cWorld * a_World, int a_BlockX, int a_BlockY, int a_BlockZ, AString & a_Line1, AString & a_Line2, AString & a_Line3, AString & a_Line4);
virtual bool OnWeatherChanged (cWorld * a_World);
// Accessors // Accessors
const char* GetName() const { return m_Name.c_str(); } const char* GetName() const { return m_Name.c_str(); }

111
source/cPluginManager.cpp
View File

@ -263,39 +263,6 @@ bool cPluginManager::CallHook(PluginHook a_Hook, unsigned int a_NumArgs, ...)
break; break;
} }
case HOOK_BLOCK_DIG:
{
if( a_NumArgs != 2 ) break;
va_list argptr;
va_start( argptr, a_NumArgs);
cPacket_BlockDig* Packet = va_arg(argptr, cPacket_BlockDig* );
cPlayer* Player = va_arg(argptr, cPlayer* );
cItem* Item = va_arg( argptr, cItem* );
va_end (argptr);
for( PluginList::iterator itr = Plugins->second.begin(); itr != Plugins->second.end(); ++itr )
{
if( (*itr)->OnBlockDig( Packet, Player, Item ) )
return true;
}
break;
}
case HOOK_BLOCK_PLACE:
{
if( a_NumArgs != 2 ) break;
va_list argptr;
va_start( argptr, a_NumArgs);
cPacket_BlockPlace* Packet = va_arg(argptr, cPacket_BlockPlace* );
cPlayer* Player = va_arg(argptr, cPlayer* );
va_end (argptr);
for( PluginList::iterator itr = Plugins->second.begin(); itr != Plugins->second.end(); ++itr )
{
if( (*itr)->OnBlockPlace( Packet, Player ) )
return true;
}
break;
}
case HOOK_DISCONNECT: case HOOK_DISCONNECT:
{ {
if( a_NumArgs != 2 ) break; if( a_NumArgs != 2 ) break;
@ -312,21 +279,6 @@ bool cPluginManager::CallHook(PluginHook a_Hook, unsigned int a_NumArgs, ...)
break; break;
} }
case HOOK_LOGIN:
{
if( a_NumArgs != 1 ) break;
va_list argptr;
va_start( argptr, a_NumArgs);
cPacket_Login* Packet = va_arg(argptr, cPacket_Login* );
va_end (argptr);
for( PluginList::iterator itr = Plugins->second.begin(); itr != Plugins->second.end(); ++itr )
{
if( (*itr)->OnLogin( Packet ) )
return true;
}
break;
}
case HOOK_PLAYER_JOIN: case HOOK_PLAYER_JOIN:
{ {
if( a_NumArgs != 1 ) break; if( a_NumArgs != 1 ) break;
@ -437,6 +389,69 @@ bool cPluginManager::CallHook(PluginHook a_Hook, unsigned int a_NumArgs, ...)
bool cPluginManager::CallHookLogin(cClientHandle * a_Client, int a_ProtocolVersion, const AString & a_Username)
{
HookMap::iterator Plugins = m_Hooks.find(HOOK_LOGIN);
if (Plugins == m_Hooks.end())
{
return false;
}
for (PluginList::iterator itr = Plugins->second.begin(); itr != Plugins->second.end(); ++itr)
{
if ((*itr)->OnLogin(a_Client, a_ProtocolVersion, a_Username))
{
return true;
}
}
return false;
}
bool cPluginManager::CallHookBlockDig(cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, char a_Status, BLOCKTYPE a_OldBlock, NIBBLETYPE a_OldMeta)
{
HookMap::iterator Plugins = m_Hooks.find(HOOK_BLOCK_DIG);
if (Plugins == m_Hooks.end())
{
return false;
}
for (PluginList::iterator itr = Plugins->second.begin(); itr != Plugins->second.end(); ++itr)
{
if ((*itr)->OnBlockDig(a_Player, a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, a_Status, a_OldBlock, a_OldMeta))
{
return true;
}
}
return false;
}
bool cPluginManager::CallHookBlockPlace(cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, const cItem & a_HeldItem)
{
HookMap::iterator Plugins = m_Hooks.find(HOOK_BLOCK_PLACE);
if (Plugins == m_Hooks.end())
{
return false;
}
for (PluginList::iterator itr = Plugins->second.begin(); itr != Plugins->second.end(); ++itr)
{
if ((*itr)->OnBlockPlace(a_Player, a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, a_HeldItem))
{
return true;
}
}
return false;
}
bool cPluginManager::CallHookChunkGenerating(cWorld * a_World, int a_ChunkX, int a_ChunkZ, cLuaChunk * a_LuaChunk) bool cPluginManager::CallHookChunkGenerating(cWorld * a_World, int a_ChunkX, int a_ChunkZ, cLuaChunk * a_LuaChunk)
{ {
HookMap::iterator Plugins = m_Hooks.find(HOOK_CHUNK_GENERATING); HookMap::iterator Plugins = m_Hooks.find(HOOK_CHUNK_GENERATING);

3
source/cPluginManager.h
View File

@ -97,6 +97,9 @@ public: //tolua_export
// If the hook returns true, no further hook is called and the functions return false // If the hook returns true, no further hook is called and the functions return false
bool CallHook( PluginHook a_Hook, unsigned int a_NumArgs, ... ); bool CallHook( PluginHook a_Hook, unsigned int a_NumArgs, ... );
bool CallHookLogin (cClientHandle * a_Client, int a_ProtocolVersion, const AString & a_Username);
bool CallHookBlockDig (cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, char a_Status, BLOCKTYPE OldBlock, NIBBLETYPE OldMeta);
bool CallHookBlockPlace (cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, const cItem & a_HeldItem);
bool CallHookChunkGenerating (cWorld * a_World, int a_ChunkX, int a_ChunkZ, cLuaChunk * a_Chunk); bool CallHookChunkGenerating (cWorld * a_World, int a_ChunkX, int a_ChunkZ, cLuaChunk * a_Chunk);
bool CallHookPreCrafting (const cPlayer * a_Player, const cCraftingGrid * a_Grid, cCraftingRecipe * a_Recipe); bool CallHookPreCrafting (const cPlayer * a_Player, const cCraftingGrid * a_Grid, cCraftingRecipe * a_Recipe);
bool CallHookCraftingNoRecipe(const cPlayer * a_Player, const cCraftingGrid * a_Grid, cCraftingRecipe * a_Recipe); bool CallHookCraftingNoRecipe(const cPlayer * a_Player, const cCraftingGrid * a_Grid, cCraftingRecipe * a_Recipe);

53
source/cPlugin_NewLua.cpp
View File

@ -204,41 +204,56 @@ bool cPlugin_NewLua::OnDisconnect(const AString & a_Reason, cPlayer* a_Player )
bool cPlugin_NewLua::OnBlockPlace( cPacket_BlockPlace* a_PacketData, cPlayer* a_Player ) bool cPlugin_NewLua::OnBlockPlace(cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, const cItem & a_HeldItem)
{ {
cCSLock Lock( m_CriticalSection ); cCSLock Lock(m_CriticalSection);
if( !PushFunction("OnBlockPlace") ) if (!PushFunction("OnBlockPlace"))
{
return false; return false;
}
tolua_pushusertype(m_LuaState, a_PacketData, "cPacket_BlockPlace");
tolua_pushusertype(m_LuaState, a_Player, "cPlayer"); tolua_pushusertype(m_LuaState, a_Player, "cPlayer");
tolua_pushnumber (m_LuaState, a_BlockX);
tolua_pushnumber (m_LuaState, a_BlockY);
tolua_pushnumber (m_LuaState, a_BlockZ);
tolua_pushnumber (m_LuaState, a_BlockFace);
tolua_pushusertype(m_LuaState, (void *)&a_HeldItem, "cItem");
if( !CallFunction(2, 1, "OnBlockPlace") ) if (!CallFunction(6, 1, "OnBlockPlace"))
{
return false; return false;
}
bool bRetVal = (tolua_toboolean( m_LuaState, -1, 0) > 0); return (tolua_toboolean( m_LuaState, -1, 0) > 0);
return bRetVal;
} }
bool cPlugin_NewLua::OnBlockDig( cPacket_BlockDig* a_PacketData, cPlayer* a_Player, cItem* a_PickupItem ) bool cPlugin_NewLua::OnBlockDig(cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, char a_Status, BLOCKTYPE a_OldBlock, NIBBLETYPE a_OldMeta)
{ {
cCSLock Lock( m_CriticalSection ); cCSLock Lock(m_CriticalSection);
if( !PushFunction("OnBlockDig") ) if (!PushFunction("OnBlockDig"))
{
return false; return false;
}
tolua_pushusertype(m_LuaState, a_PacketData, "cPacket_BlockDig");
tolua_pushusertype(m_LuaState, a_Player, "cPlayer"); tolua_pushusertype(m_LuaState, a_Player, "cPlayer");
tolua_pushusertype(m_LuaState, a_PickupItem, "cItem"); tolua_pushnumber (m_LuaState, a_BlockX);
tolua_pushnumber (m_LuaState, a_BlockY);
tolua_pushnumber (m_LuaState, a_BlockZ);
tolua_pushnumber (m_LuaState, a_BlockFace);
tolua_pushnumber (m_LuaState, a_Status);
tolua_pushnumber (m_LuaState, a_OldBlock);
tolua_pushnumber (m_LuaState, a_OldMeta);
if( !CallFunction(3, 1, "OnBlockDig") ) if (!CallFunction(8, 1, "OnBlockDig"))
{
return false; return false;
}
bool bRetVal = (tolua_toboolean( m_LuaState, -1, 0) > 0); return (tolua_toboolean( m_LuaState, -1, 0) > 0);
return bRetVal;
} }
@ -265,15 +280,17 @@ bool cPlugin_NewLua::OnChat( const char* a_Chat, cPlayer* a_Player )
bool cPlugin_NewLua::OnLogin( cPacket_Login* a_PacketData ) bool cPlugin_NewLua::OnLogin(cClientHandle * a_Client, int a_ProtocolVersion, const AString & a_Username)
{ {
cCSLock Lock( m_CriticalSection ); cCSLock Lock( m_CriticalSection );
if( !PushFunction("OnLogin") ) if( !PushFunction("OnLogin") )
return false; return false;
tolua_pushusertype(m_LuaState, a_PacketData, "cPacket_Login"); tolua_pushusertype (m_LuaState, a_Client, "cClientHandle");
tolua_pushnumber (m_LuaState, a_ProtocolVersion);
tolua_pushcppstring(m_LuaState, a_Username);
if( !CallFunction(1, 1, "OnLogin") ) if (!CallFunction(3, 1, "OnLogin"))
return false; return false;
bool bRetVal = (tolua_toboolean( m_LuaState, -1, 0) > 0); bool bRetVal = (tolua_toboolean( m_LuaState, -1, 0) > 0);

6
source/cPlugin_NewLua.h
View File

@ -27,10 +27,10 @@ public: //tolua_export
virtual bool OnCollectItem (cPickup* a_Pickup, cPlayer* a_Player ) override; virtual bool OnCollectItem (cPickup* a_Pickup, cPlayer* a_Player ) override;
virtual bool OnDisconnect (const AString & a_Reason, cPlayer * a_Player ) override; virtual bool OnDisconnect (const AString & a_Reason, cPlayer * a_Player ) override;
virtual bool OnBlockPlace (cPacket_BlockPlace* a_PacketData, cPlayer* a_Player ) override; virtual bool OnBlockPlace (cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, const cItem & a_HeldItem) override;
virtual bool OnBlockDig (cPacket_BlockDig* a_PacketData, cPlayer* a_Player, cItem* a_PickupItem ) override; virtual bool OnBlockDig (cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, char a_Status, BLOCKTYPE a_OldBlock, NIBBLETYPE a_OldMeta) override;
virtual bool OnChat (const char* a_Chat, cPlayer* a_Player ) override; virtual bool OnChat (const char* a_Chat, cPlayer* a_Player ) override;
virtual bool OnLogin (cPacket_Login* a_PacketData ) override; virtual bool OnLogin (cClientHandle * a_Client, int a_ProtocolVersion, const AString & a_Username) override;
virtual void OnPlayerSpawn (cPlayer* a_Player ) override; virtual void OnPlayerSpawn (cPlayer* a_Player ) override;
virtual bool OnPlayerJoin (cPlayer* a_Player ) override; virtual bool OnPlayerJoin (cPlayer* a_Player ) override;
virtual void OnPlayerMove (cPlayer* a_Player ) override; virtual void OnPlayerMove (cPlayer* a_Player ) override;

29
source/cPlugin_Squirrel.cpp
View File

@ -125,37 +125,37 @@ bool cPlugin_Squirrel::OnDisconnect(const AString & a_Reason, cPlayer* a_Player
bool cPlugin_Squirrel::OnBlockPlace( cPacket_BlockPlace* a_PacketData, cPlayer* a_Player ) bool cPlugin_Squirrel::OnBlockPlace(cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, const cItem & a_HeldItem)
{ {
cCSLock Lock( m_CriticalSection ); cCSLock Lock(m_CriticalSection);
if(!m_Plugin->HasFunction("OnBlockPlace")) return false; if (!m_Plugin->HasFunction("OnBlockPlace")) return false;
return m_Plugin->GetFunction("OnBlockPlace").Evaluate<bool>(a_PacketData, a_Player); return m_Plugin->GetFunction("OnBlockPlace").Evaluate<bool>(a_Player, a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, a_HeldItem);
} }
bool cPlugin_Squirrel::OnBlockDig( cPacket_BlockDig* a_PacketData, cPlayer* a_Player, cItem* a_PickupItem ) bool cPlugin_Squirrel::OnBlockDig(cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, char a_Status, BLOCKTYPE a_OldBlock, NIBBLETYPE a_OldMeta)
{ {
cCSLock Lock( m_CriticalSection ); cCSLock Lock(m_CriticalSection);
if(!m_Plugin->HasFunction("OnBlockDig")) return false; if (!m_Plugin->HasFunction("OnBlockDig")) return false;
return m_Plugin->GetFunction("OnBlockDig").Evaluate<bool>(a_PacketData, a_Player, a_PickupItem); return m_Plugin->GetFunction("OnBlockDig").Evaluate<bool>(a_Player, a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, a_Status, a_OldBlock, a_OldMeta);
} }
bool cPlugin_Squirrel::OnChat( const char* a_Chat, cPlayer* a_Player ) bool cPlugin_Squirrel::OnChat(const char * a_Chat, cPlayer * a_Player)
{ {
cCSLock Lock( m_CriticalSection ); cCSLock Lock( m_CriticalSection );
if(!m_Plugin->HasFunction("OnChat")) return false; if (!m_Plugin->HasFunction("OnChat")) return false;
return m_Plugin->GetFunction("OnChat").Evaluate<bool>(a_Chat, a_Player); return m_Plugin->GetFunction("OnChat").Evaluate<bool>(a_Chat, a_Player);
@ -165,13 +165,16 @@ bool cPlugin_Squirrel::OnChat( const char* a_Chat, cPlayer* a_Player )
bool cPlugin_Squirrel::OnLogin( cPacket_Login* a_PacketData ) bool cPlugin_Squirrel::OnLogin(cClientHandle * a_Client, int a_ProtocolVersion, const AString & a_Username)
{ {
cCSLock Lock( m_CriticalSection ); cCSLock Lock( m_CriticalSection );
if(!m_Plugin->HasFunction("OnLogin")) return false; if (!m_Plugin->HasFunction("OnLogin"))
{
return false;
}
return m_Plugin->GetFunction("OnLogin").Evaluate<bool>(a_PacketData); return m_Plugin->GetFunction("OnLogin").Evaluate<bool>(a_Client, a_ProtocolVersion, a_Username);
} }

8
source/cPlugin_Squirrel.h
View File

@ -16,10 +16,10 @@ public:
bool OnCollectItem (cPickup* a_Pickup, cPlayer* a_Player ) override; bool OnCollectItem (cPickup* a_Pickup, cPlayer* a_Player ) override;
bool OnDisconnect (const AString & a_Reason, cPlayer * a_Player ) override; bool OnDisconnect (const AString & a_Reason, cPlayer * a_Player ) override;
bool OnBlockPlace (cPacket_BlockPlace* a_PacketData, cPlayer* a_Player ) override; bool OnBlockPlace (cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, const cItem & a_HeldItem) override;
bool OnBlockDig (cPacket_BlockDig* a_PacketData, cPlayer* a_Player, cItem* a_PickupItem ) override; bool OnBlockDig (cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace, char a_Status, BLOCKTYPE a_OldBlock, NIBBLETYPE a_OldMeta) override;
bool OnChat (const char* a_Chat, cPlayer* a_Player ) override; bool OnChat (const char * a_Chat, cPlayer * a_Player ) override;
bool OnLogin (cPacket_Login* a_PacketData ) override; bool OnLogin (cClientHandle * a_Client, int a_ProtocolVersion, const AString & a_Username) override;
void OnPlayerSpawn (cPlayer* a_Player ) override; void OnPlayerSpawn (cPlayer* a_Player ) override;
bool OnPlayerJoin (cPlayer* a_Player ) override; bool OnPlayerJoin (cPlayer* a_Player ) override;
void OnPlayerMove (cPlayer* a_Player ) override; void OnPlayerMove (cPlayer* a_Player ) override;

69
source/cSurvivalInventory.cpp
View File

@ -8,7 +8,7 @@
#include "cItem.h" #include "cItem.h"
#include "CraftingRecipes.h" #include "CraftingRecipes.h"
#include "cRoot.h" #include "cRoot.h"
#include "packets/cPacket_WindowClick.h" #include "items/Item.h"
@ -31,39 +31,42 @@ cSurvivalInventory::~cSurvivalInventory()
void cSurvivalInventory::Clicked( cPacket* a_ClickPacket ) void cSurvivalInventory::Clicked(
short a_SlotNum, bool a_IsRightClick, bool a_IsShiftPressed,
const cItem & a_HeldItem
)
{ {
cPacket_WindowClick * Packet = reinterpret_cast<cPacket_WindowClick *>(a_ClickPacket); cWindow * Window = GetWindow();
if ( if (
Packet->m_IsShiftPressed && // Shift pressed a_IsShiftPressed && // Shift pressed
(GetWindow() != NULL) && // Window is valid (Window != NULL) && // Window is valid
(GetWindow()->GetDraggingItem()->IsEmpty()) // Not dragging anything (Window->GetDraggingItem()->IsEmpty()) // Not dragging anything
) )
{ {
ShiftClicked(Packet); ShiftClicked(a_SlotNum);
return; return;
} }
bool bDontCook = false; bool bDontCook = false;
if (GetWindow()) if (Window != NULL)
{ {
// Override for craft result slot // Override for craft result slot
if (Packet->m_SlotNum == (short)c_CraftOffset) if (a_SlotNum == (short)c_CraftOffset)
{ {
LOGD("In craft slot: %i x %i !!", m_Slots[c_CraftOffset].m_ItemID, m_Slots[c_CraftOffset].m_ItemCount ); LOGD("Clicked in craft result slot, item there: %d:%d (%d times) !!", m_Slots[c_CraftOffset].m_ItemID, m_Slots[c_CraftOffset].m_ItemHealth, m_Slots[c_CraftOffset].m_ItemCount);
cItem * DraggingItem = GetWindow()->GetDraggingItem(); cItem * DraggingItem = Window->GetDraggingItem();
if (DraggingItem->IsEmpty()) if (DraggingItem->IsEmpty())
{ {
*DraggingItem = m_Slots[c_CraftOffset]; *DraggingItem = m_Slots[c_CraftOffset];
m_Slots[c_CraftOffset].Empty(); m_Slots[c_CraftOffset].Empty();
} }
else if (DraggingItem->Equals(m_Slots[c_CraftOffset])) else if (DraggingItem->IsEqual(m_Slots[c_CraftOffset]))
{ {
if (DraggingItem->m_ItemCount + m_Slots[c_CraftOffset].m_ItemCount <= 64) cItemHandler * Handler = ItemHandler(m_Slots[c_CraftOffset].m_ItemID);
if (DraggingItem->m_ItemCount + m_Slots[c_CraftOffset].m_ItemCount <= Handler->GetMaxStackSize())
{ {
DraggingItem->m_ItemCount += m_Slots[c_CraftOffset].m_ItemCount; DraggingItem->m_ItemCount += m_Slots[c_CraftOffset].m_ItemCount;
m_Slots[0].Empty(); m_Slots[c_CraftOffset].Empty();
} }
else else
{ {
@ -74,11 +77,10 @@ void cSurvivalInventory::Clicked( cPacket* a_ClickPacket )
{ {
bDontCook = true; bDontCook = true;
} }
LOGD("Dragging Dish %i", DraggingItem->m_ItemCount );
} }
else else
{ {
GetWindow()->Clicked( Packet, *m_Owner ); Window->Clicked(*m_Owner, 0, a_SlotNum, a_IsRightClick, a_IsShiftPressed, a_HeldItem);
} }
} }
else else
@ -87,14 +89,14 @@ void cSurvivalInventory::Clicked( cPacket* a_ClickPacket )
LOG("No Inventory window! WTF"); LOG("No Inventory window! WTF");
} }
if ((Packet->m_SlotNum >= (short)c_CraftOffset) && (Packet->m_SlotNum < (short)(c_CraftOffset + c_CraftSlots + 1))) if ((a_SlotNum >= (short)c_CraftOffset) && (a_SlotNum < (short)(c_CraftOffset + c_CraftSlots + 1)))
{ {
cCraftingGrid Grid(m_Slots + c_CraftOffset + 1, 2, 2); cCraftingGrid Grid(m_Slots + c_CraftOffset + 1, 2, 2);
cCraftingRecipe Recipe(Grid); cCraftingRecipe Recipe(Grid);
cRoot::Get()->GetCraftingRecipes()->GetRecipe(m_Owner, Grid, Recipe); cRoot::Get()->GetCraftingRecipes()->GetRecipe(m_Owner, Grid, Recipe);
if ((Packet->m_SlotNum == 0) && !bDontCook) if ((a_SlotNum == 0) && !bDontCook)
{ {
// Consume the items from the crafting grid: // Consume the items from the crafting grid:
Recipe.ConsumeIngredients(Grid); Recipe.ConsumeIngredients(Grid);
@ -106,8 +108,8 @@ void cSurvivalInventory::Clicked( cPacket* a_ClickPacket )
cRoot::Get()->GetCraftingRecipes()->GetRecipe(m_Owner, Grid, Recipe); cRoot::Get()->GetCraftingRecipes()->GetRecipe(m_Owner, Grid, Recipe);
} }
m_Slots[c_CraftOffset] = Recipe.GetResult(); m_Slots[c_CraftOffset] = Recipe.GetResult();
LOGD("%s cooked: %i x %i !!", m_Owner->GetName().c_str(), m_Slots[c_CraftOffset].m_ItemID, m_Slots[c_CraftOffset].m_ItemCount ); LOGD("%s cooked: %d:%d (%d times) !!", m_Owner->GetName().c_str(), m_Slots[c_CraftOffset].m_ItemID, m_Slots[c_CraftOffset].m_ItemHealth, m_Slots[c_CraftOffset].m_ItemCount );
SendWholeInventory( m_Owner->GetClientHandle() ); SendWholeInventory(m_Owner->GetClientHandle());
} }
SendSlot(0); SendSlot(0);
} }
@ -116,32 +118,31 @@ void cSurvivalInventory::Clicked( cPacket* a_ClickPacket )
void cSurvivalInventory::ShiftClicked(cPacket_WindowClick * a_ClickPacket) void cSurvivalInventory::ShiftClicked(short a_SlotNum)
{ {
ASSERT((GetWindow() == NULL) || (GetWindow()->GetDraggingItem()->IsEmpty())); // Cannot handle shift-click if dragging something ASSERT((GetWindow() == NULL) || (GetWindow()->GetDraggingItem()->IsEmpty())); // Cannot handle shift-click if dragging something
short Slot = a_ClickPacket->m_SlotNum; if (a_SlotNum == SLOT_CRAFTING_RESULT)
if (Slot == SLOT_CRAFTING_RESULT)
{ {
ShiftClickedCraftingResult(Slot); ShiftClickedCraftingResult(a_SlotNum);
} }
else if ((Slot >= SLOT_CRAFTING_MIN) && (Slot <= SLOT_CRAFTING_MAX)) else if ((a_SlotNum >= SLOT_CRAFTING_MIN) && (a_SlotNum <= SLOT_CRAFTING_MAX))
{ {
ShiftClickedCraftingGrid(Slot); ShiftClickedCraftingGrid(a_SlotNum);
} }
else if ((Slot >= SLOT_ARMOR_MIN) && (Slot <= SLOT_ARMOR_MAX)) else if ((a_SlotNum >= SLOT_ARMOR_MIN) && (a_SlotNum <= SLOT_ARMOR_MAX))
{ {
ShiftClickedArmor(Slot); ShiftClickedArmor(a_SlotNum);
} }
else if ((Slot >= SLOT_HOTBAR_MIN) && (Slot <= SLOT_HOTBAR_MAX)) else if ((a_SlotNum >= SLOT_HOTBAR_MIN) && (a_SlotNum <= SLOT_HOTBAR_MAX))
{ {
ShiftClickedHotbar(Slot); ShiftClickedHotbar(a_SlotNum);
} }
else else
{ {
ShiftClickedInventory(Slot); ShiftClickedInventory(a_SlotNum);
} }
// Because the client tries to guess our actions, not always right, send the whole inventory: // Because the client tries to guess our actions and is not always right, send the whole inventory:
SendWholeInventoryToAll(); SendWholeInventoryToAll();
} }
@ -182,7 +183,7 @@ void cSurvivalInventory::ShiftClickedCraftingResult(short a_Slot)
m_Slots[SLOT_CRAFTING_RESULT] = Recipe.GetResult(); m_Slots[SLOT_CRAFTING_RESULT] = Recipe.GetResult();
// If the recipe changed, abort: // If the recipe changed, abort:
if (!Recipe.GetResult().Equals(ResultCopy)) if (!Recipe.GetResult().IsEqual(ResultCopy))
{ {
break; break;
} }

8
source/cSurvivalInventory.h
View File

@ -28,8 +28,8 @@ class cSurvivalInventory //tolua_export
SLOT_HOTBAR_MAX = 44, SLOT_HOTBAR_MAX = 44,
} ; } ;
void ShiftClickedCraftingResult(short a_Slot); void ShiftClickedCraftingResult(short a_SlotNum);
void ShiftClickedCraftingGrid (short a_Slot); void ShiftClickedCraftingGrid (short a_SlotNum);
void ShiftClickedArmor (short a_Slot); void ShiftClickedArmor (short a_Slot);
void ShiftClickedHotbar (short a_Slot); void ShiftClickedHotbar (short a_Slot);
void ShiftClickedInventory (short a_Slot); void ShiftClickedInventory (short a_Slot);
@ -38,9 +38,9 @@ public:
cSurvivalInventory(cPlayer* a_Owner); cSurvivalInventory(cPlayer* a_Owner);
~cSurvivalInventory(); ~cSurvivalInventory();
virtual void Clicked(cPacket * a_ClickPacket) override; virtual void Clicked(short a_SlotNum, bool a_IsRightClick, bool a_IsShiftPressed, const cItem & a_HeldItem) override;
void ShiftClicked(cPacket_WindowClick * a_ClickPacket); void ShiftClicked(short a_SlotNum);
}; //tolua_export }; //tolua_export

145
source/cWindow.cpp
View File

@ -8,8 +8,8 @@
#include "cPickup.h" #include "cPickup.h"
#include "cInventory.h" #include "cInventory.h"
#include "cWindowOwner.h" #include "cWindowOwner.h"
#include "items/Item.h"
#include "packets/cPacket_WindowClick.h"
#include "packets/cPacket_WholeInventory.h" #include "packets/cPacket_WholeInventory.h"
#include "packets/cPacket_WindowOpen.h" #include "packets/cPacket_WindowOpen.h"
#include "packets/cPacket_WindowClose.h" #include "packets/cPacket_WindowClose.h"
@ -84,11 +84,15 @@ cItem* cWindow::GetDraggingItem( cPlayer * a_Player /* = 0 */ )
void cWindow::Clicked( cPacket_WindowClick* a_ClickPacket, cPlayer & a_Player ) void cWindow::Clicked(
cPlayer & a_Player,
int a_WindowID, short a_SlotNum, bool a_IsRightClick, bool a_IsShiftPressed,
const cItem & a_HeldItem
)
{ {
if (a_ClickPacket->m_WindowID != m_WindowID) if (a_WindowID != m_WindowID)
{ {
LOG("WRONG WINDOW ID! (exp %d, got %d)", m_WindowID, a_ClickPacket->m_WindowID); LOG("WRONG WINDOW ID! (exp %d, got %d) received from \"%s\"", m_WindowID, a_WindowID, a_Player.GetName().c_str());
return; return;
} }
@ -101,111 +105,118 @@ void cWindow::Clicked( cPacket_WindowClick* a_ClickPacket, cPlayer & a_Player )
} }
} }
bool bAsync = false; bool bAsync = false;
if (a_ClickPacket->m_SlotNum == -999) // Outside window click if (a_SlotNum == -999) // Outside window click
{ {
if (a_ClickPacket->m_RightMouse) if (a_IsRightClick)
{ {
a_Player.TossItem( true ); a_Player.TossItem(true);
} }
else else
{ {
a_Player.TossItem( true, m_DraggingItem->m_ItemCount ); a_Player.TossItem(true, m_DraggingItem->m_ItemCount);
} }
} }
else if (GetSlot(a_ClickPacket->m_SlotNum) != NULL) else if (GetSlot(a_SlotNum) != NULL)
{ {
cItem * Item = GetSlot(a_ClickPacket->m_SlotNum); cItem * Item = GetSlot(a_SlotNum);
if ( if (!Item->IsEqual(a_HeldItem))
(a_ClickPacket->m_ItemID != Item->m_ItemID) ||
(a_ClickPacket->m_ItemCount != Item->m_ItemCount) ||
(a_ClickPacket->m_ItemUses != Item->m_ItemHealth)
)
{ {
if (!((a_ClickPacket->m_ItemID == -1 || a_ClickPacket->m_ItemID == 0) && (Item->m_ItemID == -1 || Item->m_ItemID == 0 )) ) LOGD("*** Window lost sync ***");
{ LOGD("My Type: %i Their Type: %i", Item->m_ItemID, a_HeldItem.m_ItemID);
LOGD("My ID: %i Their ID: %i", Item->m_ItemID, a_ClickPacket->m_ItemID ); LOGD("My Count: %i Their Count: %i", Item->m_ItemCount, a_HeldItem.m_ItemCount);
LOGD("My Count: %i Their Count: %i", Item->m_ItemCount, a_ClickPacket->m_ItemCount ); LOGD("My Dmg: %i Their Dmg: %i", Item->m_ItemHealth, a_HeldItem.m_ItemHealth);
LOGD("My Uses: %i Their Uses: %i", Item->m_ItemHealth, a_ClickPacket->m_ItemUses ); bAsync = true;
bAsync = true;
}
} }
} }
if (m_DraggingItem && (a_ClickPacket->m_SlotNum > -1) && (a_ClickPacket->m_SlotNum < m_NumSlots)) if (m_DraggingItem && (a_SlotNum > -1) && (a_SlotNum < m_NumSlots))
{ {
if (a_ClickPacket->m_RightMouse == 0) if (!a_IsRightClick)
{ {
if (!m_DraggingItem->Equals(m_Slots[a_ClickPacket->m_SlotNum])) // Left-clicked
if (!m_DraggingItem->IsEqual(m_Slots[a_SlotNum]))
{ {
// Switch contents
cItem tmp(*m_DraggingItem); cItem tmp(*m_DraggingItem);
*m_DraggingItem = m_Slots[a_ClickPacket->m_SlotNum]; *m_DraggingItem = m_Slots[a_SlotNum];
m_Slots[a_ClickPacket->m_SlotNum] = tmp; // Switch contents m_Slots[a_SlotNum] = tmp;
} }
else else
{ {
int FreeSlots = 64 - m_Slots[a_ClickPacket->m_SlotNum].m_ItemCount; // Same type, add items:
int Filling = (FreeSlots > m_DraggingItem->m_ItemCount) ? m_DraggingItem->m_ItemCount : FreeSlots; cItemHandler * Handler = ItemHandler(m_DraggingItem->m_ItemID);
m_Slots[a_ClickPacket->m_SlotNum].m_ItemCount += (char)Filling; int FreeSlots = Handler->GetMaxStackSize() - m_Slots[a_SlotNum].m_ItemCount;
m_DraggingItem->m_ItemCount -= (char)Filling; if (FreeSlots < 0)
if( m_DraggingItem->m_ItemCount <= 0 )
m_DraggingItem->Empty();
}
}
else // Right clicked
{
if( m_DraggingItem->m_ItemID <= 0 ) // Empty?
{
m_DraggingItem->m_ItemCount = (char)(((float)m_Slots[a_ClickPacket->m_SlotNum].m_ItemCount)/2.f + 0.5f);
m_Slots[a_ClickPacket->m_SlotNum].m_ItemCount -= m_DraggingItem->m_ItemCount;
m_DraggingItem->m_ItemID = m_Slots[a_ClickPacket->m_SlotNum].m_ItemID;
m_DraggingItem->m_ItemHealth = m_Slots[a_ClickPacket->m_SlotNum].m_ItemHealth;
if( m_Slots[a_ClickPacket->m_SlotNum].m_ItemCount <= 0 )
{ {
m_Slots[a_ClickPacket->m_SlotNum].Empty(); ASSERT(!"Bad item stack size - where did we get more items in a slot than allowed?");
FreeSlots = 0;
}
int Filling = (FreeSlots > m_DraggingItem->m_ItemCount) ? m_DraggingItem->m_ItemCount : FreeSlots;
m_Slots[a_SlotNum].m_ItemCount += (char)Filling;
m_DraggingItem->m_ItemCount -= (char)Filling;
if (m_DraggingItem->m_ItemCount <= 0)
{
m_DraggingItem->Empty();
} }
} }
else if( m_Slots[a_ClickPacket->m_SlotNum].m_ItemID <= 0 || m_DraggingItem->Equals( m_Slots[a_ClickPacket->m_SlotNum] ) ) }
{ // Drop one item in slot else
if( m_DraggingItem->m_ItemCount > 0 && m_Slots[a_ClickPacket->m_SlotNum].m_ItemCount < 64 ) {
// Right clicked
if (m_DraggingItem->m_ItemID <= 0) // Empty-handed?
{
m_DraggingItem->m_ItemCount = (char)(((float)m_Slots[a_SlotNum].m_ItemCount) / 2.f + 0.5f);
m_Slots[a_SlotNum].m_ItemCount -= m_DraggingItem->m_ItemCount;
m_DraggingItem->m_ItemID = m_Slots[a_SlotNum].m_ItemID;
m_DraggingItem->m_ItemHealth = m_Slots[a_SlotNum].m_ItemHealth;
if (m_Slots[a_SlotNum].m_ItemCount <= 0)
{ {
m_Slots[a_ClickPacket->m_SlotNum].m_ItemID = m_DraggingItem->m_ItemID; m_Slots[a_SlotNum].Empty();
m_Slots[a_ClickPacket->m_SlotNum].m_ItemCount++; }
m_Slots[a_ClickPacket->m_SlotNum].m_ItemHealth = m_DraggingItem->m_ItemHealth; }
else if ((m_Slots[a_SlotNum].m_ItemID <= 0) || m_DraggingItem->IsEqual(m_Slots[a_SlotNum]))
{
// Drop one item in slot
cItemHandler * Handler = ItemHandler(m_Slots[a_SlotNum].m_ItemID);
if ((m_DraggingItem->m_ItemCount > 0) && (m_Slots[a_SlotNum].m_ItemCount < Handler->GetMaxStackSize()))
{
m_Slots[a_SlotNum].m_ItemID = m_DraggingItem->m_ItemID;
m_Slots[a_SlotNum].m_ItemCount++;
m_Slots[a_SlotNum].m_ItemHealth = m_DraggingItem->m_ItemHealth;
m_DraggingItem->m_ItemCount--; m_DraggingItem->m_ItemCount--;
} }
if( m_DraggingItem->m_ItemCount <= 0 ) if (m_DraggingItem->m_ItemCount <= 0)
{ {
m_DraggingItem->Empty(); m_DraggingItem->Empty();
} }
} }
else if( !m_DraggingItem->Equals( m_Slots[a_ClickPacket->m_SlotNum]) ) // Swap contents else if (!m_DraggingItem->IsEqual(m_Slots[a_SlotNum]))
{ {
// Swap contents
cItem tmp( *m_DraggingItem ); cItem tmp( *m_DraggingItem );
*m_DraggingItem = m_Slots[a_ClickPacket->m_SlotNum]; *m_DraggingItem = m_Slots[a_SlotNum];
m_Slots[a_ClickPacket->m_SlotNum] = tmp; // Switch contents m_Slots[a_SlotNum] = tmp;
} }
} }
if( bAsync ) if (bAsync)
{ {
LOG("Window is not synchonous with client. Sending whole window. ID: %i", m_WindowID); // TODO: Handle this thread-safely (m_OpenedBy may change by another cSocketThread
for( std::list< cPlayer* >::iterator itr = m_OpenedBy.begin(); itr != m_OpenedBy.end(); ++itr ) for (cPlayerList::iterator itr = m_OpenedBy.begin(); itr != m_OpenedBy.end(); ++itr)
{ {
SendWholeWindow( (*itr)->GetClientHandle() ); SendWholeWindow((*itr)->GetClientHandle());
} }
if( m_bInventoryVisible || m_OpenedBy.size() == 0 ) if (m_bInventoryVisible || m_OpenedBy.empty())
{ {
a_Player.GetInventory().SendWholeInventory( a_Player.GetClientHandle() ); a_Player.GetInventory().SendWholeInventory( a_Player.GetClientHandle() );
} }
} }
} }
else if( m_bInventoryVisible ) // Click in player inventory else if (m_bInventoryVisible) // Click in player inventory
{ {
a_ClickPacket->m_WindowID = 0; cWindow * Window = a_Player.GetInventory().GetWindow();
a_ClickPacket->m_SlotNum -= (short)(m_NumSlots - 9); if (Window)
cWindow* Window = a_Player.GetInventory().GetWindow();
if( Window )
{ {
Window->Clicked( a_ClickPacket, a_Player ); Window->Clicked(a_Player, a_WindowID, a_SlotNum - 9, a_IsRightClick, a_IsShiftPressed, a_HeldItem);
} }
} }
if (m_DraggingItem != NULL) if (m_DraggingItem != NULL)

11
source/cWindow.h
View File

@ -10,12 +10,11 @@
#pragma once #pragma once
class cPacket_WindowClick;
class cPlayer; class cPlayer;
class cItem; class cItem;
class cWindowOwner; class cWindowOwner;
class cClientHandle; class cClientHandle;
class cPacket; class cPacket; // TODO: remove this
typedef std::list<cPlayer *> cPlayerList; typedef std::list<cPlayer *> cPlayerList;
@ -63,7 +62,11 @@ public:
bool IsInventoryVisible() { return m_bInventoryVisible; } bool IsInventoryVisible() { return m_bInventoryVisible; }
void SetInventoryVisible( bool a_bVisible ) { m_bInventoryVisible = a_bVisible; } void SetInventoryVisible( bool a_bVisible ) { m_bInventoryVisible = a_bVisible; }
virtual void Clicked( cPacket_WindowClick* a_ClickPacket, cPlayer & a_Player ); virtual void Clicked(
cPlayer & a_Player, int a_WindowID,
short a_SlotNum, bool a_IsRightClick, bool a_IsShiftPressed,
const cItem & a_HeldItem
);
virtual void Open( cPlayer & a_Player ); virtual void Open( cPlayer & a_Player );
virtual void Close( cPlayer & a_Player ); virtual void Close( cPlayer & a_Player );
@ -71,7 +74,7 @@ public:
cWindowOwner* GetOwner() { return m_Owner; } cWindowOwner* GetOwner() { return m_Owner; }
void SetOwner( cWindowOwner* a_Owner ) { m_Owner = a_Owner; } void SetOwner( cWindowOwner* a_Owner ) { m_Owner = a_Owner; }
void SendWholeWindow( cClientHandle* a_Client ); void SendWholeWindow(cClientHandle * a_Client);
void BroadcastWholeWindow(void); void BroadcastWholeWindow(void);
void Broadcast(const cPacket & a_Packet); void Broadcast(const cPacket & a_Packet);

2
source/items/Item.h
View File

@ -19,7 +19,7 @@ class cItemHandler
public: public:
cItemHandler(int a_ItemID); cItemHandler(int a_ItemID);
virtual bool OnItemUse(cWorld *a_World, cPlayer *a_Player, cItem *a_Item, int a_X, int a_Y, int a_Z, char a_Dir); //eg for fishing or hoes virtual bool OnItemUse(cWorld *a_World, cPlayer *a_Player, cItem *a_Item, int a_X, int a_Y, int a_Z, char a_Dir); //eg for fishing or hoes
virtual bool OnDiggingBlock(cWorld *a_World, cPlayer *a_Player, cItem *a_Item, int a_X, int a_Y, int a_Z, char a_Dir); virtual bool OnDiggingBlock(cWorld * a_World, cPlayer * a_Player, cItem * a_HeldItem, int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace);
virtual void OnBlockDestroyed(cWorld *a_World, cPlayer *a_Player, cItem *a_Item, int a_X, int a_Y, int a_Z); virtual void OnBlockDestroyed(cWorld *a_World, cPlayer *a_Player, cItem *a_Item, int a_X, int a_Y, int a_Z);
virtual void OnFoodEaten(cWorld *a_World, cPlayer *a_Player, cItem *a_Item); virtual void OnFoodEaten(cWorld *a_World, cPlayer *a_Player, cItem *a_Item);

32
source/packets/cPacket_BlockDig.h
View File

@ -1,31 +1,37 @@
#pragma once #pragma once
#include "cPacket.h" #include "cPacket.h"
class cPacket_BlockDig : public cPacket //tolua_export
{ //tolua_export
class cPacket_BlockDig :
public cPacket
{
public: public:
cPacket_BlockDig() //tolua_export cPacket_BlockDig()
: m_Status( 0 ) : m_Status( 0 )
, m_PosX( 0 ) , m_PosX( 0 )
, m_PosY( 0 ) , m_PosY( 0 )
, m_PosZ( 0 ) , m_PosZ( 0 )
, m_Direction( 0 ) , m_Direction( 0 )
{ m_PacketID = E_BLOCK_DIG; } //tolua_export {
virtual cPacket* Clone() const { return new cPacket_BlockDig(*this); } //tolua_export m_PacketID = E_BLOCK_DIG;
}
virtual cPacket* Clone() const { return new cPacket_BlockDig(*this); }
virtual int Parse(cByteBuffer & a_Buffer) override; virtual int Parse(cByteBuffer & a_Buffer) override;
virtual void Serialize(AString & a_Data) const override; virtual void Serialize(AString & a_Data) const override;
char m_Status; // tolua_export char m_Status;
int m_PosX; // tolua_export int m_PosX;
char m_PosY; // tolua_export char m_PosY;
int m_PosZ; // tolua_export int m_PosZ;
char m_Direction; // tolua_export char m_Direction;
};
static const unsigned int c_Size = 12;
}; //tolua_export

7
source/packets/cPacket_BlockPlace.cpp
View File

@ -16,18 +16,13 @@ int cPacket_BlockPlace::Parse(cByteBuffer & a_Buffer)
HANDLE_PACKET_READ(ReadBEInt, m_PosZ, TotalBytes); HANDLE_PACKET_READ(ReadBEInt, m_PosZ, TotalBytes);
HANDLE_PACKET_READ(ReadChar, m_Direction, TotalBytes); HANDLE_PACKET_READ(ReadChar, m_Direction, TotalBytes);
cPacket_ItemData Item; cPacket_ItemData Item(m_HeldItem);
int res = Item.Parse(a_Buffer); int res = Item.Parse(a_Buffer);
if (res < 0) if (res < 0)
{ {
return res; return res;
} }
TotalBytes += res; TotalBytes += res;
m_ItemType = Item.m_ItemID;
m_Count = Item.m_ItemCount;
m_Uses = Item.m_ItemUses;
return TotalBytes; return TotalBytes;
} }

30
source/packets/cPacket_BlockPlace.h
View File

@ -2,38 +2,36 @@
#pragma once #pragma once
#include "cPacket.h" #include "cPacket.h"
#include "../cItem.h"
class cPacket_BlockPlace : public cPacket //tolua_export class cPacket_BlockPlace :
{ //tolua_export public cPacket
{
public: public:
cPacket_BlockPlace() cPacket_BlockPlace()
: m_PosX( 0 ) : m_PosX( 0 )
, m_PosY( 0 ) , m_PosY( 0 )
, m_PosZ( 0 ) , m_PosZ( 0 )
, m_Direction( 0 ) , m_Direction( 0 )
, m_ItemType( 0 ) {
, m_Count( 0 ) m_PacketID = E_BLOCK_PLACE;
, m_Uses( 0 ) }
{ m_PacketID = E_BLOCK_PLACE; }
virtual cPacket* Clone() const { return new cPacket_BlockPlace(*this); } virtual cPacket* Clone() const { return new cPacket_BlockPlace(*this); }
virtual int Parse(cByteBuffer & a_Buffer) override; virtual int Parse(cByteBuffer & a_Buffer) override;
int m_PosX; //tolua_export int m_PosX;
unsigned char m_PosY; //tolua_export unsigned char m_PosY;
int m_PosZ; //tolua_export int m_PosZ;
char m_Direction; //tolua_export char m_Direction;
short m_ItemType; //tolua_export cItem m_HeldItem;
char m_Count; //tolua_export } ;
short m_Uses; //tolua_export
static const unsigned int c_Size = 1 + 4 + 1 + 4 + 1 + 2;// ( + 2 )
}; //tolua_export

32
source/packets/cPacket_CreativeInventoryAction.cpp
View File

@ -10,11 +10,9 @@
cPacket_CreativeInventoryAction::cPacket_CreativeInventoryAction( const cPacket_CreativeInventoryAction & a_Copy ) cPacket_CreativeInventoryAction::cPacket_CreativeInventoryAction( const cPacket_CreativeInventoryAction & a_Copy )
{ {
m_PacketID = E_CREATIVE_INVENTORY_ACTION; m_PacketID = E_CREATIVE_INVENTORY_ACTION;
m_Slot = a_Copy.m_Slot; m_SlotNum = a_Copy.m_SlotNum;
m_ItemID = a_Copy.m_ItemID; m_ClickedItem = a_Copy.m_ClickedItem;
m_Quantity = a_Copy.m_Quantity;
m_Damage = a_Copy.m_Damage;
} }
@ -24,20 +22,15 @@ cPacket_CreativeInventoryAction::cPacket_CreativeInventoryAction( const cPacket_
int cPacket_CreativeInventoryAction::Parse(cByteBuffer & a_Buffer) int cPacket_CreativeInventoryAction::Parse(cByteBuffer & a_Buffer)
{ {
int TotalBytes = 0; int TotalBytes = 0;
HANDLE_PACKET_READ(ReadBEShort, m_Slot, TotalBytes); HANDLE_PACKET_READ(ReadBEShort, m_SlotNum, TotalBytes);
cPacket_ItemData Item; cPacket_ItemData Item(m_ClickedItem);
int res = Item.Parse(a_Buffer); int res = Item.Parse(a_Buffer);
if (res < 0) if (res < 0)
{ {
return res; return res;
} }
TotalBytes += res; TotalBytes += res;
m_ItemID = Item.m_ItemID;
m_Quantity = Item.m_ItemCount;
m_Damage = Item.m_ItemUses;
return TotalBytes; return TotalBytes;
} }
@ -47,19 +40,10 @@ int cPacket_CreativeInventoryAction::Parse(cByteBuffer & a_Buffer)
void cPacket_CreativeInventoryAction::Serialize(AString & a_Data) const void cPacket_CreativeInventoryAction::Serialize(AString & a_Data) const
{ {
short ItemID = m_ItemID; AppendByte (a_Data, m_PacketID);
ASSERT(ItemID >= -1); // Check validity of packets in debug runtime AppendShort(a_Data, m_SlotNum);
if (ItemID <= 0)
{
ItemID = -1;
// Fix, to make sure no invalid values are sent.
// WARNING: HERE ITS -1, BUT IN NAMED ENTITY SPAWN PACKET ITS 0 !!
}
AppendByte (a_Data, m_PacketID); cPacket_ItemData::AppendItem(a_Data, m_ClickedItem);
AppendShort (a_Data, m_Slot);
cPacket_ItemData::AppendItem(a_Data, ItemID, m_Quantity, m_Damage);
} }

28
source/packets/cPacket_CreativeInventoryAction.h
View File

@ -2,35 +2,31 @@
#pragma once #pragma once
#include "cPacket.h" #include "cPacket.h"
#include "../cItem.h"
//Sure it´s not Creative Inventory? class cPacket_CreativeInventoryAction :
public cPacket
class cPacket_CreativeInventoryAction : public cPacket
{ {
public: public:
cPacket_CreativeInventoryAction() cPacket_CreativeInventoryAction() :
: m_Slot( 0 ) m_SlotNum(0)
, m_ItemID( 0 ) {
, m_Quantity( 0 ) m_PacketID = E_CREATIVE_INVENTORY_ACTION;
, m_Damage( 0 ) }
{ m_PacketID = E_CREATIVE_INVENTORY_ACTION; m_Quantity = 1; }
cPacket_CreativeInventoryAction( const cPacket_CreativeInventoryAction & a_Copy ); cPacket_CreativeInventoryAction( const cPacket_CreativeInventoryAction & a_Copy );
virtual cPacket* Clone() const { return new cPacket_CreativeInventoryAction(*this); } virtual cPacket* Clone() const { return new cPacket_CreativeInventoryAction(*this); }
virtual int Parse(cByteBuffer & a_Buffer) override; virtual int Parse(cByteBuffer & a_Buffer) override;
virtual void Serialize(AString & a_Data) const override; virtual void Serialize(AString & a_Data) const override;
short m_Slot; // 0 = hold 1-4 = armor short m_SlotNum;
short m_ItemID; cItem m_ClickedItem;
char m_Quantity; //Byte not short ;) } ;
short m_Damage;
static const unsigned int c_Size = 1 + 2;
};

1
source/packets/cPacket_Handshake.h
View File

@ -17,7 +17,6 @@ public:
virtual void Serialize(AString & a_Data) const override; virtual void Serialize(AString & a_Data) const override;
std::string m_Username; std::string m_Username;
static const unsigned int c_Size = 3; // Minimal size
}; };

39
source/packets/cPacket_ItemData.cpp
View File

@ -10,25 +10,26 @@
int cPacket_ItemData::Parse(cByteBuffer & a_Buffer) int cPacket_ItemData::Parse(cByteBuffer & a_Buffer)
{ {
int TotalBytes = 0; int TotalBytes = 0;
HANDLE_PACKET_READ(ReadBEShort, m_ItemID, TotalBytes); HANDLE_PACKET_READ(ReadBEShort, m_Dst.m_ItemType, TotalBytes);
if (m_ItemID <= -1) if (m_Dst.m_ItemType <= -1)
{ {
m_ItemCount = 0; m_Dst.Empty();
m_ItemUses = 0;
return TotalBytes; return TotalBytes;
} }
HANDLE_PACKET_READ(ReadChar, m_ItemCount, TotalBytes); HANDLE_PACKET_READ(ReadChar, m_Dst.m_ItemCount, TotalBytes);
HANDLE_PACKET_READ(ReadBEShort, m_ItemUses, TotalBytes); HANDLE_PACKET_READ(ReadBEShort, m_Dst.m_ItemDamage, TotalBytes);
if (cItem::IsEnchantable((ENUM_ITEM_ID) m_ItemID)) if (cItem::IsEnchantable(m_Dst.m_ItemType))
{ {
HANDLE_PACKET_READ(ReadBEShort, m_EnchantNums, TotalBytes); short EnchantNumBytes;
HANDLE_PACKET_READ(ReadBEShort, EnchantNumBytes, TotalBytes);
if ( m_EnchantNums > -1 ) if (EnchantNumBytes > 0)
{ {
// TODO: Enchantment not implemented yet! // TODO: Enchantment not implemented yet!
a_Buffer.SkipRead(EnchantNumBytes);
} }
} }
return TotalBytes; return TotalBytes;
@ -51,24 +52,32 @@ int cPacket_ItemData::GetSize(short a_ItemID)
void cPacket_ItemData::AppendItem(AString & a_Data, const cItem * a_Item) void cPacket_ItemData::AppendItem(AString & a_Data, const cItem & a_Item)
{ {
return AppendItem(a_Data, a_Item->m_ItemID, a_Item->m_ItemCount, a_Item->m_ItemHealth); return AppendItem(a_Data, a_Item.m_ItemType, a_Item.m_ItemCount, a_Item.m_ItemDamage);
} }
void cPacket_ItemData::AppendItem(AString & a_Data, short a_ItemID, char a_Quantity, short a_Damage) void cPacket_ItemData::AppendItem(AString & a_Data, short a_ItemType, char a_Quantity, short a_Damage)
{ {
AppendShort(a_Data, (short) a_ItemID); short ItemType = a_ItemType;
if (a_ItemID > -1) ASSERT(ItemType >= -1); // Check validity of packets in debug runtime
if (ItemType <= 0)
{
// Fix, to make sure no invalid values are sent.
ItemType = -1;
}
AppendShort(a_Data, ItemType);
if (a_ItemType > -1)
{ {
AppendByte (a_Data, a_Quantity); AppendByte (a_Data, a_Quantity);
AppendShort(a_Data, a_Damage); AppendShort(a_Data, a_Damage);
if (cItem::IsEnchantable((ENUM_ITEM_ID) a_ItemID)) if (cItem::IsEnchantable(a_ItemType))
{ {
// TODO: Implement enchantments // TODO: Implement enchantments
AppendShort(a_Data, (short) -1); AppendShort(a_Data, (short) -1);

29
source/packets/cPacket_ItemData.h
View File

@ -1,35 +1,34 @@
#pragma once #pragma once
#include "cPacket.h" #include "cPacket.h"
#include "../cItem.h" #include "../cItem.h"
class cPacket_ItemData : public cPacket class cPacket_ItemData : public cPacket
{ {
cItem & m_Dst;
public: public:
cPacket_ItemData() cPacket_ItemData(cItem & a_Dst) :
: m_ItemID( 0 ) m_Dst(a_Dst)
, m_ItemCount( 0 )
, m_ItemUses( 0 )
, m_EnchantNums(-1)
{ {
} }
virtual cPacket* Clone() const { return new cPacket_ItemData(*this); } virtual cPacket * Clone() const { return new cPacket_ItemData(*this); }
virtual int Parse(cByteBuffer & a_Buffer) override; virtual int Parse(cByteBuffer & a_Buffer) override;
static void AppendItem(AString & a_Data, short a_ItemID, char a_Quantity, short a_Damage); static void AppendItem(AString & a_Data, short a_ItemType, char a_Quantity, short a_Damage);
static void AppendItem(AString & a_Data, const cItem * a_Item); static void AppendItem(AString & a_Data, const cItem & a_Item);
int GetSize(short a_ItemID); int GetSize(short a_ItemID);
} ;
// Below = item
short m_ItemID; // if this is -1 the next stuff dont exist
char m_ItemCount;
short m_ItemUses;
short m_EnchantNums;
static unsigned int c_Size; // Minimal size ( +1+1 = max)
};

5
source/packets/cPacket_Login.cpp
View File

@ -7,8 +7,8 @@
const std::string cPacket_Login::LEVEL_TYPE_DEFAULT = "DEFAULT"; const char * cPacket_Login::LEVEL_TYPE_DEFAULT = "DEFAULT";
const std::string cPacket_Login::LEVEL_TYPE_SUPERFLAT = "SUPERFLAT"; const char * cPacket_Login::LEVEL_TYPE_SUPERFLAT = "SUPERFLAT";
@ -16,7 +16,6 @@ const std::string cPacket_Login::LEVEL_TYPE_SUPERFLAT = "SUPERFLAT";
int cPacket_Login::Parse(cByteBuffer & a_Buffer) int cPacket_Login::Parse(cByteBuffer & a_Buffer)
{ {
//printf("Parse: NEW Login\n");
int TotalBytes = 0; int TotalBytes = 0;
m_Username.clear(); m_Username.clear();
HANDLE_PACKET_READ(ReadBEInt, m_ProtocolVersion, TotalBytes); HANDLE_PACKET_READ(ReadBEInt, m_ProtocolVersion, TotalBytes);

26
source/packets/cPacket_Login.h
View File

@ -7,8 +7,8 @@
class cPacket_Login : public cPacket //tolua_export class cPacket_Login : public cPacket
{ //tolua_export {
public: public:
cPacket_Login() cPacket_Login()
: m_ProtocolVersion( 0 ) : m_ProtocolVersion( 0 )
@ -24,18 +24,18 @@ public:
virtual int Parse(cByteBuffer & a_Buffer) override; virtual int Parse(cByteBuffer & a_Buffer) override;
virtual void Serialize(AString & a_Data) const override; virtual void Serialize(AString & a_Data) const override;
int m_ProtocolVersion; //tolua_export int m_ProtocolVersion;
AString m_Username; //tolua_export AString m_Username;
AString m_LevelType; //tolua_export AString m_LevelType;
int m_ServerMode; //tolua_export int m_ServerMode;
int m_Dimension; int m_Dimension;
char m_Difficulty; //tolua_export char m_Difficulty;
unsigned char m_WorldHeight; //tolua_export unsigned char m_WorldHeight;
unsigned char m_MaxPlayers; //tolua_export unsigned char m_MaxPlayers;
static const AString LEVEL_TYPE_DEFAULT; static const char * LEVEL_TYPE_DEFAULT;
static const AString LEVEL_TYPE_SUPERFLAT; static const char * LEVEL_TYPE_SUPERFLAT;
}; //tolua_export };

24
source/packets/cPacket_Player.cpp
View File

@ -195,15 +195,15 @@ void cPacket_PlayerMoveLook::Serialize(AString & a_Data) const
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// cPacket_PlayerPosition: // cPacket_PlayerPosition:
cPacket_PlayerPosition::cPacket_PlayerPosition( cPlayer* a_Player ) cPacket_PlayerPosition::cPacket_PlayerPosition(cPlayer * a_Player)
{ {
m_PacketID = E_PLAYERPOS; m_PacketID = E_PLAYERPOS;
m_PosX = a_Player->GetPosX(); m_PosX = a_Player->GetPosX();
m_PosY = a_Player->GetPosY() + 1.65; m_PosY = a_Player->GetPosY() + 1.65;
m_PosZ = a_Player->GetPosZ(); m_PosZ = a_Player->GetPosZ();
m_Stance = a_Player->GetStance(); m_Stance = a_Player->GetStance();
m_bFlying = a_Player->GetFlying(); m_IsOnGround = a_Player->IsOnGround();
} }
@ -213,11 +213,11 @@ cPacket_PlayerPosition::cPacket_PlayerPosition( cPlayer* a_Player )
int cPacket_PlayerPosition::Parse(cByteBuffer & a_Buffer) int cPacket_PlayerPosition::Parse(cByteBuffer & a_Buffer)
{ {
int TotalBytes = 0; int TotalBytes = 0;
HANDLE_PACKET_READ(ReadBEDouble, m_PosX, TotalBytes); HANDLE_PACKET_READ(ReadBEDouble, m_PosX, TotalBytes);
HANDLE_PACKET_READ(ReadBEDouble, m_PosY, TotalBytes); HANDLE_PACKET_READ(ReadBEDouble, m_PosY, TotalBytes);
HANDLE_PACKET_READ(ReadBEDouble, m_Stance, TotalBytes); HANDLE_PACKET_READ(ReadBEDouble, m_Stance, TotalBytes);
HANDLE_PACKET_READ(ReadBEDouble, m_PosZ, TotalBytes); HANDLE_PACKET_READ(ReadBEDouble, m_PosZ, TotalBytes);
HANDLE_PACKET_READ(ReadBool, m_bFlying, TotalBytes); HANDLE_PACKET_READ(ReadBool, m_IsOnGround, TotalBytes);
return TotalBytes; return TotalBytes;
} }
@ -232,7 +232,7 @@ void cPacket_PlayerPosition::Serialize(AString & a_Data) const
AppendDouble (a_Data, m_PosY); AppendDouble (a_Data, m_PosY);
AppendDouble (a_Data, m_Stance); AppendDouble (a_Data, m_Stance);
AppendDouble (a_Data, m_PosZ); AppendDouble (a_Data, m_PosZ);
AppendBool (a_Data, m_bFlying); AppendBool (a_Data, m_IsOnGround);
} }

8
source/packets/cPacket_Player.h
View File

@ -129,9 +129,9 @@ public:
cPacket_PlayerPosition() cPacket_PlayerPosition()
: m_PosX( 0.0 ) : m_PosX( 0.0 )
, m_PosY( 0.0 ) , m_PosY( 0.0 )
, m_Stance( 0.0 )
, m_PosZ( 0.0 ) , m_PosZ( 0.0 )
, m_bFlying( false ) , m_Stance( 0.0 )
, m_IsOnGround(true)
{ m_PacketID = E_PLAYERPOS; } { m_PacketID = E_PLAYERPOS; }
virtual cPacket* Clone() const { return new cPacket_PlayerPosition(*this); } virtual cPacket* Clone() const { return new cPacket_PlayerPosition(*this); }
@ -140,9 +140,9 @@ public:
double m_PosX; double m_PosX;
double m_PosY; double m_PosY;
double m_Stance;
double m_PosZ; double m_PosZ;
bool m_bFlying; // Yeah.. wtf double m_Stance;
bool m_IsOnGround;
} ; } ;

13
source/packets/cPacket_WholeInventory.cpp
View File

@ -17,19 +17,21 @@ cPacket_WholeInventory::cPacket_WholeInventory( const cPacket_WholeInventory & a
m_WindowID = a_Clone.m_WindowID; m_WindowID = a_Clone.m_WindowID;
m_Count = a_Clone.m_Count; m_Count = a_Clone.m_Count;
m_Items = new cItem[m_Count]; m_Items = new cItem[m_Count];
memcpy( m_Items, a_Clone.m_Items, sizeof(cItem)*m_Count ); // TODO: copy items one by one, they may have some values that needn't be shallow-copiable
memcpy(m_Items, a_Clone.m_Items, sizeof(cItem) * m_Count);
} }
cPacket_WholeInventory::cPacket_WholeInventory( cInventory* a_Inventory ) cPacket_WholeInventory::cPacket_WholeInventory(cInventory * a_Inventory)
{ {
m_PacketID = E_INVENTORY_WHOLE; m_PacketID = E_INVENTORY_WHOLE;
m_WindowID = 0; m_WindowID = 0;
m_Count = a_Inventory->c_NumSlots; m_Count = a_Inventory->c_NumSlots;
m_Items = new cItem[m_Count]; m_Items = new cItem[m_Count];
// TODO: copy items one by one, they may have some values that needn't be shallow-copiable
memcpy( m_Items, a_Inventory->GetSlots(), sizeof(cItem)*m_Count ); memcpy( m_Items, a_Inventory->GetSlots(), sizeof(cItem)*m_Count );
} }
@ -37,13 +39,14 @@ cPacket_WholeInventory::cPacket_WholeInventory( cInventory* a_Inventory )
cPacket_WholeInventory::cPacket_WholeInventory( cWindow* a_Window ) cPacket_WholeInventory::cPacket_WholeInventory(cWindow * a_Window)
{ {
m_PacketID = E_INVENTORY_WHOLE; m_PacketID = E_INVENTORY_WHOLE;
m_WindowID = (char)a_Window->GetWindowID(); m_WindowID = (char)a_Window->GetWindowID();
m_Count = (short)a_Window->GetNumSlots(); m_Count = (short)a_Window->GetNumSlots();
m_Items = new cItem[m_Count]; m_Items = new cItem[m_Count];
memcpy( m_Items, a_Window->GetSlots(), sizeof(cItem)*m_Count ); // TODO: copy items one by one, they may have some values that needn't be shallow-copiable
memcpy( m_Items, a_Window->GetSlots(), sizeof(cItem) * m_Count);
} }
@ -67,7 +70,7 @@ void cPacket_WholeInventory::Serialize(AString & a_Data) const
for (int j = 0; j < m_Count; j++) for (int j = 0; j < m_Count; j++)
{ {
cPacket_ItemData::AppendItem(a_Data, &(m_Items[j])); cPacket_ItemData::AppendItem(a_Data, m_Items[j]);
} }
} }

12
source/packets/cPacket_WindowClick.cpp
View File

@ -14,11 +14,11 @@ int cPacket_WindowClick::Parse(cByteBuffer & a_Buffer)
int TotalBytes = 0; int TotalBytes = 0;
HANDLE_PACKET_READ(ReadChar, m_WindowID, TotalBytes); HANDLE_PACKET_READ(ReadChar, m_WindowID, TotalBytes);
HANDLE_PACKET_READ(ReadBEShort, m_SlotNum, TotalBytes); HANDLE_PACKET_READ(ReadBEShort, m_SlotNum, TotalBytes);
HANDLE_PACKET_READ(ReadChar, m_RightMouse, TotalBytes); HANDLE_PACKET_READ(ReadBool, m_IsRightClick, TotalBytes);
HANDLE_PACKET_READ(ReadBEShort, m_NumClicks, TotalBytes); HANDLE_PACKET_READ(ReadBEShort, m_TransactionID, TotalBytes);
HANDLE_PACKET_READ(ReadBool, m_IsShiftPressed, TotalBytes); HANDLE_PACKET_READ(ReadBool, m_IsShiftPressed, TotalBytes);
cPacket_ItemData Item; cPacket_ItemData Item(m_HeldItem);
int res = Item.Parse(a_Buffer); int res = Item.Parse(a_Buffer);
if (res < 0) if (res < 0)
{ {
@ -26,12 +26,6 @@ int cPacket_WindowClick::Parse(cByteBuffer & a_Buffer)
} }
TotalBytes += res; TotalBytes += res;
m_ItemID = Item.m_ItemID;
m_ItemCount = Item.m_ItemCount;
m_ItemUses = Item.m_ItemUses;
m_EnchantNums = Item.m_EnchantNums;
return TotalBytes; return TotalBytes;
} }

33
source/packets/cPacket_WindowClick.h
View File

@ -2,6 +2,7 @@
#pragma once #pragma once
#include "cPacket.h" #include "cPacket.h"
#include "../cItem.h"
@ -13,36 +14,24 @@ public:
cPacket_WindowClick() cPacket_WindowClick()
: m_WindowID( 0 ) : m_WindowID( 0 )
, m_SlotNum( 0 ) , m_SlotNum( 0 )
, m_RightMouse( 0 ) , m_IsRightClick(false)
, m_NumClicks( 0 ) , m_TransactionID( 0 )
, m_IsShiftPressed( false ) , m_IsShiftPressed( false )
, m_ItemID( 0 ) {
, m_ItemCount( 0 ) m_PacketID = E_WINDOW_CLICK;
, m_ItemUses( 0 ) }
, m_EnchantNums(-1)
{ m_PacketID = E_WINDOW_CLICK; }
virtual cPacket* Clone() const { return new cPacket_WindowClick(*this); } virtual cPacket* Clone() const { return new cPacket_WindowClick(*this); }
virtual int Parse(cByteBuffer & a_Buffer) override; virtual int Parse(cByteBuffer & a_Buffer) override;
char m_WindowID; char m_WindowID;
short m_SlotNum; // Slot short m_SlotNum;
// 0 = craft result bool m_IsRightClick;
// 1-4 = crafting table short m_TransactionID;
// 5-8 = armor
// 9-35 = inventory
// 36-44 = Hot bar
char m_RightMouse; // 0 = Left 1 = Right mb
short m_NumClicks; // Num clicks
bool m_IsShiftPressed; // Shift pressed when clicked? bool m_IsShiftPressed; // Shift pressed when clicked?
// Below = item cItem m_HeldItem;
short m_ItemID; // if this is -1 the next stuff dont exist
char m_ItemCount;
short m_ItemUses;
short m_EnchantNums;
}; };