New redstone simulator. Should work without crashes!

git-svn-id: http://mc-server.googlecode.com/svn/trunk@345 0a769ca7-a7f5-676a-18bf-c427514a06d6

VC2010/MCServer.vcxproj

@@ -355,6 +355,7 @@
     <ClCompile Include="..\source\cPlugin_NewLua.cpp" />
     <ClCompile Include="..\Source\cRecipeChecker.cpp" />
     <ClCompile Include="..\source\cRedstone.cpp" />
+    <ClCompile Include="..\source\cRedstoneSimulator.cpp" />
     <ClCompile Include="..\Source\cReferenceManager.cpp" />
     <ClCompile Include="..\Source\cRoot.cpp" />
     <ClCompile Include="..\source\cSandSimulator.cpp" />
@@ -530,6 +531,7 @@
     <ClInclude Include="..\source\cPlugin_NewLua.h" />
     <ClInclude Include="..\Source\cRecipeChecker.h" />
     <ClInclude Include="..\source\cRedstone.h" />
+    <ClInclude Include="..\source\cRedstoneSimulator.h" />
     <ClInclude Include="..\Source\cReferenceManager.h" />
     <ClInclude Include="..\Source\cRoot.h" />
     <ClInclude Include="..\source\cSandSimulator.h" />

VC2010/MCServer.vcxproj.filters

@@ -454,6 +454,9 @@
     <Filter Include="cWebAdmin\cWebPlugin\cWebPlugin">
       <UniqueIdentifier>{31f2d7f9-9684-456b-9d70-011a10e894fd}</UniqueIdentifier>
     </Filter>
+    <Filter Include="Simulator\cSimulator\cRedstoneSimulator">
+      <UniqueIdentifier>{4b3b7b43-8e8b-4823-b112-2259fdfff7d3}</UniqueIdentifier>
+    </Filter>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="..\source\cServer.cpp">
@@ -912,6 +915,9 @@
     <ClCompile Include="..\source\WSSCompact.cpp" />
     <ClCompile Include="..\source\StringCompression.cpp" />
     <ClCompile Include="..\source\LightingThread.cpp" />
+    <ClCompile Include="..\source\cRedstoneSimulator.cpp">
+      <Filter>Simulator\cSimulator\cRedstoneSimulator</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="..\source\cServer.h">
@@ -1408,6 +1414,9 @@
     <ClInclude Include="..\source\WorldStorage.h" />
     <ClInclude Include="..\source\StringCompression.h" />
     <ClInclude Include="..\source\LightingThread.h" />
+    <ClInclude Include="..\source\cRedstoneSimulator.h">
+      <Filter>Simulator\cSimulator\cRedstoneSimulator</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <None Include="..\source\AllToLua.pkg">

makefile_base

@@ -1555,6 +1555,8 @@ build/WSSCompact.o : source/WSSCompact.cpp
 build/StringCompression.o : source/StringCompression.cpp
 	$(CC) $(CC_OPTIONS) source/StringCompression.cpp -c $(INCLUDE) -o build/StringCompression.o	
 
+build/cRedstoneSimulator.o : source/cRedstoneSimulator.cpp
+ 	$(CC) $(CC_OPTIONS) source/cRedstoneSimulator.cpp -c $(INCLUDE) -o build/cRedstoneSimulator.o	
 
 # Template: copy and delete the "# "; insert filenames
 # build/.o : source/.cpp

source/cChunk.cpp

@@ -464,6 +464,10 @@ void cChunk::Tick(float a_Dt, MTRand & a_TickRandom)
 					if( m_World->GetBlock( XX, YY, ZZ ) == E_BLOCK_AIR )
 					{
 						SetBlock( X, Y, Z, 0, 0 );
+
+						Vector3i wPos = PositionToWorldPosition( Vector3i(X, Y, Z) );
+
+						m_World->GetSimulatorManager()->WakeUp(wPos.x, wPos.y, wPos.z);
 						if (isRedstone) {
 							cRedstone Redstone(m_World);
 							Redstone.ChangeRedstone( (X+m_PosX*16), (Y+m_PosY*16), (Z+m_PosZ*16), false );
@@ -953,7 +957,8 @@ void cChunk::FastSetBlock( int a_X, int a_Y, int a_Z, char a_BlockType, char a_B
 	
 	const int index = a_Y + (a_Z * 128) + (a_X * 128 * 16);
 	const char OldBlock = m_BlockType[index];
-	if (OldBlock == a_BlockType)
+	const char OldBlockMeta = GetLight( m_BlockMeta, index );
+	if (OldBlock == a_BlockType && OldBlockMeta == a_BlockMeta)
 	{
 		return;
 	}
@@ -1399,6 +1404,15 @@ void cChunk::PositionToWorldPosition(int a_ChunkX, int a_ChunkY, int a_ChunkZ, i
 
 
 
+Vector3i cChunk::PositionToWorldPosition( const Vector3i & a_InChunkPos )
+{
+	return Vector3i( m_PosX * 16 + a_InChunkPos.x, a_InChunkPos.y, m_PosZ * 16 + a_InChunkPos.z );
+}
+
+
+
+
+
 #if !C_CHUNK_USE_INLINE
 # include "cChunk.inc"
 #endif

source/cChunk.h

@@ -210,6 +210,7 @@ public:
 	void SetLight(char* a_Buffer, int x, int y, int z, char light);
 
 	void PositionToWorldPosition(int a_ChunkX, int a_ChunkY, int a_ChunkZ, int & a_X, int & a_Y, int & a_Z);
+	Vector3i PositionToWorldPosition( const Vector3i & a_InChunkPos );
 
 	inline static unsigned int MakeIndex(int x, int y, int z )
 	{

source/cPiston.cpp

@@ -56,7 +56,8 @@ void cPiston::ExtendPiston( int pistx, int pisty, int pistz ) {
 	char pistonMeta = m_World->GetBlockMeta( pistx, pisty, pistz );
 	char isSticky = (char)(pistonBlock == E_BLOCK_STICKY_PISTON) * 8;
 	bool recalc = false;
-	if (pistonMeta < 6) {// only extend if piston is not already extended 
+	if ( (pistonMeta & 0x8) == 0x0 ) // only extend if piston is not already extended 
+	{
 		unsigned short dist = FirstPassthroughBlock(pistx, pisty, pistz, pistonMeta);
 		if(dist>9000) return; // too many blocks
 	
@@ -89,7 +90,7 @@ void cPiston::ExtendPiston( int pistx, int pisty, int pistz ) {
 		Action.m_Byte2	=	pistonMeta;
 
 		m_World->BroadcastToChunkOfBlock(pistx, pisty, pistz, &Action);
-		m_World->FastSetBlock( pistx, pisty, pistz, pistonBlock, pistonMeta | 8 );
+		m_World->FastSetBlock( pistx, pisty, pistz, pistonBlock, pistonMeta | 0x8 );
 
 		int extx = pistx;
 		int exty = pisty;

source/cRedstoneSimulator.cpp

@@ -0,0 +1,523 @@
+#include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules
+
+#include "cRedstoneSimulator.h"
+#include "cPiston.h"
+#include "cWorld.h"
+#include "BlockID.h"
+#include "cCriticalSection.h"
+#include "cTorch.h"
+
+#include "cRedstone.h"
+
+
+
+cRedstoneSimulator::cRedstoneSimulator( cWorld* a_World )
+	: super(a_World)
+{
+}
+
+
+
+
+
+cRedstoneSimulator::~cRedstoneSimulator()
+{
+}
+
+
+
+
+
+void cRedstoneSimulator::WakeUp( int a_X, int a_Y, int a_Z )
+{
+	if( cRedstone::s_UseRedstone ) return; // Using the other/broken simulator
+
+	cCSLock Lock( m_CS );
+	m_Blocks.push_back( Vector3i( a_X, a_Y, a_Z ) );
+}
+
+
+
+
+
+void cRedstoneSimulator::Simulate( float a_Dt )
+{
+	if( cRedstone::s_UseRedstone ) return; // Using the other/broken simulator
+
+	// Toggle torches on/off
+	while( !m_RefreshTorchesAround.empty() )
+	{
+		Vector3i pos = m_RefreshTorchesAround.back();
+		m_RefreshTorchesAround.pop_back();
+
+		RefreshTorchesAround( pos );
+	}
+
+	// Handle changed blocks
+	{
+		cCSLock Lock( m_CS );
+		std::swap( m_Blocks, m_BlocksBuffer );
+	}
+	for( BlockList::iterator itr = m_BlocksBuffer.begin(); itr != m_BlocksBuffer.end(); ++itr )
+	{
+		HandleChange( *itr );
+	}
+	m_BlocksBuffer.clear();
+}
+
+
+
+
+
+void cRedstoneSimulator::RefreshTorchesAround( const Vector3i & a_BlockPos )
+{
+	static Vector3i Surroundings [] = {
+		Vector3i(-1, 0, 0),
+		Vector3i( 1, 0, 0),
+		Vector3i( 0, 0,-1),
+		Vector3i( 0, 0, 1),
+		Vector3i( 0, 1, 0), // Also toggle torch on top
+	};
+	char TargetBlockID = E_BLOCK_REDSTONE_TORCH_ON;
+	if( IsPowered( a_BlockPos, true ) )
+	{
+		TargetBlockID = E_BLOCK_REDSTONE_TORCH_OFF;
+		if( m_World->GetBlock( a_BlockPos ) == E_BLOCK_DIRT )
+		{
+			m_World->FastSetBlock( a_BlockPos.x, a_BlockPos.y, a_BlockPos.z, E_BLOCK_STONE, 0 );
+		}
+	}
+	else
+	{
+		if( m_World->GetBlock( a_BlockPos ) == E_BLOCK_STONE )
+		{
+			m_World->FastSetBlock( a_BlockPos.x, a_BlockPos.y, a_BlockPos.z, E_BLOCK_DIRT, 0 );
+		}
+	}
+
+	for( unsigned int i = 0; i < ARRAYCOUNT( Surroundings ); ++i )
+	{
+		Vector3i TorchPos = a_BlockPos + Surroundings[i];
+		const char Block = m_World->GetBlock( TorchPos );
+		if( Block == E_BLOCK_REDSTONE_TORCH_ON || Block == E_BLOCK_REDSTONE_TORCH_OFF )
+		{
+			if( Block != TargetBlockID )
+			{
+				char TorchMeta = m_World->GetBlockMeta( TorchPos );
+				if( cTorch::IsAttachedTo( TorchPos, TorchMeta, a_BlockPos ) )
+				{
+					m_World->FastSetBlock( TorchPos.x, TorchPos.y, TorchPos.z, TargetBlockID, m_World->GetBlockMeta( TorchPos ) );
+					m_Blocks.push_back( TorchPos );
+				}
+			}
+		}
+	}
+}
+
+
+
+
+
+void cRedstoneSimulator::HandleChange( const Vector3i & a_BlockPos )
+{
+	std::deque< Vector3i > SpreadStack;
+
+	Vector3i Surroundings[] = {
+		Vector3i( 1, 0, 0 ),
+		Vector3i( 1, 1, 0 ),
+		Vector3i( 1,-1, 0 ),
+		Vector3i(-1, 0, 0 ),
+		Vector3i(-1, 1, 0 ),
+		Vector3i(-1,-1, 0 ),
+		Vector3i( 0, 0, 1 ),
+		Vector3i( 0, 1, 1 ),
+		Vector3i( 0,-1, 1 ),
+		Vector3i( 0, 0,-1 ),
+		Vector3i( 0, 1,-1 ),
+		Vector3i( 0,-1,-1 ),
+		Vector3i( 0,-1, 0 ),
+	};
+
+	char Block = m_World->GetBlock( a_BlockPos );
+
+	// First check whether torch should be on or off
+	if( Block == E_BLOCK_REDSTONE_TORCH_ON || Block == E_BLOCK_REDSTONE_TORCH_OFF )
+	{
+		static Vector3i Surroundings [] = {
+			Vector3i(-1, 0, 0),
+			Vector3i( 1, 0, 0),
+			Vector3i( 0, 0,-1),
+			Vector3i( 0, 0, 1),
+			Vector3i( 0,-1, 0),
+		};
+		for( unsigned int i = 0; i < ARRAYCOUNT( Surroundings ); ++i )
+		{
+			Vector3i pos = a_BlockPos + Surroundings[i];
+			char OtherBlock = m_World->GetBlock( pos );
+			if( (OtherBlock != E_BLOCK_AIR) && (OtherBlock != E_BLOCK_REDSTONE_TORCH_ON) && (OtherBlock != E_BLOCK_REDSTONE_TORCH_OFF) )
+			{
+				RefreshTorchesAround( pos );
+			}
+		}
+		Block = m_World->GetBlock( a_BlockPos ); // Make sure we got the updated block
+	}
+
+	BlockList Sources;
+	// If torch is still on, use it as a source
+	if( Block == E_BLOCK_REDSTONE_TORCH_ON )
+	{
+		Sources.push_back( a_BlockPos );
+	}
+
+	// Power all blocks legally connected to the sources
+	{
+		BlockList NewSources = RemoveCurrent( a_BlockPos );
+		Sources.insert( Sources.end(), NewSources.begin(), NewSources.end() );
+		while( !Sources.empty() )
+		{
+			static Vector3i Surroundings [] = {
+				Vector3i(-1, 0, 0),
+				Vector3i( 1, 0, 0),
+				Vector3i( 0, 0,-1),
+				Vector3i( 0, 0, 1),
+			};
+
+			Vector3i SourcePos = Sources.back();
+			for( unsigned int i = 0; i < ARRAYCOUNT( Surroundings ); ++i )
+			{
+				Vector3i OtherPos =  SourcePos + Surroundings[i];
+				if( PowerBlock( OtherPos, a_BlockPos, 0xf ) )
+				{
+					SpreadStack.push_back( OtherPos ); // Changed, so add to stack
+				}
+			}
+			Sources.pop_back();
+		}
+	}
+
+
+	// Do a floodfill
+	while( !SpreadStack.empty() )
+	{
+		Vector3i pos = SpreadStack.back();
+		SpreadStack.pop_back();
+
+		char Meta = m_World->GetBlockMeta( pos );
+
+		for( unsigned int i = 0; i < ARRAYCOUNT( Surroundings ); ++i )
+		{
+			Vector3i OtherPos =  pos + Surroundings[i];
+			if( PowerBlock( OtherPos, pos, Meta-1 ) )
+			{
+				SpreadStack.push_back( OtherPos ); // Changed, so add to stack
+			}
+		}
+	}
+
+	// Only after a redstone area has been completely simulated the redstone entities can react
+	while( !m_RefreshPistons.empty() )
+	{
+		Vector3i pos = m_RefreshPistons.back();
+		m_RefreshPistons.pop_back();
+
+		char Block = m_World->GetBlock( pos );
+		switch( Block )
+		{
+		case E_BLOCK_PISTON:
+			if( IsPowered( pos ) )
+			{
+				cPiston Piston( m_World );
+				Piston.ExtendPiston( pos.x, pos.y, pos.z );
+			}
+			else
+			{
+				cPiston Piston( m_World );
+				Piston.RetractPiston( pos.x, pos.y, pos.z );
+			}
+			break;
+		default:
+			break;
+		};
+	}
+}
+
+
+
+
+
+bool cRedstoneSimulator::PowerBlock( const Vector3i & a_BlockPos, const Vector3i & a_FromBlock, char a_Power )
+{
+	char Block = m_World->GetBlock( a_BlockPos );
+	switch( Block )
+	{
+	case E_BLOCK_REDSTONE_WIRE:
+		{
+			if( m_World->GetBlockMeta( a_BlockPos ) < a_Power )
+			{
+				m_World->SetBlockMeta( a_BlockPos, a_Power );
+				return true;
+			}
+		}
+		break;
+	case E_BLOCK_PISTON:
+		{
+			m_RefreshPistons.push_back( a_BlockPos );
+		}
+		break;
+	default:
+		{
+			if( Block != E_BLOCK_AIR && Block != E_BLOCK_REDSTONE_TORCH_ON && Block != E_BLOCK_REDSTONE_TORCH_OFF )
+			{
+				if( IsPowered( a_BlockPos, true ) )
+				{
+					m_RefreshTorchesAround.push_back( a_BlockPos );
+				}
+			}
+		}
+		break;
+	};
+
+	return false;
+}
+
+
+
+
+
+int cRedstoneSimulator::UnPowerBlock( const Vector3i & a_BlockPos )
+{
+	char Block = m_World->GetBlock( a_BlockPos );
+	switch( Block )
+	{
+	case E_BLOCK_REDSTONE_WIRE:
+		{
+			if( m_World->GetBlockMeta( a_BlockPos ) > 0 )
+			{
+				m_World->SetBlockMeta( a_BlockPos, 0 );
+				return 1;
+			}
+		}
+		break;
+	case E_BLOCK_PISTON:
+		{
+			m_RefreshPistons.push_back( a_BlockPos );
+		}
+		break;
+	case E_BLOCK_REDSTONE_TORCH_ON:
+		{
+			return 2;
+		}
+		break;
+	default:
+		if( Block != E_BLOCK_AIR && Block != E_BLOCK_REDSTONE_TORCH_ON && Block != E_BLOCK_REDSTONE_TORCH_OFF )
+		{
+			if( !IsPowered( a_BlockPos, true ) )
+			{
+				m_RefreshTorchesAround.push_back( a_BlockPos );
+			}
+		}
+		break;
+	};
+
+	return 0;
+}
+
+
+
+
+
+// Removes current from all powered redstone wires until it reaches an energy source.
+// Also returns all energy sources it encountered
+cRedstoneSimulator::BlockList cRedstoneSimulator::RemoveCurrent( const Vector3i & a_BlockPos )
+{
+	std::deque< Vector3i > SpreadStack;
+	std::deque< Vector3i > FoundSources;
+
+	Vector3i Surroundings[] = {
+		Vector3i( 1, 0, 0 ),
+		Vector3i( 1, 1, 0 ),
+		Vector3i( 1,-1, 0 ),
+		Vector3i(-1, 0, 0 ),
+		Vector3i(-1, 1, 0 ),
+		Vector3i(-1,-1, 0 ),
+		Vector3i( 0, 0, 1 ),
+		Vector3i( 0, 1, 1 ),
+		Vector3i( 0,-1, 1 ),
+		Vector3i( 0, 0,-1 ),
+		Vector3i( 0, 1,-1 ),
+		Vector3i( 0,-1,-1 ),
+		Vector3i( 0,-1, 0 ),
+	};
+
+	char Block = m_World->GetBlock( a_BlockPos );
+	if( Block == E_BLOCK_REDSTONE_TORCH_OFF || Block == E_BLOCK_REDSTONE_TORCH_ON )
+	{
+		static Vector3i Surroundings [] = {	// Torches only spread on the same level
+			Vector3i(-1, 0, 0),
+			Vector3i( 1, 0, 0),
+			Vector3i( 0, 0,-1),
+			Vector3i( 0, 0, 1),
+		};
+
+		for( unsigned int i = 0; i < ARRAYCOUNT( Surroundings ); ++i )
+		{
+			Vector3i pos = Vector3i( a_BlockPos ) + Surroundings[i];
+			int RetVal = UnPowerBlock( pos );
+			if( RetVal == 1 )
+			{
+				SpreadStack.push_back( pos ); // Changed, so add to stack
+			}
+			else if( RetVal == 2 )
+			{
+				FoundSources.push_back( pos );
+			}
+		}
+	}
+	else
+	{
+		SpreadStack.push_back( a_BlockPos );
+	}
+
+
+	while( !SpreadStack.empty() )
+	{
+		Vector3i pos = SpreadStack.back();
+		SpreadStack.pop_back();
+
+		for( unsigned int i = 0; i < ARRAYCOUNT( Surroundings ); ++i )
+		{
+			Vector3i OtherPos =  pos + Surroundings[i];
+			int RetVal = UnPowerBlock( OtherPos );
+			if( RetVal == 1 )
+			{
+				SpreadStack.push_back( OtherPos ); // Changed, so add to stack
+			}
+			else if( RetVal == 2 )
+			{
+				FoundSources.push_back( OtherPos );
+			}
+		}
+	}
+
+	return FoundSources;
+}
+
+
+
+
+
+bool cRedstoneSimulator::IsPowered( const Vector3i & a_BlockPos, bool a_bOnlyByWire /* = false */ )
+{
+	char NegX = m_World->GetBlock( a_BlockPos.x-1, a_BlockPos.y, a_BlockPos.z );
+	if( !a_bOnlyByWire && NegX == E_BLOCK_REDSTONE_TORCH_ON )	return true;
+	if( NegX == E_BLOCK_REDSTONE_WIRE )
+	{
+		if( m_World->GetBlockMeta( a_BlockPos.x-1, a_BlockPos.y, a_BlockPos.z ) > 0 )
+		{
+			if( GetDirection( a_BlockPos.x-1, a_BlockPos.y, a_BlockPos.z ) == REDSTONE_X_POS )
+			{
+				return true;
+			}
+		}
+	}
+	char PosX = m_World->GetBlock( a_BlockPos.x+1, a_BlockPos.y, a_BlockPos.z );
+	if( !a_bOnlyByWire && PosX == E_BLOCK_REDSTONE_TORCH_ON )	return true;
+	if( PosX == E_BLOCK_REDSTONE_WIRE )
+	{
+		if( m_World->GetBlockMeta( a_BlockPos.x+1, a_BlockPos.y, a_BlockPos.z ) > 0 )
+		{
+			if( GetDirection( a_BlockPos.x+1, a_BlockPos.y, a_BlockPos.z ) == REDSTONE_X_NEG )
+			{
+				return true;
+			}
+		}
+	}
+	char NegZ = m_World->GetBlock( a_BlockPos.x, a_BlockPos.y, a_BlockPos.z-1 );
+	if( !a_bOnlyByWire && NegZ == E_BLOCK_REDSTONE_TORCH_ON )	return true;
+	if( NegZ == E_BLOCK_REDSTONE_WIRE )
+	{
+		if( m_World->GetBlockMeta( a_BlockPos.x, a_BlockPos.y, a_BlockPos.z-1 ) > 0 )
+		{
+			if( GetDirection( a_BlockPos.x, a_BlockPos.y, a_BlockPos.z-1 ) == REDSTONE_Z_POS )
+			{
+				return true;
+			}
+		}
+	}
+	char PosZ = m_World->GetBlock( a_BlockPos.x, a_BlockPos.y, a_BlockPos.z+1 );
+	if( !a_bOnlyByWire && PosZ == E_BLOCK_REDSTONE_TORCH_ON )	return true;
+	if( PosZ == E_BLOCK_REDSTONE_WIRE )
+	{
+		if( m_World->GetBlockMeta( a_BlockPos.x, a_BlockPos.y, a_BlockPos.z+1 ) > 0 )
+		{
+			if( GetDirection( a_BlockPos.x, a_BlockPos.y, a_BlockPos.z+1 ) == REDSTONE_Z_NEG )
+			{
+				return true;
+			}
+		}
+	}
+
+	// Only wires can power the bottom block
+	char PosY = m_World->GetBlock( a_BlockPos.x, a_BlockPos.y+1, a_BlockPos.z );
+	if( PosY == E_BLOCK_REDSTONE_WIRE )
+	{
+		if( m_World->GetBlockMeta( a_BlockPos.x, a_BlockPos.y+1, a_BlockPos.z ) > 0 )
+		{
+			return true;
+		}
+	}
+
+	return false;
+}
+
+
+
+
+// Believe me, it works!! 
+cRedstoneSimulator::eRedstoneDirection cRedstoneSimulator::GetDirection( int a_X, int a_Y, int a_Z )
+{
+	int Dir = REDSTONE_NONE;
+
+	char NegX = m_World->GetBlock( a_X-1, a_Y, a_Z );
+	if( NegX == E_BLOCK_REDSTONE_WIRE || NegX == E_BLOCK_REDSTONE_TORCH_ON )
+	{
+		Dir |= (REDSTONE_X_POS);
+	}
+	char PosX = m_World->GetBlock( a_X+1, a_Y, a_Z );
+	if( PosX == E_BLOCK_REDSTONE_WIRE || PosX == E_BLOCK_REDSTONE_TORCH_ON )
+	{
+		Dir |= (REDSTONE_X_NEG);
+	}
+	char NegZ = m_World->GetBlock( a_X, a_Y, a_Z-1 );
+	if( NegZ == E_BLOCK_REDSTONE_WIRE || NegZ == E_BLOCK_REDSTONE_TORCH_ON )
+	{
+		if( (Dir & REDSTONE_X_POS) && !(Dir & REDSTONE_X_NEG ) ) //corner
+		{
+			Dir ^= REDSTONE_X_POS;
+			Dir |= REDSTONE_X_NEG;
+		}
+		if( (Dir & REDSTONE_X_NEG) && !(Dir & REDSTONE_X_POS ) ) //corner
+		{
+			Dir ^= REDSTONE_X_NEG;
+			Dir |= REDSTONE_X_POS;
+		}
+		Dir |= REDSTONE_Z_POS;
+	}
+	char PosZ = m_World->GetBlock( a_X, a_Y, a_Z+1 );
+	if( PosZ == E_BLOCK_REDSTONE_WIRE || PosZ == E_BLOCK_REDSTONE_TORCH_ON )
+	{
+		if( (Dir & REDSTONE_X_POS) && !(Dir & REDSTONE_X_NEG ) ) //corner
+		{
+			Dir ^= REDSTONE_X_POS;
+			Dir |= REDSTONE_X_NEG;
+		}
+		if( (Dir & REDSTONE_X_NEG) && !(Dir & REDSTONE_X_POS ) ) //corner
+		{
+			Dir ^= REDSTONE_X_NEG;
+			Dir |= REDSTONE_X_POS;
+		}
+		Dir |= REDSTONE_Z_NEG;
+	}
+
+	return (eRedstoneDirection)Dir;
+}

source/cRedstoneSimulator.h

@@ -0,0 +1,50 @@
+#pragma once
+
+#include "cSimulator.h"
+#include "Vector3i.h"
+
+class cRedstoneSimulator : public cSimulator
+{
+	typedef cSimulator super;
+public:
+	cRedstoneSimulator( cWorld* a_World );
+	~cRedstoneSimulator();
+
+	virtual void Simulate( float a_Dt );
+	virtual bool IsAllowedBlock( char a_BlockID ) { return true; }
+
+	virtual void WakeUp( int a_X, int a_Y, int a_Z );
+
+	enum eRedstoneDirection
+	{
+		REDSTONE_NONE =  0,
+		REDSTONE_X_POS = 0x1,
+		REDSTONE_X_NEG = 0x2,
+		REDSTONE_Z_POS = 0x4,
+		REDSTONE_Z_NEG = 0x8,
+	};
+	eRedstoneDirection GetDirection( int a_X, int a_Y, int a_Z );
+	eRedstoneDirection GetDirection( const Vector3i & a_Pos ) { return GetDirection( a_Pos.x, a_Pos.y, a_Pos.z ); }
+private:
+	typedef std::deque <Vector3i> BlockList;
+
+	virtual void AddBlock(int a_X, int a_Y, int a_Z) {}
+
+	void HandleChange( const Vector3i & a_BlockPos );
+	BlockList RemoveCurrent( const Vector3i & a_BlockPos );
+
+	bool PowerBlock( const Vector3i & a_BlockPos, const Vector3i & a_FromBlock, char a_Power );
+	int UnPowerBlock( const Vector3i & a_BlockPos );
+
+	bool IsPowered( const Vector3i & a_BlockPos, bool a_bOnlyByWire = false );
+	
+	BlockList m_Blocks;
+	BlockList m_BlocksBuffer;
+
+	BlockList m_RefreshPistons;
+
+	BlockList m_RefreshTorchesAround;
+	void RefreshTorchesAround( const Vector3i & a_BlockPos );
+
+	cCriticalSection m_CS;
+};

source/cTorch.h

@@ -1,5 +1,7 @@
 #pragma once
 
+#include "Vector3i.h"
+
 class cTorch												//tolua_export
 {															//tolua_export
 public:
@@ -48,4 +50,45 @@ public:
 		return 0x0;
 	}														//tolua_export
 
+	static bool IsAttachedTo( const Vector3i & a_TorchPos, char a_TorchMeta, const Vector3i & a_BlockPos )
+	{
+		switch( a_TorchMeta )
+		{
+		case 0x0:
+		case 0x5:	// On floor
+			if( (a_TorchPos - a_BlockPos).Equals( Vector3i(0, 1, 0 ) ) )
+			{
+				return true;
+			}
+			break;
+		case 0x4: // South -Z
+			if( (a_TorchPos - a_BlockPos).Equals( Vector3i(0, 0, -1 ) ) )
+			{
+				return true;
+			}
+			break;
+		case 0x3: // North +Z
+			if( (a_TorchPos - a_BlockPos).Equals( Vector3i(0, 0, 1 ) ) )
+			{
+				return true;
+			}
+			break;
+		case 0x2: // West -X
+			if( (a_TorchPos - a_BlockPos).Equals( Vector3i(-1, 0, 0 ) ) )
+			{
+				return true;
+			}
+			break;
+		case 0x1: // East +X
+			if( (a_TorchPos - a_BlockPos).Equals( Vector3i( 1, 0, 0 ) ) )
+			{
+				return true;
+			}
+			break;
+		default:
+			break;
+		};
+		return false;
+	}
+
 };															//tolua_export

source/cWorld.cpp

@@ -19,6 +19,7 @@
 #include "cLavaSimulator.h"
 #include "cFireSimulator.h"
 #include "cSandSimulator.h"
+#include "cRedstoneSimulator.h"
 #include "cChicken.h"
 #include "cSpider.h"
 #include "cCow.h" //cow
@@ -160,6 +161,7 @@ cWorld::~cWorld()
 	delete m_WaterSimulator;
 	delete m_LavaSimulator;
 	delete m_FireSimulator;
+	delete m_RedstoneSimulator;
 
 	m_Generator.Stop();
 
@@ -248,12 +250,14 @@ cWorld::cWorld( const AString & a_WorldName )
 	m_LavaSimulator = new cLavaSimulator( this );
 	m_SandSimulator = new cSandSimulator(this);
 	m_FireSimulator = new cFireSimulator(this);
+	m_RedstoneSimulator = new cRedstoneSimulator(this);
 
 	m_SimulatorManager = new cSimulatorManager();
 	m_SimulatorManager->RegisterSimulator(m_WaterSimulator, 6);
 	m_SimulatorManager->RegisterSimulator(m_LavaSimulator, 12);
 	m_SimulatorManager->RegisterSimulator(m_SandSimulator, 1);
 	m_SimulatorManager->RegisterSimulator(m_FireSimulator, 10);
+	m_SimulatorManager->RegisterSimulator(m_RedstoneSimulator, 1);
 
 	memset( g_BlockLightValue, 0x0, 128 );
 	memset( g_BlockSpreadLightFalloff, 0xf, 128 ); // 0xf means total falloff

source/cWorld.h

@@ -14,6 +14,7 @@
 #include "cChunkMap.h"
 #include "WorldStorage.h"
 #include "cChunkGenerator.h"
+#include "Vector3i.h"
 
 
 
@@ -25,6 +26,7 @@ class cFireSimulator;
 class cWaterSimulator;
 class cLavaSimulator;
 class cSandSimulator;
+class cRedstoneSimulator;
 class cItem;
 class cPlayer;
 class cClientHandle;
@@ -147,8 +149,11 @@ public:
 	void SetBlock( int a_X, int a_Y, int a_Z, char a_BlockType, char a_BlockMeta );	//tolua_export
 	void FastSetBlock( int a_X, int a_Y, int a_Z, char a_BlockType, char a_BlockMeta );	//tolua_export
 	char GetBlock( int a_X, int a_Y, int a_Z );										//tolua_export
+	char GetBlock( const Vector3i & a_Pos ) { return GetBlock( a_Pos.x, a_Pos.y, a_Pos.z ); } //tolua_export
 	char GetBlockMeta( int a_X, int a_Y, int a_Z );									//tolua_export
+	char GetBlockMeta( const Vector3i & a_Pos ) { return GetBlockMeta( a_Pos.x, a_Pos.y, a_Pos.z ); } //tolua_export
 	void SetBlockMeta( int a_X, int a_Y, int a_Z, char a_MetaData );				//tolua_export
+	void SetBlockMeta( const Vector3i & a_Pos, char a_MetaData ) { SetBlockMeta( a_Pos.x, a_Pos.y, a_Pos.z, a_MetaData ); } //tolua_export
 	bool DigBlock( int a_X, int a_Y, int a_Z, cItem & a_PickupItem );				//tolua_export
 	void SendBlockTo( int a_X, int a_Y, int a_Z, cPlayer* a_Player );				//tolua_export
 
@@ -237,11 +242,12 @@ private:
 	friend class cRedstone;
 	std::vector<int> m_RSList;
 
-	cSimulatorManager * m_SimulatorManager;
+	cSimulatorManager *  m_SimulatorManager;
-	cSandSimulator *    m_SandSimulator;
+	cSandSimulator *     m_SandSimulator;
-	cWaterSimulator *   m_WaterSimulator;
+	cWaterSimulator *    m_WaterSimulator;
-	cLavaSimulator *    m_LavaSimulator;
+	cLavaSimulator *     m_LavaSimulator;
-	cFireSimulator *    m_FireSimulator;
+	cFireSimulator *     m_FireSimulator;
+	cRedstoneSimulator * m_RedstoneSimulator;
 	
 	cCriticalSection m_CSClients;
 	cCriticalSection m_CSEntities;