summaryrefslogblamecommitdiffstats
path: root/source/cChunk.cpp
blob: 6d260e5b142dea3b25693df090a402140e74cda6 (plain) (tree)
1
2
3
4
5
6
7
8
9
10
 

                                                                                               
               
                           
       

 

                    

                             



                           


                            


                     
                       


                    
                            
                             
                     
 


                                           



                                        
 

 
 


                             
 

 


                                                                                                                        



                                                                                                                                            


                                   
                                                                








                                                                                                                        
                                                                                                   
                             

                             


                            
                             
                                 
                           
                                

                            
                         
  
                                                                                                            





  

                  

                                                                                                                          
                                                                                                            


                             
                                 
 


                                                                                                   
          
                                                                            
                  
                                                  

                  
                                                                                         
          

                                           
          
                            

  


 
 
                            
  

                          
                                                  








                                                                              
                                                                                                               
          
                                                        
                                           
  
 
 
 
 


                             
                                                                             






























                              
                    





  













                                  
                                                         
  
                                                
                                               

                                                
                                                  

                                                   
         

                                                                                             
                                         



                                                                                                            
                                              






          
                         





                                            


                                           
  

                                                            




                                                                       











                                                                                   




                                      
 



                                                                                                                



                                                                                                            



                                                                                      
 
                                 





  















                                                                                                                    
                                                     
  
                                                       





  
                                                   
  



                                                                              





  














                                                                                                            

  



 










                                                                             
                                                     
  

                                                                     





                                                                   

                                                                                                        


                                                                                      
                                                                     
                                                                        
 

                                                                                                            
                                                                           
                  

                                                                

                                         



                                                                     
                                                                     
                                                                                                   

                                                         


                                                                        
                                                                       
                                                                                   

                                                  
                                             
          
                       
 
                                         




                                                        

                                                                

          
                                       
                                                            
                        
 
                                 






                                                                          
                                                                                                                          
                  
                                                     
                                                                        
 

                                                               
                                           
                          


                                                                    

                                                           
                                                       
                                  












                                                                                                                          
                                  
                                                                                                             
                                          
                                                                                      
 
                                                                                                         
 
                                                                                                                            



                                                                                                                        
                                          
                                               
                                  



                                                                 
                                                           



                                                       
                                  





                                                                                                                      
                                          
                                                                                      
 
                                                                                                                            
 


                                                                                                                        
                                          
                                               
                                  

                                                     
                                  




                                                                                                                       
                                          
                                                                                      


                                                                                                                        
                                          
                                               
                                  










                                                                                                            
                                                                                          
                  
          
  
 




                                               
                           



                                                                                                                                             


                                  
 



                                                                                                                                     


                                                                                           







                                                          

                                                                                                  


                                                          
 
                                                                                                   
                                                    

                             
                                            
                          


                                                                                                                                             
                                  
                                                                                                                                                 
                                  


                                                                                                                                
                                       
                          
                         
                                            
                          

                                                                  
                                  
                                                                                                                       
                                  
                                       
                          
                         


                                                                                                                                             

                                                                                                              
                                              
                          










                                                                                                                                     
                          

                                                                                                          
                          





                                       
                          



                  



 











































                                                                                                                                
                                                                                                                            






















                                                                                                                  
                                                                                   
















                                                                                                                                          





































































                                                                                                                                   

                                                                                                                         
                                                                                                          



















                                                                                                                     
                                                                                                          

















                                                                                                                         
                                                                                                          















                                                                                
                                          
  
                                                                            
         
                                                                        
          
                                                       
          


                  



 
                                       
  
                                        
          
                                                
                  
                                                         
                          
                                                                                                               
                                                     
                                  
                                                            
                                          
                                                                                                                                    
                                                  
                                                                                                                                                                              
                                                  
                                                       
                                          

                                                              
                                          
                                                                                                                                    
                                                  
                                                                                                                                                                                
                                                  
                                                       
                                          


                                                                
                                          
                                                                                                                                    
                                                  
                                                                                                                                                                                        
                                                  
                                                       
                                          



                                                         

  



 

                                  
                                        
          
                                                
                  
                                                              
                          
                                                                  
                                                                        
                                  
                                                                                       

                                               


                                    

  



 
                                                                                                           
  
                                                                                                              
          
                                 

          
                                                                 
         
                                                                


                                                                  
 
                                                      
 




                                                                            

                     











                                                                                                           
                                        


                                        
                                                            
          

                                                
                                                                        


                     
                                                             
                          
                                                                                                         
                                  
                                                                                   



                                                            
          
 






                                                                                     
 
                                                                               
                                                                






                                                  
          
                                    
                  
                                                                                                          
                               
                  
                                      
                  
                                                                                                            
                               
                  

                                        
                  
                                                                                                                                     
                               




                                   
 
 
 
                                                                                                    
  
                                                                                                     
 
                           
         
                                                             


                                                                        


                        


                     
                                           
 




                                                        
                                                      
 
                                                        




                                                                                                       
          
                                        

          
                                        
                                                   
          

                                                
                                                                             




                                                          
                                                                                                
                                  
                                                                                           



                                                            
          

  



 



                                                                               
                                              


                                                                 




                                                                            
                  


                        
                                                                                                                
          
                                        

                                                                         
                                                                                      
                                                         


                                                                        

                                                          
                                                                                 
                                                                                           
                                              





                                                       



 

                                                           





























                                                                                                            












                                                                           

                                                        





                                                                                             
                                                                              








                                                                               
                                     











                                                                                                                                                                











                                                                                                            
                                     



                                                                                                               

  



 

                                                              
                                      
                     
                                                 

  



 
                                                
  
                                                                                                               
          
                                      
                  

                                                         
                  
          
                                                
 
                                                                                              
          
                                                                                                                                                                                                 

                                             
                     

  



 

                                                     
                                                                                                               
          
                                      
                  
                                  
                  













                                                                                                                                                                         

  



 
                                                  
  







                                                                                                                     

  



 
                                 
  
                                          

  



 
                                            
  
                                                                      


                             
                                          

  



 
                                              
  



                                               
                                     
          
                                                                      
                                                                              


                                     
          

  



 
                                                        
  
                                                                                                                          
 
                                                                  

  



 
                                             
  

                                                                  

  



 

                                                              
                                                                                                          

                            

                                                                              


                                                
          

                              
 

                                                                             
                                                                             


                              
                                    



                                                                                   
                  
                                            
                          
                                                                                                   
                                                                   
                                  
                                                                                                          

                                                            
                                  
                                                                          
                                       

                          
                                              
                          
                                                                                                        
                                                                     
                                  
                                                                                                            

                                                              
                                  
                                                                            
                                       

                          

                                                
                          
                                                                                                          
                                                                     
                                  
                                                                                                         

                                                           
                                  
                                                                         
                                       

                          
                                 
                          
                                                                           


                                       
          
                   
 
                                  
                                                  
          
                                                                          


             
                                                                                            
          
                           
                     
  
   
 



 
                                                                            
  
                                                                                                                      
          



                                       
                                         
                                         


  


 


                                                                                                                

                                         

  



 
                                                                                     
  
                                                                                                             





  
                        
                         




       

#include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules

#ifndef _WIN32
	#include <cstdlib>
#endif


#include "cChunk.h"
#include "cWorld.h"
#include "cWaterSimulator.h"
#include "cLavaSimulator.h"
#include "cClientHandle.h"
#include "cServer.h"
#include "zlib.h"
#include "Defines.h"
#include "cChestEntity.h"
#include "cFurnaceEntity.h"
#include "cSignEntity.h"
#include "cTorch.h"
#include "cLadder.h"
#include "cPickup.h"
#include "cRedstone.h"
#include "cItem.h"
#include "cNoise.h"
#include "cRoot.h"
#include "cBlockToPickup.h"
#include "MersenneTwister.h"
#include "cPlayer.h"

#include "packets/cPacket_DestroyEntity.h"
#include "packets/cPacket_PreChunk.h"
#include "packets/cPacket_BlockChange.h"
#include "packets/cPacket_MultiBlock.h"

#include <json/json.h>





extern bool g_bWaterPhysics;





///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// sSetBlock:

sSetBlock::sSetBlock( int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta )  // absolute block position
	: x( a_BlockX )
	, y( a_BlockY )
	, z( a_BlockZ )
	, BlockType( a_BlockType )
	, BlockMeta( a_BlockMeta )
{
	cChunkDef::AbsoluteToRelative(x, y, z, ChunkX, ChunkZ);
}





///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// cChunk:

cChunk::cChunk(int a_ChunkX, int a_ChunkY, int a_ChunkZ, cChunkMap * a_ChunkMap, cWorld * a_World)
	: m_PosX( a_ChunkX )
	, m_PosY( a_ChunkY )
	, m_PosZ( a_ChunkZ )
	, m_BlockTickX( 0 )
	, m_BlockTickY( 0 )
	, m_BlockTickZ( 0 )
	, m_World( a_World )
	, m_ChunkMap(a_ChunkMap)
	, m_IsValid(false)
	, m_IsLightValid(false)
	, m_IsDirty(false)
	, m_IsSaving(false)
	, m_StayCount(0)
{
	// LOGINFO("### new cChunk (%i, %i) at %p, thread 0x%x ###", a_X, a_Z, this, GetCurrentThreadId());
}





cChunk::~cChunk()
{
	// LOGINFO("### delete cChunk() (%i, %i) from %p, thread 0x%x ###", m_PosX, m_PosZ, this, GetCurrentThreadId() );
	
	for (cBlockEntityList::iterator itr = m_BlockEntities.begin(); itr != m_BlockEntities.end(); ++itr)
	{
		delete *itr;
	}
	m_BlockEntities.clear();

	// Remove and destroy all entities that are not players:
	cEntityList Entities;
	for (cEntityList::const_iterator itr = m_Entities.begin(); itr != m_Entities.end(); ++itr)
	{
		if ((*itr)->GetEntityType() != cEntity::eEntityType_Player)
		{
			Entities.push_back(*itr);
		}
	}
	for (cEntityList::iterator itr = Entities.begin(); itr != Entities.end(); ++itr)
	{
		(*itr)->RemoveFromChunk();
		(*itr)->Destroy();
	}
	m_Entities.clear();
}





void cChunk::SetValid(void)
{
	m_IsValid = true;
	
	m_World->GetChunkMap()->ChunkValidated();
}





void cChunk::MarkRegenerating(void)
{
	// Tell all clients attached to this chunk that they want this chunk:
	for (cClientHandleList::iterator itr = m_LoadedByClient.begin(); itr != m_LoadedByClient.end(); ++itr)
	{
		(*itr)->AddWantedChunk(m_PosX, m_PosZ);
	}  // for itr - m_LoadedByClient[]
}





bool cChunk::CanUnload(void)
{
	return m_LoadedByClient.empty() && !m_IsDirty && (m_StayCount == 0);
}





void cChunk::MarkSaving(void)
{
	m_IsSaving = true;
}





void cChunk::MarkSaved(void)
{
	if (!m_IsSaving)
	{
		return;
	}
	m_IsDirty = false;
}





void cChunk::MarkLoaded(void)
{
	m_IsDirty = false;
	SetValid();
}





void cChunk::MarkLoadFailed(void)
{
	if (m_IsValid)
	{
		return;
	}
	
	m_HasLoadFailed = true;
}





void cChunk::GetAllData(cChunkDataCallback & a_Callback)
{
	a_Callback.HeightMap    (&m_HeightMap);
	a_Callback.BiomeData    (&m_BiomeMap);
	a_Callback.BlockTypes   (m_BlockTypes);
	a_Callback.BlockMeta    (m_BlockMeta);
	a_Callback.LightIsValid (m_IsLightValid);
	a_Callback.BlockLight   (m_BlockLight);
	a_Callback.BlockSkyLight(m_BlockSkyLight);
	
	for (cEntityList::iterator itr = m_Entities.begin(); itr != m_Entities.end(); ++itr)
	{
		a_Callback.Entity(*itr);
	}
	
	for (cBlockEntityList::iterator itr = m_BlockEntities.begin(); itr != m_BlockEntities.end(); ++itr)
	{
		a_Callback.BlockEntity(*itr);
	}
}





void cChunk::SetAllData(
	const BLOCKTYPE *  a_BlockTypes, 
	const NIBBLETYPE * a_BlockMeta,
	const NIBBLETYPE * a_BlockLight,
	const NIBBLETYPE * a_BlockSkyLight,
	const HeightMap *  a_HeightMap,
	const BiomeMap &   a_BiomeMap,
	cEntityList & a_Entities, 
	cBlockEntityList & a_BlockEntities
)
{
	memcpy(m_BiomeMap, a_BiomeMap, sizeof(m_BiomeMap));
	
	if (a_HeightMap != NULL)
	{
		memcpy(m_HeightMap, a_HeightMap, sizeof(m_HeightMap));
	}
	
	memcpy(m_BlockTypes, a_BlockTypes, sizeof(m_BlockTypes));
	memcpy(m_BlockMeta,  a_BlockMeta,  sizeof(m_BlockMeta));
	if (a_BlockLight != NULL)
	{
		memcpy(m_BlockLight, a_BlockLight, sizeof(m_BlockLight));
	}
	if (a_BlockSkyLight != NULL)
	{
		memcpy(m_BlockSkyLight, a_BlockSkyLight, sizeof(m_BlockSkyLight));
	}
	
	m_IsLightValid = (a_BlockLight != NULL) && (a_BlockSkyLight != NULL);
	
	if (a_HeightMap == NULL)
	{
		CalculateHeightmap();
	}

	// Append entities to current entity list:
	m_Entities.splice(m_Entities.end(), a_Entities);
	
	// Clear the block entities present - either the loader / saver has better, or we'll create empty ones:
	for (cBlockEntityList::iterator itr = m_BlockEntities.begin(); itr != m_BlockEntities.end(); ++itr)
	{
		delete *itr;
	}
	std::swap(a_BlockEntities, m_BlockEntities);
	
	// Create block entities that the loader didn't load; fill them with defaults
	CreateBlockEntities();

	m_HasLoadFailed = false;
}





void cChunk::SetLight(
	const cChunkDef::BlockNibbles & a_BlockLight,
	const cChunkDef::BlockNibbles & a_SkyLight
)
{
	// TODO: We might get cases of wrong lighting when a chunk changes in the middle of a lighting calculation.
	// Postponing until we see how bad it is :)
	memcpy(m_BlockLight,    a_BlockLight, sizeof(m_BlockLight));
	memcpy(m_BlockSkyLight, a_SkyLight,   sizeof(m_BlockSkyLight));
	m_IsLightValid = true;
}





void cChunk::GetBlockTypes(BLOCKTYPE * a_BlockTypes)
{
	memcpy(a_BlockTypes, m_BlockTypes, NumBlocks);
}





void cChunk::GetBlockData(BLOCKTYPE * a_BlockData)
{
	memcpy(a_BlockData, m_BlockTypes, NumBlocks);
	memcpy(a_BlockData + MetaOffset,     m_BlockMeta,     NumBlocks / 2);
	memcpy(a_BlockData + LightOffset,    m_BlockLight,    NumBlocks / 2);
	memcpy(a_BlockData + SkyLightOffset, m_BlockSkyLight, NumBlocks / 2);
}





/// Returns true if there is a block entity at the coords specified
bool cChunk::HasBlockEntityAt(int a_BlockX, int a_BlockY, int a_BlockZ)
{
	for (cBlockEntityList::iterator itr = m_BlockEntities.begin(); itr != m_BlockEntities.end(); ++itr)
	{
		if (
			((*itr)->GetPosX() == a_BlockX) &&
			((*itr)->GetPosY() == a_BlockY) &&
			((*itr)->GetPosZ() == a_BlockZ)
		)
		{
			return true;
		}
	}  // for itr - m_BlockEntities[]
	return false;
}





/// Sets or resets the internal flag that prevents chunk from being unloaded
void cChunk::Stay(bool a_Stay)
{
	m_StayCount += (a_Stay ? 1 : -1);
	ASSERT(m_StayCount >= 0);
}





void cChunk::Tick(float a_Dt, MTRand & a_TickRandom)
{
	cCSLock Lock(m_CSBlockLists);
	unsigned int PendingSendBlocks = m_PendingSendBlocks.size();
	if( PendingSendBlocks > 1 )
	{
		cPacket_MultiBlock MultiBlock;
		MultiBlock.m_ChunkX = m_PosX;
		MultiBlock.m_ChunkZ = m_PosZ;
		MultiBlock.m_NumBlocks = (short)PendingSendBlocks;
		MultiBlock.m_Data = new cPacket_MultiBlock::sBlockChange[ PendingSendBlocks ];
		MultiBlock.m_DataSize = PendingSendBlocks * sizeof( cPacket_MultiBlock::sBlockChange );
		//LOG("Sending multiblock packet for %i blocks", PendingSendBlocks );
		for( unsigned int i = 0; i < PendingSendBlocks; i++)
		{
			unsigned int index = m_PendingSendBlocks[i];
			Vector3i BlockPos = IndexToCoordinate( index );

			unsigned int Coords = BlockPos.y | (BlockPos.z << 8) | (BlockPos.x << 12);
			unsigned int Blocks = GetNibble( m_BlockMeta, index ) | (m_BlockTypes[index] << 4);
			MultiBlock.m_Data[i].Data = Coords << 16 | Blocks;
		}
		m_PendingSendBlocks.clear();
		PendingSendBlocks = m_PendingSendBlocks.size();
		Broadcast( MultiBlock );
	}
	if( PendingSendBlocks > 0 )
	{
		for( unsigned int i = 0; i < PendingSendBlocks; i++)
		{
			unsigned int index = m_PendingSendBlocks[i];
			Vector3i WorldPos = PositionToWorldPosition( IndexToCoordinate( index ) );

			cPacket_BlockChange BlockChange;
			BlockChange.m_PosX = WorldPos.x;
			BlockChange.m_PosY = (unsigned char)WorldPos.y;
			BlockChange.m_PosZ = WorldPos.z;
			BlockChange.m_BlockType = m_BlockTypes[index];
			BlockChange.m_BlockMeta = GetNibble( m_BlockMeta, index );
			Broadcast( BlockChange );
		}
		m_PendingSendBlocks.clear();
	}
	Lock.Unlock();

	while ( !m_UnloadQuery.empty() )
	{
		cPacket_PreChunk UnloadPacket;
		UnloadPacket.m_PosX = GetPosX();
		UnloadPacket.m_PosZ = GetPosZ();
		UnloadPacket.m_bLoad = false; // Unload
		(*m_UnloadQuery.begin())->Send( UnloadPacket );
		m_UnloadQuery.remove( *m_UnloadQuery.begin() );
	}

	cCSLock Lock2(m_CSBlockLists);
	unsigned int NumTickBlocks = m_ToTickBlocks.size();
	Lock2.Unlock();

	if ( NumTickBlocks > 0 )
	{
		Lock2.Lock();
		std::deque< unsigned int > ToTickBlocks = m_ToTickBlocks;
		m_ToTickBlocks.clear();
		Lock2.Unlock();
	
		bool isRedstone = false;
		for ( std::deque< unsigned int >::iterator itr = ToTickBlocks.begin(); itr != ToTickBlocks.end(); ++itr )
		{
			unsigned int index = (*itr);
			Vector3i BlockPos = IndexToCoordinate( index );

			BLOCKTYPE BlockID = GetBlock( index );
			NIBBLETYPE BlockMeta = GetMeta(index);
			switch ( BlockID )
			{
				case E_BLOCK_REDSTONE_REPEATER_OFF:
				case E_BLOCK_REDSTONE_REPEATER_ON:
				case E_BLOCK_REDSTONE_WIRE:
				{
					isRedstone = true;
					// fallthrough
				}
				
				case E_BLOCK_CACTUS:
				case E_BLOCK_REEDS:
				case E_BLOCK_WOODEN_PRESSURE_PLATE:
				case E_BLOCK_STONE_PRESSURE_PLATE:
				case E_BLOCK_MINECART_TRACKS:
				case E_BLOCK_SIGN_POST:
				case E_BLOCK_CROPS:
				case E_BLOCK_SAPLING:
				case E_BLOCK_YELLOW_FLOWER:
				case E_BLOCK_RED_ROSE:
				case E_BLOCK_RED_MUSHROOM:
				case E_BLOCK_BROWN_MUSHROOM:		// Stuff that drops when block below is destroyed
				{
					if (GetBlock(BlockPos.x, BlockPos.y - 1, BlockPos.z) == E_BLOCK_AIR)
					{
						SetBlock( BlockPos, E_BLOCK_AIR, 0 );

						Vector3i WorldPos = PositionToWorldPosition( BlockPos );

						m_World->GetSimulatorManager()->WakeUp(WorldPos.x, WorldPos.y, WorldPos.z);
						
						cItems Pickups;
						cBlockToPickup::ToPickup(BlockID, BlockMeta, E_ITEM_EMPTY, Pickups);
						m_World->SpawnItemPickups(Pickups, WorldPos.x, WorldPos.y, WorldPos.z);
					}
					break;
				}

				case E_BLOCK_REDSTONE_TORCH_OFF:
				case E_BLOCK_REDSTONE_TORCH_ON:
				{
					isRedstone = true;
					// fallthrough
				}
				
				case E_BLOCK_TORCH:
				{
					char Dir = cTorch::MetaDataToDirection( GetNibble( m_BlockMeta, BlockPos ) );
					Vector3i WorldPos = PositionToWorldPosition( BlockPos );

					Vector3i AttachedTo = WorldPos;
					AddDirection( AttachedTo.x, AttachedTo.y, AttachedTo.z, Dir, true );
					if( m_World->GetBlock( AttachedTo ) == E_BLOCK_AIR )
					{
						SetBlock( BlockPos, E_BLOCK_AIR, 0 );

						m_World->GetSimulatorManager()->WakeUp(WorldPos.x, WorldPos.y, WorldPos.z);

						cItems Pickups;
						cBlockToPickup::ToPickup(BlockID, BlockMeta, E_ITEM_EMPTY, Pickups);
						m_World->SpawnItemPickups(Pickups, WorldPos.x, WorldPos.y, WorldPos.z);
					}
					break;
				}

				case E_BLOCK_LADDER:
				{
					char Dir = cLadder::MetaDataToDirection( GetNibble( m_BlockMeta, BlockPos ) );
					Vector3i WorldPos = PositionToWorldPosition( BlockPos );
					Vector3i AttachedTo = WorldPos;
					AddDirection( AttachedTo.x, AttachedTo.y, AttachedTo.z, Dir, true );
					if( m_World->GetBlock( AttachedTo ) == E_BLOCK_AIR )
					{
						SetBlock( BlockPos, E_BLOCK_AIR, 0 );
						cItems Pickups;
						cBlockToPickup::ToPickup(BlockID, BlockMeta, E_ITEM_EMPTY, Pickups);
						m_World->SpawnItemPickups(Pickups, WorldPos.x, WorldPos.y, WorldPos.z);
					}
					break;
				}
			}  // switch (BlockType)
		}  // for itr - ToTickBlocks[]
	}

	TickBlocks(a_TickRandom);

	// Tick block entities (furnaces)
	for (cBlockEntityList::iterator itr = m_BlockEntities.begin(); itr != m_BlockEntities.end(); ++itr)
	{
		if ((*itr)->GetBlockType() == E_BLOCK_FURNACE)
		{
			m_IsDirty = ((cFurnaceEntity *)(*itr))->Tick( a_Dt ) | m_IsDirty;
		}
	}
}




void cChunk::TickBlocks(MTRand & a_TickRandom)
{
	// Tick dem blocks
	// _X: We must limit the random number or else we get a nasty int overflow bug ( http://forum.mc-server.org/showthread.php?tid=457 )
	int RandomX = a_TickRandom.randInt(0x00ffffff);
	int RandomY = a_TickRandom.randInt(0x00ffffff);
	int RandomZ = a_TickRandom.randInt(0x00ffffff);
	int TickX = m_BlockTickX;
	int TickY = m_BlockTickY;
	int TickZ = m_BlockTickZ;

	// This for loop looks disgusting, but it actually does a simple thing - first processes m_BlockTick, then adds random to it
	// This is so that SetNextBlockTick() works
	for (int i = 0; i < 50; i++,
	
		// This weird construct (*2, then /2) is needed,
		// otherwise the blocktick distribution is too biased towards even coords!
		
		TickX = (TickX + RandomX) % (Width * 2),
		TickY = (TickY + RandomY) % (Height * 2),
		TickZ = (TickZ + RandomZ) % (Width * 2),
		m_BlockTickX = TickX / 2,
		m_BlockTickY = TickY / 2,
		m_BlockTickZ = TickZ / 2
	)
	{

		if (m_BlockTickY > cChunkDef::GetHeight(m_HeightMap, m_BlockTickX, m_BlockTickZ))
		{
			continue; // It's all air up here
		}

		unsigned int Index = MakeIndexNoCheck( m_BlockTickX, m_BlockTickY, m_BlockTickZ );
		BLOCKTYPE ID = m_BlockTypes[Index];
		switch( ID )
		{
			case E_BLOCK_GRASS:
			{
				// Grass turns into dirt if there's another block on top of it:
				BLOCKTYPE AboveBlock = GetBlock(Index + (Width * Width) );
				if (!( (AboveBlock == E_BLOCK_AIR) || (g_BlockOneHitDig[AboveBlock]) || (g_BlockTransparent[AboveBlock]) ) )
				{
					FastSetBlock( m_BlockTickX, m_BlockTickY, m_BlockTickZ, E_BLOCK_DIRT, GetNibble( m_BlockMeta, Index ) );
				}
				
				// TODO: Grass spreads to nearby blocks if there's enough light and free space above that block
				// Ref.: http://www.minecraftwiki.net/wiki/Grass_Block#Growth
				break;
			}
			
			case E_BLOCK_CROPS:
			{
				NIBBLETYPE Meta = GetMeta(Index);
				if (Meta < 7)
				{
					FastSetBlock(m_BlockTickX, m_BlockTickY, m_BlockTickZ, E_BLOCK_CROPS, ++Meta);
				}
				break;
			}
			
			case E_BLOCK_PUMPKIN_STEM:
			case E_BLOCK_MELON_STEM: TickMelonPumpkin(m_BlockTickX, m_BlockTickY, m_BlockTickZ, Index, ID, a_TickRandom); break;
			
			case E_BLOCK_FARMLAND: TickFarmland(m_BlockTickX, m_BlockTickY, m_BlockTickZ); break;
			
			case E_BLOCK_SAPLING:
			{
				// Check the highest bit, if set, grow the tree, if not, set it (1-bit delay):
				NIBBLETYPE Meta = GetMeta(m_BlockTickX, m_BlockTickY, m_BlockTickZ);
				if ((Meta & 0x08) != 0)
				{
					m_World->GrowTree( m_BlockTickX + m_PosX*Width, m_BlockTickY, m_BlockTickZ + m_PosZ*Width );
				}
				else
				{
					SetMeta(m_BlockTickX, m_BlockTickY, m_BlockTickZ, Meta | 0x08);
				}
				break;
			}
			
			case E_BLOCK_LEAVES: //todo, http://www.minecraftwiki.net/wiki/Data_values#Leaves
			{
				break;
			}
			
			default:
			{
				break;
			}
		}
	}
}





void cChunk::TickMelonPumpkin(int a_RelX, int a_RelY, int a_RelZ, int a_BlockIdx, BLOCKTYPE a_BlockType, MTRand & a_TickRandom)
{
	NIBBLETYPE Meta = GetMeta(a_BlockIdx);
	if (Meta < 7)
	{
		FastSetBlock(m_BlockTickX, m_BlockTickY, m_BlockTickZ, a_BlockType, ++Meta);
		return;
	}
	
	// Convert the stem BlockType into produce BlockType
	BLOCKTYPE ProduceType;
	switch (a_BlockType)
	{
		case E_BLOCK_MELON_STEM:   ProduceType = E_BLOCK_MELON;   break;
		case E_BLOCK_PUMPKIN_STEM: ProduceType = E_BLOCK_PUMPKIN; break;
		default:
		{
			ASSERT(!"Unhandled blocktype in TickMelonPumpkin()");
			return;
		}
	}

	// Check if there's another melon / pumpkin around that stem, if so, abort:
	bool IsValid;
	BLOCKTYPE BlockType[4];
	NIBBLETYPE BlockMeta;  // unused
	IsValid =            UnboundedRelGetBlock(a_RelX + 1, a_RelY, a_RelZ,     BlockType[0], BlockMeta);
	IsValid = IsValid && UnboundedRelGetBlock(a_RelX - 1, a_RelY, a_RelZ,     BlockType[1], BlockMeta);
	IsValid = IsValid && UnboundedRelGetBlock(a_RelX,     a_RelY, a_RelZ + 1, BlockType[2], BlockMeta);
	IsValid = IsValid && UnboundedRelGetBlock(a_RelX,     a_RelY, a_RelZ - 1, BlockType[3], BlockMeta);
	if (
		!IsValid || 
		(BlockType[0] == ProduceType) || 
		(BlockType[1] == ProduceType) || 
		(BlockType[2] == ProduceType) || 
		(BlockType[3] == ProduceType)
	)
	{
		// Neighbors not valid or already taken by the same produce
		return;
	}
	
	// Pick a direction in which to place the produce:
	int x = 0, z = 0;
	int CheckType = a_TickRandom.randInt(3);  // The index to the neighbors array which should be checked for emptiness
	switch (CheckType)
	{
		case 0: x =  1; break;
		case 1: x = -1; break;
		case 2: z =  1; break;
		case 3: z = -1; break;
	}
	
	// Check that the block in that direction is empty:
	switch (BlockType[CheckType])
	{
		case E_BLOCK_AIR:
		case E_BLOCK_SNOW:
		case E_BLOCK_TALL_GRASS:
		case E_BLOCK_DEAD_BUSH:
		{
			break;
		}
		default: return;
	}
	
	// Check if there's soil under the neighbor. We already know the neighbors are valid. Place produce if ok
	BLOCKTYPE Soil;
	UnboundedRelGetBlock(a_RelX + x, a_RelY - 1, a_RelZ + z, Soil, BlockMeta);
	switch (Soil)
	{
		case E_BLOCK_DIRT:
		case E_BLOCK_GRASS:
		case E_BLOCK_FARMLAND:
		{
			// Place a randomly-facing produce:
			UnboundedRelFastSetBlock(a_RelX + x, a_RelY, a_RelZ + z, ProduceType, (NIBBLETYPE)(a_TickRandom.randInt(4) % 4));
			break;
		}
	}
}





void cChunk::TickFarmland(int a_RelX, int a_RelY, int a_RelZ)
{
	// TODO: Rain hydrates blocks, too. Check world weather, don't search for water if raining.
	
	// Search for water in a close proximity:
	// Ref.: http://www.minecraftwiki.net/wiki/Farmland#Hydrated_Farmland_Tiles
	bool Found = false;
	for (int y = a_RelY; y <= a_RelY + 1; y++)
	{
		for (int z = a_RelZ - 4; z <= a_RelZ + 4; z++)
		{
			for (int x = a_RelX - 4; x <= a_RelX + 4; x++)
			{
				BLOCKTYPE BlockType;
				NIBBLETYPE Meta;  // unused
				
				if (!UnboundedRelGetBlock(x, y, z, BlockType, Meta))
				{
					// Too close to an unloaded chunk, we might miss a water block there, so don't tick at all
					return;
				}
				if (
					(BlockType == E_BLOCK_WATER) ||
					(BlockType == E_BLOCK_STATIONARY_WATER)
				)
				{
					Found = true;
					break;
				}
			}  // for x
			if (Found)
			{
				break;
			}
		}  // for z
		if (Found)
		{
			break;
		}
	}  // for y
	
	NIBBLETYPE BlockMeta = GetMeta(a_RelX, a_RelY, a_RelZ);
	
	if (Found)
	{
		// Water was found, hydrate the block until hydration reaches 7:
		if (BlockMeta < 7)
		{
			FastSetBlock(a_RelX, a_RelY, a_RelZ, E_BLOCK_FARMLAND, ++BlockMeta);
		}
		return;
	}

	// Water wasn't found, de-hydrate block:
	if (BlockMeta > 0)
	{
		FastSetBlock(a_RelX, a_RelY, a_RelZ, E_BLOCK_FARMLAND, --BlockMeta);
		return;
	}
	
	// Farmland too dry. Turn back to dirt:
	FastSetBlock(a_RelX, a_RelY, a_RelZ, E_BLOCK_DIRT, 0);
	
	// TODO: Uproot whatever was growing on top:
}





bool cChunk::UnboundedRelGetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta)
{
	if ((a_RelX >= 0) && (a_RelX < cChunkDef::Width) && (a_RelZ >= 0) && (a_RelZ < cChunkDef::Width))
	{
		int BlockIdx = cChunkDef::MakeIndexNoCheck(a_RelX, a_RelY, a_RelZ);
		a_BlockType = GetBlock(BlockIdx);
		a_BlockMeta = GetMeta(BlockIdx);
		return true;
	}
	return m_ChunkMap->LockedGetBlock(
		m_PosX * cChunkDef::Width + a_RelX,
		ZERO_CHUNK_Y * cChunkDef::Height + a_RelY,
		m_PosZ * cChunkDef::Width + a_RelZ,
		a_BlockType, a_BlockMeta
	);
}





bool cChunk::UnboundedRelSetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)
{
	if ((a_RelX >= 0) && (a_RelX < cChunkDef::Width) && (a_RelZ >= 0) && (a_RelZ < cChunkDef::Width))
	{
		SetBlock(a_RelX, a_RelY, a_RelZ, a_BlockType, a_BlockMeta);
		return true;
	}
	return m_ChunkMap->LockedSetBlock(
		m_PosX * cChunkDef::Width + a_RelX,
		ZERO_CHUNK_Y * cChunkDef::Height + a_RelY,
		m_PosZ * cChunkDef::Width + a_RelZ,
		a_BlockType, a_BlockMeta
	);
}





bool cChunk::UnboundedRelFastSetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)
{
	if ((a_RelX >= 0) && (a_RelX < cChunkDef::Width) && (a_RelZ >= 0) && (a_RelZ < cChunkDef::Width))
	{
		FastSetBlock(a_RelX, a_RelY, a_RelZ, a_BlockType, a_BlockMeta);
		return true;
	}
	return m_ChunkMap->LockedFastSetBlock(
		m_PosX * cChunkDef::Width + a_RelX,
		ZERO_CHUNK_Y * cChunkDef::Height + a_RelY,
		m_PosZ * cChunkDef::Width + a_RelZ,
		a_BlockType, a_BlockMeta
	);
}





int cChunk::GetHeight( int a_X, int a_Z )
{
	ASSERT((a_X >= 0) && (a_X < Width) && (a_Z >= 0) && (a_Z < Width));
	
	if ((a_X >= 0) && (a_X < Width) && (a_Z >= 0) && (a_Z < Width))
	{
		return m_HeightMap[a_X + a_Z * Width];
	}
	return 0;
}





void cChunk::CreateBlockEntities(void)
{
	for (int x = 0; x < Width; x++)
	{
		for (int z = 0; z < Width; z++)
		{
			for (int y = 0; y < Height; y++)
			{
				ENUM_BLOCK_ID BlockType = (ENUM_BLOCK_ID)m_BlockTypes[ MakeIndex( x, y, z ) ];
				switch ( BlockType )
				{
					case E_BLOCK_CHEST:
					{
						if (!HasBlockEntityAt(x + m_PosX * Width, y + m_PosY * Height, z + m_PosZ * Width))
						{
							m_BlockEntities.push_back( new cChestEntity( x + m_PosX * Width, y + m_PosY * Height, z + m_PosZ * Width, m_World) );
						}
						break;
					}
					
					case E_BLOCK_FURNACE:
					{
						if (!HasBlockEntityAt(x + m_PosX * Width, y + m_PosY * Height, z + m_PosZ * Width))
						{
							m_BlockEntities.push_back( new cFurnaceEntity( x + m_PosX * Width, y + m_PosY * Height, z + m_PosZ * Width, m_World) );
						}
						break;
					}
					
					case E_BLOCK_SIGN_POST:
					case E_BLOCK_WALLSIGN:
					{
						if (!HasBlockEntityAt(x + m_PosX * Width, y + m_PosY * Height, z + m_PosZ * Width))
						{
							m_BlockEntities.push_back( new cSignEntity( BlockType, x + m_PosX * Width, y + m_PosY * Height, z + m_PosZ * Width, m_World) );
						}
						break;
					}
				}  // switch (BlockType)
			}  // for y
		}  // for z
	}  // for x
}





void cChunk::CalculateHeightmap()
{
	for (int x = 0; x < Width; x++)
	{
		for (int z = 0; z < Width; z++)
		{
			for (int y = Height - 1; y > -1; y--)
			{
				int index = MakeIndex( x, y, z );
				if (m_BlockTypes[index] != E_BLOCK_AIR)
				{
					m_HeightMap[x + z * Width] = (unsigned char)y;
					break;
				}
			}  // for y
		}  // for z
	}  // for x
}





void cChunk::SetBlock( int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta )
{
	if (a_RelX < 0 || a_RelX >= Width || a_RelY < 0 || a_RelY >= Height || a_RelZ < 0 || a_RelZ >= Width)
	{
		return;  // Clip
	}

	ASSERT(IsValid());  // Is this chunk loaded / generated?
	
	int index = MakeIndexNoCheck( a_RelX, a_RelY, a_RelZ );
	BLOCKTYPE OldBlockMeta = GetNibble( m_BlockMeta, index );
	BLOCKTYPE OldBlockType = m_BlockTypes[index];
	m_BlockTypes[index] = a_BlockType;

	SetNibble( m_BlockMeta, index, a_BlockMeta );

	if ((OldBlockType == a_BlockType) && (OldBlockMeta == a_BlockMeta))
	{
		return;
	}

	MarkDirty();
	
	{
		cCSLock Lock(m_CSBlockLists);
		m_PendingSendBlocks.push_back( index );
	}

	// ONLY recalculate lighting if it's necessary!
	if(
		(g_BlockLightValue[ OldBlockType ] != g_BlockLightValue[ a_BlockType ]) ||
		(g_BlockSpreadLightFalloff[ OldBlockType ] != g_BlockSpreadLightFalloff[ a_BlockType ]) ||
		(g_BlockTransparent[ OldBlockType ] != g_BlockTransparent[ a_BlockType ] )
	)
	{
		m_IsLightValid = false;
	}

	// Update heightmap, if needed:
	if (a_RelY >= m_HeightMap[a_RelX + a_RelZ * Width])
	{
		if (a_BlockType != E_BLOCK_AIR)
		{
			SetHeight(m_HeightMap, a_RelX, a_RelZ, a_RelY);
		}
		else
		{
			for (int y = a_RelY - 1; y > 0; --y)
			{
				if (cChunkDef::GetBlock(m_BlockTypes, a_RelX, y, a_RelZ) != E_BLOCK_AIR)
				{
					SetHeight(m_HeightMap, a_RelX, a_RelZ, y);
					break;
				}
			}  // for y - column in m_BlockData
		}
	}

	m_ToTickBlocks.push_back( MakeIndex( a_RelX,     a_RelY,     a_RelZ ) );
	m_ToTickBlocks.push_back( MakeIndex( a_RelX + 1, a_RelY,     a_RelZ ) );
	m_ToTickBlocks.push_back( MakeIndex( a_RelX - 1, a_RelY,     a_RelZ ) );
	m_ToTickBlocks.push_back( MakeIndex( a_RelX,     a_RelY + 1, a_RelZ ) );
	m_ToTickBlocks.push_back( MakeIndex( a_RelX,     a_RelY - 1, a_RelZ ) );
	m_ToTickBlocks.push_back( MakeIndex( a_RelX,     a_RelY,     a_RelZ + 1 ) );
	m_ToTickBlocks.push_back( MakeIndex( a_RelX,     a_RelY,     a_RelZ - 1 ) );

	Vector3i WorldPos = PositionToWorldPosition( a_RelX, a_RelY, a_RelZ );
	cBlockEntity* BlockEntity = GetBlockEntity( WorldPos );
	if( BlockEntity )
	{
		BlockEntity->Destroy();
		RemoveBlockEntity( BlockEntity );
		delete BlockEntity;
	}
	switch( a_BlockType )
	{
		case E_BLOCK_CHEST:
		{
			AddBlockEntity( new cChestEntity( WorldPos.x, WorldPos.y, WorldPos.z, m_World) );
			break;
		}
		case E_BLOCK_FURNACE:
		{
			AddBlockEntity( new cFurnaceEntity( WorldPos.x, WorldPos.y, WorldPos.z, m_World) );
			break;
		}
		case E_BLOCK_SIGN_POST:
		case E_BLOCK_WALLSIGN:
		{
			AddBlockEntity( new cSignEntity( (ENUM_BLOCK_ID)a_BlockType, WorldPos.x, WorldPos.y, WorldPos.z, m_World) );
			break;
		}
	}  // switch (a_BlockType)
}





void cChunk::FastSetBlock( int a_X, int a_Y, int a_Z, BLOCKTYPE a_BlockType, BLOCKTYPE a_BlockMeta)
{
	ASSERT(!((a_X < 0 || a_X >= Width || a_Y < 0 || a_Y >= Height || a_Z < 0 || a_Z >= Width)));

	ASSERT(IsValid());
	
	const int index = MakeIndexNoCheck( a_X, a_Y, a_Z );
	const BLOCKTYPE OldBlock = m_BlockTypes[index];
	const BLOCKTYPE OldBlockMeta = GetNibble( m_BlockMeta, index );
	if ((OldBlock == a_BlockType) && (OldBlockMeta == a_BlockMeta))
	{
		return;
	}

	MarkDirty();
	
	m_BlockTypes[index] = a_BlockType;

	{
		cCSLock Lock(m_CSBlockLists);
		m_PendingSendBlocks.push_back( index );
	}
	
	SetNibble( m_BlockMeta, index, a_BlockMeta );

	// ONLY recalculate lighting if it's necessary!
	if(
		(g_BlockLightValue[ OldBlock ] != g_BlockLightValue[ a_BlockType ]) ||
		(g_BlockSpreadLightFalloff[ OldBlock ] != g_BlockSpreadLightFalloff[ a_BlockType ]) ||
		(g_BlockTransparent[ OldBlock ] != g_BlockTransparent[ a_BlockType ] )
	)
	{
		m_IsLightValid = false;
	}

	// Update heightmap, if needed:
	if (a_Y >= m_HeightMap[a_X + a_Z * Width])
	{
		if (a_BlockType != E_BLOCK_AIR)
		{
			m_HeightMap[a_X + a_Z * Width] = (unsigned char)a_Y;
		}
		else
		{
			for (int y = a_Y - 1; y > 0; --y)
			{
				if (m_BlockTypes[MakeIndexNoCheck(a_X, y, a_Z)] != E_BLOCK_AIR)
				{
					m_HeightMap[a_X + a_Z * Width] = (unsigned char)y;
					break;
				}
			}  // for y - column in m_BlockData
		}
	}
}





void cChunk::SendBlockTo( int a_X, int a_Y, int a_Z, cClientHandle* a_Client )
{
	if( a_Client == 0 )
	{
		cCSLock Lock(m_CSBlockLists);
		unsigned int index = MakeIndex( a_X, a_Y, a_Z );
		if( index != INDEX_OUT_OF_RANGE )
		{
			m_PendingSendBlocks.push_back( index );
		}
		else
		{
			LOGWARN("cChunk::SendBlockTo Index out of range!");
		}
		return;
	}

	for (cClientHandleList::iterator itr = m_LoadedByClient.begin(); itr != m_LoadedByClient.end(); ++itr )
	{
		if ( *itr == a_Client )
		{
			unsigned int index = MakeIndex( a_X, a_Y, a_Z );
			Vector3i WorldPos = PositionToWorldPosition( a_X, a_Y, a_Z );
			cPacket_BlockChange BlockChange;
			BlockChange.m_PosX = WorldPos.x;
			BlockChange.m_PosY = (unsigned char)WorldPos.y;
			BlockChange.m_PosZ = WorldPos.z;
			if( index != INDEX_OUT_OF_RANGE )
			{
				BlockChange.m_BlockType = m_BlockTypes[ index ];
				BlockChange.m_BlockMeta = GetNibble( m_BlockMeta, index );
			} // else it's both 0
			a_Client->Send( BlockChange );
			break;
		}
	}
}





void cChunk::AddBlockEntity( cBlockEntity* a_BlockEntity )
{
	cCSLock Lock(m_CSBlockLists);
	m_BlockEntities.push_back( a_BlockEntity );
}





cBlockEntity * cChunk::GetBlockEntity(int a_X, int a_Y, int a_Z)
{
	// Assumes that the m_CSBlockList is already locked, we're being called from SetBlock()
	for (cBlockEntityList::iterator itr = m_BlockEntities.begin(); itr != m_BlockEntities.end(); ++itr)
	{
		if (
			((*itr)->GetPosX() == a_X) &&
			((*itr)->GetPosY() == a_Y) &&
			((*itr)->GetPosZ() == a_Z)
		)
		{
			return *itr;
		}
	}  // for itr - m_BlockEntities[]
	
	return NULL;
}





void cChunk::UseBlockEntity(cPlayer * a_Player, int a_X, int a_Y, int a_Z)
{
	cBlockEntity * be = GetBlockEntity(a_X, a_Y, a_Z);
	if (be != NULL)
	{
		be->UsedBy(a_Player);
	}
}





void cChunk::CollectPickupsByPlayer(cPlayer * a_Player)
{
	double PosX = a_Player->GetPosX();
	double PosY = a_Player->GetPosY();
	double PosZ = a_Player->GetPosZ();
	
	for (cEntityList::iterator itr = m_Entities.begin(); itr != m_Entities.end(); ++itr)
	{
		if ( (*itr)->GetEntityType() != cEntity::eEntityType_Pickup )
		{
			continue; // Only pickups
		}
		float DiffX = (float)((*itr)->GetPosX() - PosX );
		float DiffY = (float)((*itr)->GetPosY() - PosY );
		float DiffZ = (float)((*itr)->GetPosZ() - PosZ );
		float SqrDist = DiffX * DiffX + DiffY * DiffY + DiffZ * DiffZ;
		if (SqrDist < 1.5f * 1.5f)  // 1.5 block
		{
			MarkDirty();
			(reinterpret_cast<cPickup *>(*itr))->CollectedBy( a_Player );
		}
	}
}





void cChunk::UpdateSign(int a_PosX, int a_PosY, int a_PosZ, const AString & a_Line1, const AString & a_Line2, const AString & a_Line3, const AString & a_Line4)
{
	// Also sends update packets to all clients in the chunk
	for (cBlockEntityList::iterator itr = m_BlockEntities.begin(); itr != m_BlockEntities.end(); ++itr)
	{
		if (
			((*itr)->GetPosX() == a_PosX) &&
			((*itr)->GetPosY() == a_PosY) &&
			((*itr)->GetPosZ() == a_PosZ) &&
			(
				((*itr)->GetBlockType() == E_BLOCK_WALLSIGN) ||
				((*itr)->GetBlockType() == E_BLOCK_SIGN_POST)
			)
		)
		{
			MarkDirty();
			(reinterpret_cast<cSignEntity *>(*itr))->SetLines(a_Line1, a_Line2, a_Line3, a_Line4);
			(*itr)->SendTo(NULL);
		}
	}  // for itr - m_BlockEntities[]
}





void cChunk::RemoveBlockEntity( cBlockEntity* a_BlockEntity )
{
	cCSLock Lock(m_CSBlockLists);
	MarkDirty();
	m_BlockEntities.remove( a_BlockEntity );
}





bool cChunk::AddClient(cClientHandle* a_Client)
{
	for (cClientHandleList::iterator itr = m_LoadedByClient.begin(); itr != m_LoadedByClient.end(); ++itr)
	{
		if (a_Client == *itr)
		{
			// Already there, nothing needed
			return false;
		}
	}
	m_LoadedByClient.push_back( a_Client );

	for (cEntityList::iterator itr = m_Entities.begin(); itr != m_Entities.end(); ++itr )
	{
		LOGD("cChunk: Entity #%d (%s) at [%i, %i, %i] spawning for player \"%s\"", (*itr)->GetUniqueID(), (*itr)->GetClass(), m_PosX, m_PosY, m_PosZ, a_Client->GetUsername().c_str() );
		(*itr)->SpawnOn( a_Client );
	}
	return true;
}





void cChunk::RemoveClient( cClientHandle* a_Client )
{
	for (cClientHandleList::iterator itr = m_LoadedByClient.begin(); itr != m_LoadedByClient.end(); ++itr)
	{
		if (*itr != a_Client)
		{
			continue;
		}
		
		m_LoadedByClient.erase(itr);

		if ( !a_Client->IsDestroyed() )
		{
			for (cEntityList::iterator itr = m_Entities.begin(); itr != m_Entities.end(); ++itr )
			{
				LOGD("chunk [%i, %i] destroying entity #%i for player \"%s\"", m_PosX, m_PosZ, (*itr)->GetUniqueID(), a_Client->GetUsername().c_str() );
				cPacket_DestroyEntity DestroyEntity( *itr );
				a_Client->Send( DestroyEntity );
			}
		}
		return;
	}  // for itr - m_LoadedByClient[]
}





bool cChunk::HasClient( cClientHandle* a_Client )
{
	for (cClientHandleList::const_iterator itr = m_LoadedByClient.begin(); itr != m_LoadedByClient.end(); ++itr)
	{
		if ((*itr) == a_Client)
		{
			return true;
		}
	}
	return false;
}





bool cChunk::HasAnyClients(void)
{
	return !m_LoadedByClient.empty();
}





void cChunk::AddEntity( cEntity * a_Entity)
{
	if (a_Entity->GetEntityType() != cEntity::eEntityType_Player)
	{
		MarkDirty();
	}
	m_Entities.push_back( a_Entity );
}





void cChunk::RemoveEntity(cEntity * a_Entity)
{
	size_t SizeBefore = m_Entities.size();
	m_Entities.remove(a_Entity);
	size_t SizeAfter = m_Entities.size();
	
	if (SizeBefore != SizeAfter)
	{
		// Mark as dirty if it was a server-generated entity:
		if (a_Entity->GetEntityType() != cEntity::eEntityType_Player)
		{
			MarkDirty();
		}
	}
}





BLOCKTYPE cChunk::GetBlock( int a_X, int a_Y, int a_Z )
{
	if ((a_X < 0) || (a_X >= Width) || (a_Y < 0) || (a_Y >= Height) || (a_Z < 0) || (a_Z >= Width)) return 0; // Clip

	return m_BlockTypes[ MakeIndexNoCheck( a_X, a_Y, a_Z ) ];
}





BLOCKTYPE cChunk::GetBlock( int a_BlockIdx )
{
	if( a_BlockIdx < 0 || a_BlockIdx >= NumBlocks ) return 0;
	return m_BlockTypes[ a_BlockIdx ];
}





/*
// _X 2012_02_23: Loading in old format not supported anymore
/// Loads the chunk from the old-format disk file, erases the file afterwards. Returns true if successful
bool cChunk::LoadFromDisk()
{
	AString SourceFile;
	Printf(SourceFile, "world/X%i_Y%i_Z%i.bin", m_PosX, m_PosY, m_PosZ );

	cFile f;
	if (!f.Open(SourceFile, cFile::fmRead))
	{
		return false;
	}

	if (f.Read(m_BlockData, sizeof(m_BlockData)) != sizeof(m_BlockData))
	{
		LOGERROR("ERROR READING FROM FILE %s", SourceFile.c_str()); 
		return false;
	}

	// Now load Block Entities:
	ENUM_BLOCK_ID BlockType;
	while (f.Read(&BlockType, sizeof(ENUM_BLOCK_ID)) == sizeof(ENUM_BLOCK_ID))
	{
		switch (BlockType)
		{
			case E_BLOCK_CHEST:
			{
				cChestEntity * ChestEntity = new cChestEntity( 0, 0, 0, m_World );
				if (!ChestEntity->LoadFromFile(f))
				{
					LOGERROR("ERROR READING CHEST FROM FILE %s", SourceFile.c_str());
					delete ChestEntity;
					return false;
				}
				m_BlockEntities.push_back( ChestEntity );
				break;
			}
			
			case E_BLOCK_FURNACE:
			{
				cFurnaceEntity* FurnaceEntity = new cFurnaceEntity( 0, 0, 0, m_World );
				if (!FurnaceEntity->LoadFromFile(f))
				{
					LOGERROR("ERROR READING FURNACE FROM FILE %s", SourceFile.c_str());
					delete FurnaceEntity;
					return false;
				}
				m_BlockEntities.push_back( FurnaceEntity );
				break;
			}
			
			case E_BLOCK_SIGN_POST:
			case E_BLOCK_WALLSIGN:
			{
				cSignEntity * SignEntity = new cSignEntity(BlockType, 0, 0, 0, m_World );
				if (!SignEntity->LoadFromFile( f ) )
				{
					LOGERROR("ERROR READING SIGN FROM FILE %s", SourceFile.c_str());
					delete SignEntity;
					return false;
				}
				m_BlockEntities.push_back( SignEntity );
				break;
			}
			
			default:
			{
				ASSERT(!"Unhandled block entity in file");
				break;
			}
		}
	}
	f.Close();

	// Delete old format file
	if (std::remove(SourceFile.c_str()) != 0)
	{
		LOGERROR("Could not delete file %s", SourceFile.c_str());
	}
	else
	{
		LOGINFO("Successfully deleted old format file \"%s\"", SourceFile.c_str());
	}
	m_IsDirty = false;
	return true;
}
*/





void cChunk::Broadcast( const cPacket * a_Packet, cClientHandle* a_Exclude)
{
	for (cClientHandleList::const_iterator itr = m_LoadedByClient.begin(); itr != m_LoadedByClient.end(); ++itr )
	{
		if (*itr == a_Exclude)
		{
			continue;
		}
		(*itr)->Send(*a_Packet);
	}  // for itr - LoadedByClient[]
}





void cChunk::PositionToWorldPosition(int a_ChunkX, int a_ChunkY, int a_ChunkZ, int & a_X, int & a_Y, int & a_Z)
{
	a_Y = a_ChunkY;
	a_X = m_PosX * Width + a_ChunkX;
	a_Z = m_PosZ * Width + a_ChunkZ;
}





Vector3i cChunk::PositionToWorldPosition( int a_ChunkX, int a_ChunkY, int a_ChunkZ )
{
	return Vector3i( m_PosX * Width + a_ChunkX, m_PosY * Height + a_ChunkY, m_PosZ * Width + a_ChunkZ );
}





#if !C_CHUNK_USE_INLINE
# include "cChunk.inl.h"
#endif