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

Merge remote-tracking branch 'origin/pistonfixes'

Browse Source 
Conflicts:
	src/Chunk.cpp
This commit is contained in:
Tiger Wang 2014-06-02 19:49:14 +01:00
commit 5fc7592cba
15 changed files with 401 additions and 457 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/Blocks/BlockDropSpenser.h
View File

@ -5,7 +5,7 @@
#pragma once #pragma once
#include "../Piston.h" #include "../Blocks/BlockPiston.h"
#include "MetaRotator.h" #include "MetaRotator.h"
@ -32,7 +32,7 @@ public:
a_BlockType = m_BlockType; a_BlockType = m_BlockType;
// FIXME: Do not use cPiston class for dispenser placement! // FIXME: Do not use cPiston class for dispenser placement!
a_BlockMeta = cPiston::RotationPitchToMetaData(a_Player->GetYaw(), a_Player->GetPitch()); a_BlockMeta = cBlockPistonHandler::RotationPitchToMetaData(a_Player->GetYaw(), a_Player->GetPitch());
return true; return true;
} }

4
src/Blocks/BlockFurnace.h
View File

@ -3,7 +3,7 @@
#include "BlockEntity.h" #include "BlockEntity.h"
#include "../World.h" #include "../World.h"
#include "../Piston.h" #include "../Blocks/BlockPiston.h"
#include "MetaRotator.h" #include "MetaRotator.h"
@ -35,7 +35,7 @@ public:
a_BlockType = m_BlockType; a_BlockType = m_BlockType;
// FIXME: Do not use cPiston class for furnace placement! // FIXME: Do not use cPiston class for furnace placement!
a_BlockMeta = cPiston::RotationPitchToMetaData(a_Player->GetYaw(), 0); a_BlockMeta = cBlockPistonHandler::RotationPitchToMetaData(a_Player->GetYaw(), 0);
return true; return true;
} }

2
src/Blocks/BlockMobHead.h
View File

@ -68,7 +68,7 @@ public:
public: public:
cPlayerCallback(const Vector3f & a_Pos) : m_Pos(a_Pos) {} cPlayerCallback(const Vector3f & a_Pos) : m_Pos(a_Pos) {}
} PlayerCallback(Vector3f(a_BlockX, a_BlockY, a_BlockZ)); } PlayerCallback(Vector3f((float)a_BlockX, (float)a_BlockY, (float)a_BlockZ));
a_World->DoWithMobHeadAt(a_BlockX, a_BlockY, a_BlockZ, CallbackA); a_World->DoWithMobHeadAt(a_BlockX, a_BlockY, a_BlockZ, CallbackA);

177
src/Blocks/BlockPiston.cpp
View File

@ -4,14 +4,14 @@
#include "../Item.h" #include "../Item.h"
#include "../World.h" #include "../World.h"
#include "../Entities/Player.h" #include "../Entities/Player.h"
#include "../Piston.h" #include "BlockInServerPluginInterface.h"
#define AddPistonDir(x, y, z, dir, amount) \ #define AddPistonDir(x, y, z, dir, amount) \
switch (dir) \ switch (dir & 0x07) \
{ \ { \
case 0: (y) -= (amount); break; \ case 0: (y) -= (amount); break; \
case 1: (y) += (amount); break; \ case 1: (y) += (amount); break; \
@ -19,8 +19,16 @@
case 3: (z) += (amount); break; \ case 3: (z) += (amount); break; \
case 4: (x) -= (amount); break; \ case 4: (x) -= (amount); break; \
case 5: (x) += (amount); break; \ case 5: (x) += (amount); break; \
default: \
{ \
LOGWARNING("%s: invalid direction %d, ignoring", __FUNCTION__, dir & 0x07); \
break; \
} \
} }
#define PISTON_TICK_DELAY 1
#define PISTON_MAX_PUSH_DISTANCE 12
@ -40,7 +48,7 @@ void cBlockPistonHandler::OnDestroyed(cChunkInterface & a_ChunkInterface, cWorld
int newX = a_BlockX; int newX = a_BlockX;
int newY = a_BlockY; int newY = a_BlockY;
int newZ = a_BlockZ; int newZ = a_BlockZ;
AddPistonDir(newX, newY, newZ, OldMeta & ~(8), 1); AddPistonDir(newX, newY, newZ, OldMeta, 1);
if (a_ChunkInterface.GetBlock(newX, newY, newZ) == E_BLOCK_PISTON_EXTENSION) if (a_ChunkInterface.GetBlock(newX, newY, newZ) == E_BLOCK_PISTON_EXTENSION)
{ {
@ -60,7 +68,7 @@ bool cBlockPistonHandler::GetPlacementBlockTypeMeta(
) )
{ {
a_BlockType = m_BlockType; a_BlockType = m_BlockType;
a_BlockMeta = cPiston::RotationPitchToMetaData(a_Player->GetYaw(), a_Player->GetPitch()); a_BlockMeta = RotationPitchToMetaData(a_Player->GetYaw(), a_Player->GetPitch());
return true; return true;
} }
@ -68,6 +76,165 @@ bool cBlockPistonHandler::GetPlacementBlockTypeMeta(
int cBlockPistonHandler::FirstPassthroughBlock(int a_PistonX, int a_PistonY, int a_PistonZ, NIBBLETYPE pistonmeta, cWorld * a_World)
{
// Examine each of the 12 blocks ahead of the piston:
for (int ret = 0; ret < PISTON_MAX_PUSH_DISTANCE; ret++)
{
BLOCKTYPE currBlock;
NIBBLETYPE currMeta;
AddPistonDir(a_PistonX, a_PistonY, a_PistonZ, pistonmeta, 1);
a_World->GetBlockTypeMeta(a_PistonX, a_PistonY, a_PistonZ, currBlock, currMeta);
if (CanBreakPush(currBlock))
{
// This block breaks when pushed, extend up to here
return ret;
}
if (!CanPush(currBlock, currMeta))
{
// This block cannot be pushed at all, the piston can't extend
return -1;
}
}
// There is no space for the blocks to move, piston can't extend
return -1;
}
void cBlockPistonHandler::ExtendPiston(int a_BlockX, int a_BlockY, int a_BlockZ, cWorld * a_World)
{
BLOCKTYPE pistonBlock;
NIBBLETYPE pistonMeta;
a_World->GetBlockTypeMeta(a_BlockX, a_BlockY, a_BlockZ, pistonBlock, pistonMeta);
if (IsExtended(pistonMeta))
{
// Already extended, bail out
return;
}
int dist = FirstPassthroughBlock(a_BlockX, a_BlockY, a_BlockZ, pistonMeta, a_World);
if (dist < 0)
{
// FirstPassthroughBlock says piston can't push anything, bail out
return;
}
a_World->BroadcastBlockAction(a_BlockX, a_BlockY, a_BlockZ, 0, pistonMeta, pistonBlock);
a_World->BroadcastSoundEffect("tile.piston.out", a_BlockX * 8, a_BlockY * 8, a_BlockZ * 8, 0.5f, 0.7f);
// Drop the breakable block in the line, if appropriate:
AddPistonDir(a_BlockX, a_BlockY, a_BlockZ, pistonMeta, dist + 1); // "a_Block" now at the breakable / empty block
BLOCKTYPE currBlock;
NIBBLETYPE currMeta;
a_World->GetBlockTypeMeta(a_BlockX, a_BlockY, a_BlockZ, currBlock, currMeta);
if (currBlock != E_BLOCK_AIR)
{
cBlockHandler * Handler = BlockHandler(currBlock);
if (Handler->DoesDropOnUnsuitable())
{
cChunkInterface ChunkInterface(a_World->GetChunkMap());
cBlockInServerPluginInterface PluginInterface(*a_World);
Handler->DropBlock(ChunkInterface, *a_World, PluginInterface, NULL, a_BlockX, a_BlockY, a_BlockZ);
}
}
// Push blocks, from the furthest to the nearest:
int oldx = a_BlockX, oldy = a_BlockY, oldz = a_BlockZ;
NIBBLETYPE currBlockMeta;
std::vector<Vector3i> ScheduledBlocks;
ScheduledBlocks.reserve(PISTON_MAX_PUSH_DISTANCE);
for (int i = dist + 1; i > 1; i--)
{
AddPistonDir(a_BlockX, a_BlockY, a_BlockZ, pistonMeta, -1);
a_World->GetBlockTypeMeta(a_BlockX, a_BlockY, a_BlockZ, currBlock, currBlockMeta);
a_World->SetBlock(oldx, oldy, oldz, currBlock, currBlockMeta, false);
ScheduledBlocks.push_back(Vector3i(oldx, oldy, oldz));
oldx = a_BlockX;
oldy = a_BlockY;
oldz = a_BlockZ;
}
int extx = a_BlockX;
int exty = a_BlockY;
int extz = a_BlockZ;
ScheduledBlocks.push_back(Vector3i(extx, exty, extz));
AddPistonDir(a_BlockX, a_BlockY, a_BlockZ, pistonMeta, -1);
// "a_Block" now at piston body, "ext" at future extension
a_World->SetBlock(a_BlockX, a_BlockY, a_BlockZ, pistonBlock, pistonMeta | 0x8);
a_World->SetBlock(extx, exty, extz, E_BLOCK_PISTON_EXTENSION, pistonMeta | (IsSticky(pistonBlock) ? 8 : 0), false);
a_World->ScheduleTask(PISTON_TICK_DELAY, new cWorld::cTaskSendBlockToAllPlayers(ScheduledBlocks));
}
void cBlockPistonHandler::RetractPiston(int a_BlockX, int a_BlockY, int a_BlockZ, cWorld * a_World)
{
BLOCKTYPE pistonBlock;
NIBBLETYPE pistonMeta;
a_World->GetBlockTypeMeta(a_BlockX, a_BlockY, a_BlockZ, pistonBlock, pistonMeta);
if (!IsExtended(pistonMeta))
{
// Already retracted, bail out
return;
}
// Check the extension:
AddPistonDir(a_BlockX, a_BlockY, a_BlockZ, pistonMeta, 1);
if (a_World->GetBlock(a_BlockX, a_BlockY, a_BlockZ) != E_BLOCK_PISTON_EXTENSION)
{
LOGD("%s: Piston without an extension - still extending, or just in an invalid state?", __FUNCTION__);
return;
}
AddPistonDir(a_BlockX, a_BlockY, a_BlockZ, pistonMeta, -1);
a_World->SetBlock(a_BlockX, a_BlockY, a_BlockZ, pistonBlock, pistonMeta & ~(8));
a_World->BroadcastBlockAction(a_BlockX, a_BlockY, a_BlockZ, 1, pistonMeta & ~(8), pistonBlock);
a_World->BroadcastSoundEffect("tile.piston.in", a_BlockX * 8, a_BlockY * 8, a_BlockZ * 8, 0.5f, 0.7f);
AddPistonDir(a_BlockX, a_BlockY, a_BlockZ, pistonMeta, 1);
// Retract the extension, pull block if appropriate
if (IsSticky(pistonBlock))
{
int tempx = a_BlockX, tempy = a_BlockY, tempz = a_BlockZ;
AddPistonDir(tempx, tempy, tempz, pistonMeta, 1);
BLOCKTYPE tempBlock;
NIBBLETYPE tempMeta;
a_World->GetBlockTypeMeta(tempx, tempy, tempz, tempBlock, tempMeta);
if (CanPull(tempBlock, tempMeta))
{
// Pull the block
a_World->SetBlock(a_BlockX, a_BlockY, a_BlockZ, tempBlock, tempMeta, false);
a_World->SetBlock(tempx, tempy, tempz, E_BLOCK_AIR, 0, false);
std::vector<Vector3i> ScheduledBlocks;
ScheduledBlocks.push_back(Vector3i(a_BlockX, a_BlockY, a_BlockZ));
ScheduledBlocks.push_back(Vector3i(tempx, tempy, tempz));
a_World->ScheduleTask(PISTON_TICK_DELAY + 1, new cWorld::cTaskSendBlockToAllPlayers(ScheduledBlocks));
return;
}
}
// Retract without pulling
a_World->SetBlock(a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_AIR, 0, false);
std::vector<Vector3i> ScheduledBlocks;
ScheduledBlocks.push_back(Vector3i(a_BlockX, a_BlockY, a_BlockZ));
a_World->ScheduleTask(PISTON_TICK_DELAY + 1, new cWorld::cTaskSendBlockToAllPlayers(ScheduledBlocks));
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// cBlockPistonHeadHandler: // cBlockPistonHeadHandler:
@ -87,7 +254,7 @@ void cBlockPistonHeadHandler::OnDestroyedByPlayer(cChunkInterface & a_ChunkInter
int newX = a_BlockX; int newX = a_BlockX;
int newY = a_BlockY; int newY = a_BlockY;
int newZ = a_BlockZ; int newZ = a_BlockZ;
AddPistonDir(newX, newY, newZ, OldMeta & ~(8), -1); AddPistonDir(newX, newY, newZ, OldMeta, -1);
BLOCKTYPE Block = a_ChunkInterface.GetBlock(newX, newY, newZ); BLOCKTYPE Block = a_ChunkInterface.GetBlock(newX, newY, newZ);
if ((Block == E_BLOCK_STICKY_PISTON) || (Block == E_BLOCK_PISTON)) if ((Block == E_BLOCK_STICKY_PISTON) || (Block == E_BLOCK_PISTON))

134
src/Blocks/BlockPiston.h
View File

@ -21,6 +21,138 @@ public:
int a_CursorX, int a_CursorY, int a_CursorZ, int a_CursorX, int a_CursorY, int a_CursorZ,
BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
) override; ) override;
static NIBBLETYPE RotationPitchToMetaData(double a_Rotation, double a_Pitch)
{
if (a_Pitch >= 50)
{
return 0x1;
}
else if (a_Pitch <= -50)
{
return 0x0;
}
else
{
a_Rotation += 90 + 45; // So its not aligned with axis
if (a_Rotation > 360)
{
a_Rotation -= 360;
}
if ((a_Rotation >= 0) && (a_Rotation < 90))
{
return 0x4;
}
else if ((a_Rotation >= 180) && (a_Rotation < 270))
{
return 0x5;
}
else if ((a_Rotation >= 90) && (a_Rotation < 180))
{
return 0x2;
}
else
{
return 0x3;
}
}
}
static eBlockFace MetaDataToDirection(NIBBLETYPE a_MetaData)
{
switch (a_MetaData)
{
case 0x0: return BLOCK_FACE_YM;
case 0x1: return BLOCK_FACE_YP;
case 0x2: return BLOCK_FACE_ZM;
case 0x3: return BLOCK_FACE_ZP;
case 0x4: return BLOCK_FACE_XM;
case 0x5: return BLOCK_FACE_XP;
default:
{
ASSERT(!"Invalid Metadata");
return BLOCK_FACE_NONE;
}
}
}
static void ExtendPiston(int a_BlockX, int a_BlockY, int a_BlockZ, cWorld * a_World);
static void RetractPiston(int a_BlockX, int a_BlockY, int a_BlockZ, cWorld * a_World);
private:
/// Returns true if the piston (specified by blocktype) is a sticky piston
static inline bool IsSticky(BLOCKTYPE a_BlockType) { return (a_BlockType == E_BLOCK_STICKY_PISTON); }
/// Returns true if the piston (with the specified meta) is extended
static inline bool IsExtended(NIBBLETYPE a_PistonMeta) { return ((a_PistonMeta & 0x8) != 0x0); }
/// Returns true if the specified block can be pushed by a piston (and left intact)
static inline bool CanPush(BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)
{
switch (a_BlockType)
{
case E_BLOCK_ANVIL:
case E_BLOCK_BED:
case E_BLOCK_BEDROCK:
case E_BLOCK_BREWING_STAND:
case E_BLOCK_CHEST:
case E_BLOCK_COMMAND_BLOCK:
case E_BLOCK_DISPENSER:
case E_BLOCK_DROPPER:
case E_BLOCK_ENCHANTMENT_TABLE:
case E_BLOCK_END_PORTAL:
case E_BLOCK_END_PORTAL_FRAME:
case E_BLOCK_FURNACE:
case E_BLOCK_LIT_FURNACE:
case E_BLOCK_HOPPER:
case E_BLOCK_JUKEBOX:
case E_BLOCK_MOB_SPAWNER:
case E_BLOCK_NETHER_PORTAL:
case E_BLOCK_NOTE_BLOCK:
case E_BLOCK_OBSIDIAN:
case E_BLOCK_PISTON_EXTENSION:
{
return false;
}
case E_BLOCK_STICKY_PISTON:
case E_BLOCK_PISTON:
{
// A piston can only be pushed if retracted:
return !IsExtended(a_BlockMeta);
}
}
return true;
}
/// Returns true if the specified block can be pushed by a piston and broken / replaced
static inline bool CanBreakPush(BLOCKTYPE a_BlockType) { return cBlockInfo::IsPistonBreakable(a_BlockType); }
/// Returns true if the specified block can be pulled by a sticky piston
static inline bool CanPull(BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)
{
switch (a_BlockType)
{
case E_BLOCK_LAVA:
case E_BLOCK_STATIONARY_LAVA:
case E_BLOCK_STATIONARY_WATER:
case E_BLOCK_WATER:
{
return false;
}
}
if (CanBreakPush(a_BlockType))
{
return false; // CanBreakPush returns true, but we need false to prevent pulling
}
return CanPush(a_BlockType, a_BlockMeta);
}
/// Returns how many blocks the piston has to push (where the first free space is); < 0 when unpushable
static int FirstPassthroughBlock(int a_PistonX, int a_PistonY, int a_PistonZ, NIBBLETYPE a_PistonMeta, cWorld * a_World);
} ; } ;
@ -40,7 +172,7 @@ public:
virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
{ {
// No pickups // No pickups
// Also with 1.7, the item forms of these tecnical blocks have been removed, so giving someone this will crash their client... // Also with 1.7, the item forms of these technical blocks have been removed, so giving someone this will crash their client...
} }
} ; } ;

22
src/Chunk.cpp
View File

@ -1387,7 +1387,7 @@ void cChunk::CalculateHeightmap(const BLOCKTYPE * a_BlockTypes)
int index = MakeIndex( x, y, z ); int index = MakeIndex( x, y, z );
if (a_BlockTypes[index] != E_BLOCK_AIR) if (a_BlockTypes[index] != E_BLOCK_AIR)
{ {
m_HeightMap[x + z * Width] = (unsigned char)y; m_HeightMap[x + z * Width] = (HEIGHTTYPE)y;
break; break;
} }
} // for y } // for y
@ -1399,9 +1399,9 @@ void cChunk::CalculateHeightmap(const BLOCKTYPE * a_BlockTypes)
void cChunk::SetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta) void cChunk::SetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta, bool a_SendToClients)
{ {
FastSetBlock(a_RelX, a_RelY, a_RelZ, a_BlockType, a_BlockMeta); FastSetBlock(a_RelX, a_RelY, a_RelZ, a_BlockType, a_BlockMeta, a_SendToClients);
// Tick this block and its neighbors: // Tick this block and its neighbors:
m_ToTickBlocks.push_back(Vector3i(a_RelX, a_RelY, a_RelZ)); m_ToTickBlocks.push_back(Vector3i(a_RelX, a_RelY, a_RelZ));
@ -1500,7 +1500,7 @@ void cChunk::QueueTickBlockNeighbors(int a_RelX, int a_RelY, int a_RelZ)
void cChunk::FastSetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockType, BLOCKTYPE a_BlockMeta) void cChunk::FastSetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockType, BLOCKTYPE a_BlockMeta, bool a_SendToClients)
{ {
ASSERT(!((a_RelX < 0) || (a_RelX >= Width) || (a_RelY < 0) || (a_RelY >= Height) || (a_RelZ < 0) || (a_RelZ >= Width))); ASSERT(!((a_RelX < 0) || (a_RelX >= Width) || (a_RelY < 0) || (a_RelY >= Height) || (a_RelZ < 0) || (a_RelZ >= Width)));
@ -1517,16 +1517,18 @@ void cChunk::FastSetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockT
m_ChunkData.SetBlock(a_RelX, a_RelY, a_RelZ, a_BlockType); m_ChunkData.SetBlock(a_RelX, a_RelY, a_RelZ, a_BlockType);
// The client doesn't need to distinguish between stationary and nonstationary fluids: if ( // Queue block to be sent only if ...
if ( a_SendToClients && // ... we are told to do so AND ...
(OldBlockMeta != a_BlockMeta) || // Different meta always gets sent to the client (
!( (OldBlockMeta != a_BlockMeta) || // ... the meta value is different OR ...
!( // ... the old and new blocktypes AREN'T liquids (because client doesn't need to distinguish betwixt them); see below for specifics:
((OldBlockType == E_BLOCK_STATIONARY_WATER) && (a_BlockType == E_BLOCK_WATER)) || // Replacing stationary water with water ((OldBlockType == E_BLOCK_STATIONARY_WATER) && (a_BlockType == E_BLOCK_WATER)) || // Replacing stationary water with water
((OldBlockType == E_BLOCK_WATER) && (a_BlockType == E_BLOCK_STATIONARY_WATER)) || // Replacing water with stationary water ((OldBlockType == E_BLOCK_WATER) && (a_BlockType == E_BLOCK_STATIONARY_WATER)) || // Replacing water with stationary water
((OldBlockType == E_BLOCK_STATIONARY_LAVA) && (a_BlockType == E_BLOCK_LAVA)) || // Replacing stationary water with water ((OldBlockType == E_BLOCK_STATIONARY_LAVA) && (a_BlockType == E_BLOCK_LAVA)) || // Replacing stationary water with water
((OldBlockType == E_BLOCK_LAVA) && (a_BlockType == E_BLOCK_STATIONARY_LAVA)) // Replacing water with stationary water ((OldBlockType == E_BLOCK_LAVA) && (a_BlockType == E_BLOCK_STATIONARY_LAVA)) // Replacing water with stationary water
) )
) )
)
{ {
m_PendingSendBlocks.push_back(sSetBlock(m_PosX, m_PosZ, a_RelX, a_RelY, a_RelZ, a_BlockType, a_BlockMeta)); m_PendingSendBlocks.push_back(sSetBlock(m_PosX, m_PosZ, a_RelX, a_RelY, a_RelZ, a_BlockType, a_BlockMeta));
} }
@ -1548,7 +1550,7 @@ void cChunk::FastSetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockT
{ {
if (a_BlockType != E_BLOCK_AIR) if (a_BlockType != E_BLOCK_AIR)
{ {
m_HeightMap[a_RelX + a_RelZ * Width] = (unsigned char)a_RelY; m_HeightMap[a_RelX + a_RelZ * Width] = (HEIGHTTYPE)a_RelY;
} }
else else
{ {
@ -1556,7 +1558,7 @@ void cChunk::FastSetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockT
{ {
if (GetBlock(a_RelX, y, a_RelZ) != E_BLOCK_AIR) if (GetBlock(a_RelX, y, a_RelZ) != E_BLOCK_AIR)
{ {
m_HeightMap[a_RelX + a_RelZ * Width] = (unsigned char)y; m_HeightMap[a_RelX + a_RelZ * Width] = (HEIGHTTYPE)y;
break; break;
} }
} // for y - column in m_BlockData } // for y - column in m_BlockData

4
src/Chunk.h
View File

@ -141,7 +141,7 @@ public:
cWorld * GetWorld(void) const { return m_World; } cWorld * GetWorld(void) const { return m_World; }
void SetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta ); void SetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta, bool a_SendToClients = true);
// SetBlock() does a lot of work (heightmap, tickblocks, blockentities) so a BlockIdx version doesn't make sense // SetBlock() does a lot of work (heightmap, tickblocks, blockentities) so a BlockIdx version doesn't make sense
void SetBlock( const Vector3i & a_RelBlockPos, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta ) { SetBlock( a_RelBlockPos.x, a_RelBlockPos.y, a_RelBlockPos.z, a_BlockType, a_BlockMeta ); } void SetBlock( const Vector3i & a_RelBlockPos, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta ) { SetBlock( a_RelBlockPos.x, a_RelBlockPos.y, a_RelBlockPos.z, a_BlockType, a_BlockMeta ); }
@ -154,7 +154,7 @@ public:
/** Queues all 6 neighbors of the specified block for ticking (m_ToTickQueue). If any are outside the chunk, relays the checking to the proper neighboring chunk */ /** Queues all 6 neighbors of the specified block for ticking (m_ToTickQueue). If any are outside the chunk, relays the checking to the proper neighboring chunk */
void QueueTickBlockNeighbors(int a_RelX, int a_RelY, int a_RelZ); void QueueTickBlockNeighbors(int a_RelX, int a_RelY, int a_RelZ);
void FastSetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockType, BLOCKTYPE a_BlockMeta ); // Doesn't force block updates on neighbors, use for simple changes such as grass growing etc. void FastSetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockType, BLOCKTYPE a_BlockMeta, bool a_SendToClients = true); // Doesn't force block updates on neighbors, use for simple changes such as grass growing etc.
BLOCKTYPE GetBlock(int a_RelX, int a_RelY, int a_RelZ) const; BLOCKTYPE GetBlock(int a_RelX, int a_RelY, int a_RelZ) const;
BLOCKTYPE GetBlock(Vector3i a_cords) const { return GetBlock(a_cords.x, a_cords.y, a_cords.z);} BLOCKTYPE GetBlock(Vector3i a_cords) const { return GetBlock(a_cords.x, a_cords.y, a_cords.z);}
void GetBlockTypeMeta(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta); void GetBlockTypeMeta(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta);

4
src/ChunkMap.cpp
View File

@ -1252,7 +1252,7 @@ void cChunkMap::SetBlockMeta(int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYP
void cChunkMap::SetBlock(cWorldInterface & a_WorldInterface, int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, BLOCKTYPE a_BlockMeta) void cChunkMap::SetBlock(cWorldInterface & a_WorldInterface, int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, BLOCKTYPE a_BlockMeta, bool a_SendToClients)
{ {
cChunkInterface ChunkInterface(this); cChunkInterface ChunkInterface(this);
if (a_BlockType == E_BLOCK_AIR) if (a_BlockType == E_BLOCK_AIR)
@ -1267,7 +1267,7 @@ void cChunkMap::SetBlock(cWorldInterface & a_WorldInterface, int a_BlockX, int a
cChunkPtr Chunk = GetChunk( ChunkX, ZERO_CHUNK_Y, ChunkZ ); cChunkPtr Chunk = GetChunk( ChunkX, ZERO_CHUNK_Y, ChunkZ );
if ((Chunk != NULL) && Chunk->IsValid()) if ((Chunk != NULL) && Chunk->IsValid())
{ {
Chunk->SetBlock(X, Y, Z, a_BlockType, a_BlockMeta ); Chunk->SetBlock(X, Y, Z, a_BlockType, a_BlockMeta, a_SendToClients);
m_World->GetSimulatorManager()->WakeUp(a_BlockX, a_BlockY, a_BlockZ, Chunk); m_World->GetSimulatorManager()->WakeUp(a_BlockX, a_BlockY, a_BlockZ, Chunk);
} }
BlockHandler(a_BlockType)->OnPlaced(ChunkInterface, a_WorldInterface, a_BlockX, a_BlockY, a_BlockZ, a_BlockType, a_BlockMeta); BlockHandler(a_BlockType)->OnPlaced(ChunkInterface, a_WorldInterface, a_BlockX, a_BlockY, a_BlockZ, a_BlockType, a_BlockMeta);

2
src/ChunkMap.h
View File

@ -153,7 +153,7 @@ public:
NIBBLETYPE GetBlockSkyLight (int a_BlockX, int a_BlockY, int a_BlockZ); NIBBLETYPE GetBlockSkyLight (int a_BlockX, int a_BlockY, int a_BlockZ);
NIBBLETYPE GetBlockBlockLight(int a_BlockX, int a_BlockY, int a_BlockZ); NIBBLETYPE GetBlockBlockLight(int a_BlockX, int a_BlockY, int a_BlockZ);
void SetBlockMeta (int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockMeta); void SetBlockMeta (int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockMeta);
void SetBlock (cWorldInterface & a_WorldInterface, int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, BLOCKTYPE a_BlockMeta); void SetBlock (cWorldInterface & a_WorldInterface, int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, BLOCKTYPE a_BlockMeta, bool a_SendToClients = true);
void QueueSetBlock(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, BLOCKTYPE a_BlockMeta, Int64 a_Tick, BLOCKTYPE a_PreviousBlockType = E_BLOCK_AIR); void QueueSetBlock(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, BLOCKTYPE a_BlockMeta, Int64 a_Tick, BLOCKTYPE a_PreviousBlockType = E_BLOCK_AIR);
bool GetBlockTypeMeta (int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta); bool GetBlockTypeMeta (int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta);
bool GetBlockInfo (int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_Meta, NIBBLETYPE & a_SkyLight, NIBBLETYPE & a_BlockLight); bool GetBlockInfo (int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_Meta, NIBBLETYPE & a_SkyLight, NIBBLETYPE & a_BlockLight);

1
src/ClientHandle.cpp
View File

@ -12,7 +12,6 @@
#include "BlockEntities/SignEntity.h" #include "BlockEntities/SignEntity.h"
#include "UI/Window.h" #include "UI/Window.h"
#include "Item.h" #include "Item.h"
#include "Piston.h"
#include "Mobs/Monster.h" #include "Mobs/Monster.h"
#include "ChatColor.h" #include "ChatColor.h"
#include "OSSupport/Socket.h" #include "OSSupport/Socket.h"

297
src/Piston.cpp
View File

@ -1,297 +0,0 @@
#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules
#include "Piston.h"
#include "ChunkDef.h"
#include "Entities/Pickup.h"
#include "Item.h"
#include "Root.h"
#include "ClientHandle.h"
#include "World.h"
#include "Server.h"
#include "Blocks/BlockHandler.h"
#include "BlockInServerPluginInterface.h"
/// Number of ticks that the piston extending / retracting waits before setting the block
const int PISTON_TICK_DELAY = 1;
cPiston::cPiston(cWorld * a_World)
: m_World(a_World)
{
}
int cPiston::FirstPassthroughBlock(int pistonX, int pistonY, int pistonZ, NIBBLETYPE pistonmeta)
{
// Examine each of the 12 blocks ahead of the piston:
for (int ret = 0; ret < 12; ret++)
{
BLOCKTYPE currBlock;
NIBBLETYPE currMeta;
AddDir(pistonX, pistonY, pistonZ, pistonmeta, 1);
m_World->GetBlockTypeMeta(pistonX, pistonY, pistonZ, currBlock, currMeta);
if (CanBreakPush(currBlock, currMeta))
{
// This block breaks when pushed, extend up to here
return ret;
}
if (!CanPush(currBlock, currMeta))
{
// This block cannot be pushed at all, the piston can't extend
return -1;
}
}
// There is no space for the blocks to move, piston can't extend
return -1;
}
void cPiston::ExtendPiston(int pistx, int pisty, int pistz)
{
BLOCKTYPE pistonBlock;
NIBBLETYPE pistonMeta;
m_World->GetBlockTypeMeta(pistx, pisty, pistz, pistonBlock, pistonMeta);
if (IsExtended(pistonMeta))
{
// Already extended, bail out
return;
}
int dist = FirstPassthroughBlock(pistx, pisty, pistz, pistonMeta);
if (dist < 0)
{
// FirstPassthroughBlock says piston can't push anything, bail out
return;
}
m_World->BroadcastBlockAction(pistx, pisty, pistz, 0, pistonMeta, pistonBlock);
m_World->BroadcastSoundEffect("tile.piston.out", pistx * 8, pisty * 8, pistz * 8, 0.5f, 0.7f);
// Drop the breakable block in the line, if appropriate:
AddDir(pistx, pisty, pistz, pistonMeta, dist + 1); // "pist" now at the breakable / empty block
BLOCKTYPE currBlock;
NIBBLETYPE currMeta;
m_World->GetBlockTypeMeta(pistx, pisty, pistz, currBlock, currMeta);
if (currBlock != E_BLOCK_AIR)
{
cBlockHandler * Handler = BlockHandler(currBlock);
if (Handler->DoesDropOnUnsuitable())
{
cChunkInterface ChunkInterface(m_World->GetChunkMap());
cBlockInServerPluginInterface PluginInterface(*m_World);
Handler->DropBlock(ChunkInterface, *m_World, PluginInterface, NULL, pistx, pisty, pistz);
}
}
// Push blocks, from the furthest to the nearest:
int oldx = pistx, oldy = pisty, oldz = pistz;
NIBBLETYPE currBlockMeta;
for (int i = dist + 1; i > 1; i--)
{
AddDir(pistx, pisty, pistz, pistonMeta, -1);
m_World->GetBlockTypeMeta(pistx, pisty, pistz, currBlock, currBlockMeta);
m_World->QueueSetBlock( oldx, oldy, oldz, currBlock, currBlockMeta, PISTON_TICK_DELAY);
oldx = pistx;
oldy = pisty;
oldz = pistz;
}
int extx = pistx;
int exty = pisty;
int extz = pistz;
AddDir(pistx, pisty, pistz, pistonMeta, -1);
// "pist" now at piston body, "ext" at future extension
m_World->SetBlock(pistx, pisty, pistz, pistonBlock, pistonMeta | 0x8);
m_World->QueueSetBlock(extx, exty, extz, E_BLOCK_PISTON_EXTENSION, pistonMeta | (IsSticky(pistonBlock) ? 8 : 0), PISTON_TICK_DELAY);
}
void cPiston::RetractPiston(int pistx, int pisty, int pistz)
{
BLOCKTYPE pistonBlock;
NIBBLETYPE pistonMeta;
m_World->GetBlockTypeMeta(pistx, pisty, pistz, pistonBlock, pistonMeta);
if (!IsExtended(pistonMeta))
{
// Already retracted, bail out
return;
}
// Check the extension:
AddDir(pistx, pisty, pistz, pistonMeta, 1);
if (m_World->GetBlock(pistx, pisty, pistz) != E_BLOCK_PISTON_EXTENSION)
{
LOGD("%s: Piston without an extension - still extending, or just in an invalid state?", __FUNCTION__);
return;
}
AddDir(pistx, pisty, pistz, pistonMeta, -1);
m_World->SetBlock(pistx, pisty, pistz, pistonBlock, pistonMeta & ~(8));
m_World->BroadcastBlockAction(pistx, pisty, pistz, 1, pistonMeta & ~(8), pistonBlock);
m_World->BroadcastSoundEffect("tile.piston.in", pistx * 8, pisty * 8, pistz * 8, 0.5f, 0.7f);
AddDir(pistx, pisty, pistz, pistonMeta, 1);
// Retract the extension, pull block if appropriate
if (IsSticky(pistonBlock))
{
int tempx = pistx, tempy = pisty, tempz = pistz;
AddDir(tempx, tempy, tempz, pistonMeta, 1);
BLOCKTYPE tempBlock;
NIBBLETYPE tempMeta;
m_World->GetBlockTypeMeta(tempx, tempy, tempz, tempBlock, tempMeta);
if (CanPull(tempBlock, tempMeta))
{
// Pull the block
m_World->QueueSetBlock(pistx, pisty, pistz, tempBlock, tempMeta, PISTON_TICK_DELAY);
m_World->QueueSetBlock(tempx, tempy, tempz, E_BLOCK_AIR, 0, PISTON_TICK_DELAY);
}
else
{
// Retract without pulling
m_World->QueueSetBlock(pistx, pisty, pistz, E_BLOCK_AIR, 0, PISTON_TICK_DELAY);
}
}
else
{
m_World->QueueSetBlock(pistx, pisty, pistz, E_BLOCK_AIR, 0, PISTON_TICK_DELAY);
}
}
bool cPiston::IsExtended(NIBBLETYPE a_PistonMeta)
{
return ((a_PistonMeta & 0x8) != 0x0);
}
bool cPiston::IsSticky(BLOCKTYPE a_BlockType)
{
return (a_BlockType == E_BLOCK_STICKY_PISTON);
}
bool cPiston::CanPush(BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)
{
switch (a_BlockType)
{
case E_BLOCK_ANVIL:
case E_BLOCK_BED:
case E_BLOCK_BEDROCK:
case E_BLOCK_BREWING_STAND:
case E_BLOCK_CHEST:
case E_BLOCK_COMMAND_BLOCK:
case E_BLOCK_DISPENSER:
case E_BLOCK_DROPPER:
case E_BLOCK_ENCHANTMENT_TABLE:
case E_BLOCK_END_PORTAL:
case E_BLOCK_END_PORTAL_FRAME:
case E_BLOCK_FURNACE:
case E_BLOCK_LIT_FURNACE:
case E_BLOCK_HOPPER:
case E_BLOCK_JUKEBOX:
case E_BLOCK_MOB_SPAWNER:
case E_BLOCK_NETHER_PORTAL:
case E_BLOCK_NOTE_BLOCK:
case E_BLOCK_OBSIDIAN:
case E_BLOCK_PISTON_EXTENSION:
{
return false;
}
case E_BLOCK_STICKY_PISTON:
case E_BLOCK_PISTON:
{
// A piston can only be pushed if retracted:
return !IsExtended(a_BlockMeta);
}
}
return true;
}
bool cPiston::CanBreakPush(BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)
{
UNUSED(a_BlockMeta);
return cBlockInfo::IsPistonBreakable(a_BlockType);
}
bool cPiston::CanPull(BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)
{
switch (a_BlockType)
{
case E_BLOCK_LAVA:
case E_BLOCK_STATIONARY_LAVA:
case E_BLOCK_STATIONARY_WATER:
case E_BLOCK_WATER:
{
return false;
}
}
if (CanBreakPush(a_BlockType, a_BlockMeta))
{
return false; // CanBreakPush returns true, but we need false to prevent pulling
}
return CanPush(a_BlockType, a_BlockMeta);
}
void cPiston::AddDir(int & a_BlockX, int & a_BlockY, int & a_BlockZ, NIBBLETYPE a_PistonMeta, int a_Amount)
{
switch (a_PistonMeta & 0x07)
{
case 0: a_BlockY -= a_Amount; break;
case 1: a_BlockY += a_Amount; break;
case 2: a_BlockZ -= a_Amount; break;
case 3: a_BlockZ += a_Amount; break;
case 4: a_BlockX -= a_Amount; break;
case 5: a_BlockX += a_Amount; break;
default:
{
LOGWARNING("%s: invalid direction %d, ignoring", __FUNCTION__, a_PistonMeta & 0x07);
break;
}
}
}

110
src/Piston.h
View File

@ -1,110 +0,0 @@
#pragma once
#include "Defines.h"
// fwd: World.h
class cWorld;
class cPiston
{
public:
cPiston(cWorld * a_World);
static NIBBLETYPE RotationPitchToMetaData(double a_Rotation, double a_Pitch)
{
if (a_Pitch >= 50)
{
return 0x1;
}
else if (a_Pitch <= -50)
{
return 0x0;
}
else
{
a_Rotation += 90 + 45; // So its not aligned with axis
if (a_Rotation > 360)
{
a_Rotation -= 360;
}
if ((a_Rotation >= 0) && (a_Rotation < 90))
{
return 0x4;
}
else if ((a_Rotation >= 180) && (a_Rotation < 270))
{
return 0x5;
}
else if ((a_Rotation >= 90) && (a_Rotation < 180))
{
return 0x2;
}
else
{
return 0x3;
}
}
}
static eBlockFace MetaDataToDirection(NIBBLETYPE a_MetaData)
{
switch (a_MetaData)
{
//case -1: return BLOCK_FACE_NONE; //can never happen as metadata is unsigned
case 0x0: return BLOCK_FACE_YM;
case 0x1: return BLOCK_FACE_YP;
case 0x2: return BLOCK_FACE_ZM;
case 0x3: return BLOCK_FACE_ZP;
case 0x4: return BLOCK_FACE_XM;
case 0x5: return BLOCK_FACE_XP;
default:
{
ASSERT(!"Invalid Metadata");
return BLOCK_FACE_NONE;
}
}
}
void ExtendPiston( int, int, int );
void RetractPiston( int, int, int );
/// Returns true if the piston (specified by blocktype) is a sticky piston
static bool IsSticky(BLOCKTYPE a_BlockType);
/// Returns true if the piston (with the specified meta) is extended
static bool IsExtended(NIBBLETYPE a_PistonMeta);
/// Returns true if the specified block can be pushed by a piston (and left intact)
static bool CanPush(BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta);
/// Returns true if the specified block can be pushed by a piston and broken / replaced
static bool CanBreakPush(BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta);
/// Returns true if the specified block can be pulled by a sticky piston
static bool CanPull(BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta);
/// Updates the coords by the specified amount in the direction a piston of the specified meta is facing
static void AddDir(int & a_BlockX, int & a_BlockY, int & a_BlockZ, NIBBLETYPE a_PistonMeta, int a_Amount);
cWorld * m_World;
private:
void ChainMove( int, int, int, char, unsigned short * );
/// Returns how many blocks the piston has to push (where the first free space is); <0 when unpushable
int FirstPassthroughBlock(int a_PistonX, int a_PistonY, int a_PistonZ, NIBBLETYPE a_PistonMeta);
} ;

26
src/Simulator/IncrementalRedstoneSimulator.cpp
View File

@ -11,7 +11,7 @@
#include "../Blocks/BlockDoor.h" #include "../Blocks/BlockDoor.h"
#include "../Blocks/BlockButton.h" #include "../Blocks/BlockButton.h"
#include "../Blocks/BlockLever.h" #include "../Blocks/BlockLever.h"
#include "../Piston.h" #include "../Blocks/BlockPiston.h"
@ -814,17 +814,16 @@ void cIncrementalRedstoneSimulator::HandleRedstoneRepeater(int a_RelBlockX, int
void cIncrementalRedstoneSimulator::HandlePiston(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ) void cIncrementalRedstoneSimulator::HandlePiston(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ)
{ {
cPiston Piston(&m_World);
int BlockX = (m_Chunk->GetPosX() * cChunkDef::Width) + a_RelBlockX; int BlockX = (m_Chunk->GetPosX() * cChunkDef::Width) + a_RelBlockX;
int BlockZ = (m_Chunk->GetPosZ() * cChunkDef::Width) + a_RelBlockZ; int BlockZ = (m_Chunk->GetPosZ() * cChunkDef::Width) + a_RelBlockZ;
if (IsPistonPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ, m_Chunk->GetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ) & 0x7)) // We only want the bottom three bits (4th controls extended-ness) if (IsPistonPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ, m_Chunk->GetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ) & 0x7)) // We only want the bottom three bits (4th controls extended-ness)
{ {
Piston.ExtendPiston(BlockX, a_RelBlockY, BlockZ); cBlockPistonHandler::ExtendPiston(BlockX, a_RelBlockY, BlockZ, &m_World);
} }
else else
{ {
Piston.RetractPiston(BlockX, a_RelBlockY, BlockZ); cBlockPistonHandler::RetractPiston(BlockX, a_RelBlockY, BlockZ, &m_World);
} }
} }
@ -1490,41 +1489,36 @@ bool cIncrementalRedstoneSimulator::IsPistonPowered(int a_RelBlockX, int a_RelBl
{ {
// Pistons cannot be powered through their front face; this function verifies that a source meets this requirement // Pistons cannot be powered through their front face; this function verifies that a source meets this requirement
int OldX = a_RelBlockX, OldY = a_RelBlockY, OldZ = a_RelBlockZ; eBlockFace Face = cBlockPistonHandler::MetaDataToDirection(a_Meta);
eBlockFace Face = cPiston::MetaDataToDirection(a_Meta); int BlockX = m_Chunk->GetPosX() * cChunkDef::Width + a_RelBlockX;
int BlockX = (m_Chunk->GetPosX() * cChunkDef::Width) + a_RelBlockX; int BlockZ = m_Chunk->GetPosZ() * cChunkDef::Width + a_RelBlockZ;
int BlockZ = (m_Chunk->GetPosZ() * cChunkDef::Width) + a_RelBlockZ;
for (PoweredBlocksList::const_iterator itr = m_PoweredBlocks->begin(); itr != m_PoweredBlocks->end(); ++itr) for (PoweredBlocksList::const_iterator itr = m_PoweredBlocks->begin(); itr != m_PoweredBlocks->end(); ++itr)
{ {
if (!itr->a_BlockPos.Equals(Vector3i(BlockX, a_RelBlockY, BlockZ))) { continue; } if (!itr->a_BlockPos.Equals(Vector3i(BlockX, a_RelBlockY, BlockZ))) { continue; }
AddFaceDirection(a_RelBlockX, a_RelBlockY, a_RelBlockZ, Face); AddFaceDirection(BlockX, a_RelBlockY, BlockZ, Face);
if (!itr->a_SourcePos.Equals(Vector3i(BlockX, a_RelBlockY, BlockZ))) if (!itr->a_SourcePos.Equals(Vector3i(BlockX, a_RelBlockY, BlockZ)))
{ {
return true; return true;
} }
a_RelBlockX = OldX; AddFaceDirection(BlockX, a_RelBlockY, BlockZ, Face, true);
a_RelBlockY = OldY;
a_RelBlockZ = OldZ;
} }
for (LinkedBlocksList::const_iterator itr = m_LinkedPoweredBlocks->begin(); itr != m_LinkedPoweredBlocks->end(); ++itr) for (LinkedBlocksList::const_iterator itr = m_LinkedPoweredBlocks->begin(); itr != m_LinkedPoweredBlocks->end(); ++itr)
{ {
if (!itr->a_BlockPos.Equals(Vector3i(BlockX, a_RelBlockY, BlockZ))) { continue; } if (!itr->a_BlockPos.Equals(Vector3i(BlockX, a_RelBlockY, BlockZ))) { continue; }
AddFaceDirection(a_RelBlockX, a_RelBlockY, a_RelBlockZ, Face); AddFaceDirection(BlockX, a_RelBlockY, BlockZ, Face);
if (!itr->a_MiddlePos.Equals(Vector3i(BlockX, a_RelBlockY, BlockZ))) if (!itr->a_MiddlePos.Equals(Vector3i(BlockX, a_RelBlockY, BlockZ)))
{ {
return true; return true;
} }
a_RelBlockX = OldX; AddFaceDirection(BlockX, a_RelBlockY, BlockZ, Face, true);
a_RelBlockY = OldY;
a_RelBlockZ = OldZ;
} }
return false; // Source was in front of the piston's front face return false; // Source was in front of the piston's front face
} }

47
src/World.cpp
View File

@ -1551,9 +1551,9 @@ bool cWorld::SetAreaBiome(const cCuboid & a_Area, EMCSBiome a_Biome)
void cWorld::SetBlock(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta) void cWorld::SetBlock(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta, bool a_SendToClients)
{ {
m_ChunkMap->SetBlock(*this, a_BlockX, a_BlockY, a_BlockZ, a_BlockType, a_BlockMeta); m_ChunkMap->SetBlock(*this, a_BlockX, a_BlockY, a_BlockZ, a_BlockType, a_BlockMeta, a_SendToClients);
} }
@ -3127,6 +3127,49 @@ void cWorld::cTaskUnloadUnusedChunks::Run(cWorld & a_World)
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// cWorld::cTaskSendBlockTo
cWorld::cTaskSendBlockToAllPlayers::cTaskSendBlockToAllPlayers(std::vector<Vector3i> & a_SendQueue) :
m_SendQueue(a_SendQueue)
{
}
void cWorld::cTaskSendBlockToAllPlayers::Run(cWorld & a_World)
{
class cPlayerCallback :
public cPlayerListCallback
{
public:
cPlayerCallback(std::vector<Vector3i> & a_SendQueue, cWorld & a_World) :
m_SendQueue(a_SendQueue),
m_World(a_World)
{
}
virtual bool Item(cPlayer * a_Player)
{
for (std::vector<Vector3i>::const_iterator itr = m_SendQueue.begin(); itr != m_SendQueue.end(); ++itr)
{
m_World.SendBlockTo(itr->x, itr->y, itr->z, a_Player);
}
return false;
}
private:
std::vector<Vector3i> m_SendQueue;
cWorld & m_World;
} PlayerCallback(m_SendQueue, a_World);
a_World.ForEachPlayer(PlayerCallback);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// cWorld::cChunkGeneratorCallbacks: // cWorld::cChunkGeneratorCallbacks:

16
src/World.h
View File

@ -117,6 +117,20 @@ public:
}; };
class cTaskSendBlockToAllPlayers :
public cTask
{
public:
cTaskSendBlockToAllPlayers(std::vector<Vector3i> & a_SendQueue);
protected:
// cTask overrides:
virtual void Run(cWorld & a_World) override;
std::vector<Vector3i> m_SendQueue;
};
static const char * GetClassStatic(void) // Needed for ManualBindings's ForEach templates static const char * GetClassStatic(void) // Needed for ManualBindings's ForEach templates
{ {
return "cWorld"; return "cWorld";
@ -373,7 +387,7 @@ public:
/** Sets the block at the specified coords to the specified value. /** Sets the block at the specified coords to the specified value.
Full processing, incl. updating neighbors, is performed. Full processing, incl. updating neighbors, is performed.
*/ */
void SetBlock(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta); void SetBlock(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta, bool a_SendToClients = true);
/** Sets the block at the specified coords to the specified value. /** Sets the block at the specified coords to the specified value.
The replacement doesn't trigger block updates. The replacement doesn't trigger block updates.