summaryrefslogtreecommitdiffstats
path: root/source/cChunk.cpp
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--source/cChunk.cpp704
1 files changed, 343 insertions, 361 deletions
diff --git a/source/cChunk.cpp b/source/cChunk.cpp
index 3b0dd519c..fec06e947 100644
--- a/source/cChunk.cpp
+++ b/source/cChunk.cpp
@@ -27,6 +27,7 @@
#include "cWorldGenerator.h"
#include "cBlockToPickup.h"
#include "MersenneTwister.h"
+#include "cPlayer.h"
#include "packets/cPacket_DestroyEntity.h"
#include "packets/cPacket_PreChunk.h"
@@ -43,66 +44,27 @@
extern bool g_bWaterPhysics;
-typedef std::map< int, std::string > ReferenceMap;
-typedef std::list< cFurnaceEntity* > FurnaceEntityList;
-typedef std::list< cClientHandle* > ClientHandleList;
-typedef std::list< cBlockEntity* > BlockEntityList;
-typedef std::list< cEntity* > EntityList;
-
-
-struct cChunk::sChunkState
-{
- sChunkState()
- : TotalReferencesEver( 0 )
- , MinusReferences( 0 )
- , NumRefs( 0 )
- {}
-
- FurnaceEntityList TickBlockEntities;
- std::map< unsigned int, int > ToTickBlocks; // Protected by BlockListCriticalSection
- std::vector< unsigned int > PendingSendBlocks; // Protected by BlockListCriticalSection
- ClientHandleList LoadedByClient;
- ClientHandleList UnloadQuery;
- BlockEntityList BlockEntities; // Protected by BlockListCriticalSection
- EntityList Entities;
-
- cCriticalSection BlockListCriticalSection;
-
- // Reference counting
- cCriticalSection ReferenceCriticalSection;
- ReferenceMap References;
- int MinusReferences; // References.size() - MinusReferences = Actual amount of references. This is due to removal of reference without an ID (don't know which to remove, so remove none)
- int TotalReferencesEver; // For creating a unique reference ID
- int NumRefs;
-};
-
-
-
-
-
-cChunk::cChunk(int a_X, int a_Y, int a_Z, cWorld* a_World)
- : m_pState( new sChunkState )
- , m_bCalculateLighting( false )
+cChunk::cChunk(int a_X, int a_Y, int a_Z, cWorld * a_World)
+ : m_bCalculateLighting( false )
, m_bCalculateHeightmap( false )
, m_PosX( a_X )
, m_PosY( a_Y )
, m_PosZ( a_Z )
, m_BlockType( m_BlockData ) // Offset the pointers
, m_BlockMeta( m_BlockType + c_NumBlocks )
- , m_BlockLight( m_BlockMeta + c_NumBlocks/2 )
- , m_BlockSkyLight( m_BlockLight + c_NumBlocks/2 )
+ , m_BlockLight( m_BlockMeta + c_NumBlocks / 2 )
+ , m_BlockSkyLight( m_BlockLight + c_NumBlocks / 2 )
, m_BlockTickNum( 0 )
, m_BlockTickX( 0 )
, m_BlockTickY( 0 )
, m_BlockTickZ( 0 )
- , m_EntitiesCriticalSection( 0 )
, m_World( a_World )
+ , m_IsValid(false)
{
- //LOG("cChunk::cChunk(%i, %i, %i)", a_X, a_Y, a_Z);
- m_EntitiesCriticalSection = new cCriticalSection();
+ // LOGINFO("### new cChunk (%i, %i) at %p, thread 0x%x ###", a_X, a_Z, this, GetCurrentThreadId());
}
@@ -111,79 +73,77 @@ cChunk::cChunk(int a_X, int a_Y, int a_Z, cWorld* a_World)
cChunk::~cChunk()
{
- //LOG("~cChunk() %i %i %i", m_PosX, m_PosY, m_PosZ );
- if( !m_pState->LoadedByClient.empty() )
- {
- LOGWARN("WARNING: Deleting cChunk while it contains %i clients!", m_pState->LoadedByClient.size() );
- }
-
- m_pState->ReferenceCriticalSection.Lock();
- if( GetReferenceCount() > 0 )
- {
- LOGWARN("WARNING: Deleting cChunk while it still has %i references!", GetReferenceCount() );
- }
- m_pState->ReferenceCriticalSection.Unlock();
-
- m_pState->BlockListCriticalSection.Lock();
- for( std::list<cBlockEntity*>::iterator itr = m_pState->BlockEntities.begin(); itr != m_pState->BlockEntities.end(); ++itr)
+ // LOGINFO("### delete cChunk() (%i, %i) from %p, thread 0x%x ###", m_PosX, m_PosZ, this, GetCurrentThreadId() );
+
+ cCSLock Lock(m_CSEntities);
+ for (cBlockEntityList::iterator itr = m_BlockEntities.begin(); itr != m_BlockEntities.end(); ++itr)
{
delete *itr;
}
- m_pState->BlockEntities.clear();
- m_pState->BlockListCriticalSection.Unlock();
+ m_BlockEntities.clear();
- LockEntities();
- if( m_pState->Entities.size() > 0 )
+ // Remove and destroy all entities that are not players:
+ cEntityList Entities;
+ for (cEntityList::const_iterator itr = m_Entities.begin(); itr != m_Entities.end(); ++itr)
{
- EntityList Entities = m_pState->Entities; // Copy list to a temporary list
- for( EntityList::iterator itr = Entities.begin(); itr != Entities.end(); ++itr)
+ if ((*itr)->GetEntityType() != cEntity::E_PLAYER)
{
- if( (*itr)->GetEntityType() != cEntity::E_PLAYER )
- {
- (*itr)->RemoveFromChunk( this );
- (*itr)->Destroy();
- }
+ Entities.push_back(*itr);
}
- m_pState->Entities.clear();
}
- UnlockEntities();
-
- if( m_EntitiesCriticalSection )
+ for (cEntityList::iterator itr = Entities.begin(); itr != Entities.end(); ++itr)
{
- delete m_EntitiesCriticalSection;
- m_EntitiesCriticalSection = 0;
+ (*itr)->RemoveFromChunk();
+ (*itr)->Destroy();
}
- delete m_pState;
+ m_Entities.clear();
}
-void cChunk::Initialize()
+void cChunk::SetValid(bool a_SendToClients)
{
- if (!LoadFromDisk())
+ m_IsValid = true;
+
+ if (!a_SendToClients)
+ {
+ return;
+ }
+
+ cCSLock Lock(m_CSClients);
+ if (m_LoadedByClient.empty())
+ {
+ return;
+ }
+
+ // Sending the chunk here interferes with the lighting done in the tick thread and results in the "invalid compressed data" on the client
+ /*
+ cPacket_PreChunk PreChunk;
+ PreChunk.m_PosX = m_PosX;
+ PreChunk.m_PosZ = m_PosZ;
+ PreChunk.m_bLoad = true;
+ cPacket_MapChunk MapChunk(this);
+ Broadcast(&PreChunk);
+ Broadcast(&MapChunk);
+
+ // Let all clients of this chunk know that it has been already sent to the client
+ for (cClientHandleList::iterator itr = m_LoadedByClient.begin(); itr != m_LoadedByClient.end(); ++itr)
{
- // Clear memory
- memset( m_BlockData, 0x00, c_BlockDataSize );
+ (*itr)->ChunkJustSent(this);
+ } // for itr - m_LoadedByClient[]
+ */
+}
- m_World->GetWorldGenerator()->GenerateChunk( this );
- CalculateHeightmap();
- CalculateLighting();
- CreateBlockEntities();
- // During generation, some blocks might have been set by using (Fast)SetBlock() causing this list to fill.
- // This chunk has not been sent to anybody yet, so there is no need for separately sending block changes when you can send an entire chunk
- cCSLock Lock(m_pState->BlockListCriticalSection);
- m_pState->PendingSendBlocks.clear();
- }
- else
- {
- //LOGINFO("Successfully loaded from disk");
- CalculateHeightmap();
- }
+
+bool cChunk::CanUnload(void)
+{
+ cCSLock Lock(m_CSClients);
+ return m_LoadedByClient.empty();
}
@@ -201,8 +161,8 @@ void cChunk::Tick(float a_Dt, MTRand & a_TickRandom)
CalculateHeightmap();
}
- cCSLock Lock(m_pState->BlockListCriticalSection);
- unsigned int PendingSendBlocks = m_pState->PendingSendBlocks.size();
+ cCSLock Lock(m_CSBlockLists);
+ unsigned int PendingSendBlocks = m_PendingSendBlocks.size();
if( PendingSendBlocks > 1 )
{
cPacket_MultiBlock MultiBlock;
@@ -215,7 +175,7 @@ void cChunk::Tick(float a_Dt, MTRand & a_TickRandom)
//LOG("Sending multiblock packet for %i blocks", PendingSendBlocks );
for( unsigned int i = 0; i < PendingSendBlocks; i++)
{
- unsigned int index = m_pState->PendingSendBlocks[i];
+ unsigned int index = m_PendingSendBlocks[i];
unsigned int Y = index % 128;
unsigned int Z = (index / 128) % 16;
unsigned int X = (index / (128*16));
@@ -225,15 +185,15 @@ void cChunk::Tick(float a_Dt, MTRand & a_TickRandom)
MultiBlock.m_BlockTypes[i] = m_BlockType[index];
MultiBlock.m_BlockMetas[i] = GetLight( m_BlockMeta, index );
}
- m_pState->PendingSendBlocks.clear();
- PendingSendBlocks = m_pState->PendingSendBlocks.size();
+ m_PendingSendBlocks.clear();
+ PendingSendBlocks = m_PendingSendBlocks.size();
Broadcast( MultiBlock );
}
if( PendingSendBlocks > 0 )
{
for( unsigned int i = 0; i < PendingSendBlocks; i++)
{
- unsigned int index = m_pState->PendingSendBlocks[i];
+ unsigned int index = m_PendingSendBlocks[i];
int Y = index % 128;
int Z = (index / 128) % 16;
int X = (index / (128*16));
@@ -246,23 +206,23 @@ void cChunk::Tick(float a_Dt, MTRand & a_TickRandom)
BlockChange.m_BlockMeta = GetLight( m_BlockMeta, index );
Broadcast( BlockChange );
}
- m_pState->PendingSendBlocks.clear();
+ m_PendingSendBlocks.clear();
}
Lock.Unlock();
- while( !m_pState->UnloadQuery.empty() )
+ while ( !m_UnloadQuery.empty() )
{
cPacket_PreChunk UnloadPacket;
UnloadPacket.m_PosX = GetPosX();
UnloadPacket.m_PosZ = GetPosZ();
UnloadPacket.m_bLoad = false; // Unload
- (*m_pState->UnloadQuery.begin())->Send( UnloadPacket );
- m_pState->UnloadQuery.remove( *m_pState->UnloadQuery.begin() );
+ (*m_UnloadQuery.begin())->Send( UnloadPacket );
+ m_UnloadQuery.remove( *m_UnloadQuery.begin() );
}
- cCSLock Lock2(m_pState->BlockListCriticalSection);
- std::map< unsigned int, int > ToTickBlocks = m_pState->ToTickBlocks;
- m_pState->ToTickBlocks.clear();
+ cCSLock Lock2(m_CSBlockLists);
+ std::map< unsigned int, int > ToTickBlocks = m_ToTickBlocks;
+ m_ToTickBlocks.clear();
Lock2.Unlock();
bool isRedstone = false;
@@ -376,7 +336,9 @@ void cChunk::Tick(float a_Dt, MTRand & a_TickRandom)
char ID = m_BlockType[Index];
switch( ID )
{
- case E_BLOCK_DIRT:
+ /*
+ // TODO: re-enable
+ case E_BLOCK_DIRT:
{
char AboveBlock = GetBlock( Index+1 );
if ( (AboveBlock == 0) && GetLight( m_BlockSkyLight, Index ) > 0xf/2 ) // Half lit //changed to not allow grass if any one hit object is on top
@@ -388,9 +350,11 @@ void cChunk::Tick(float a_Dt, MTRand & a_TickRandom)
FastSetBlock( m_BlockTickX, m_BlockTickY, m_BlockTickZ, E_BLOCK_GRASS, GetLight( m_BlockMeta, Index ) );
}
+ break;
}
- break;
- case E_BLOCK_GRASS:
+ */
+
+ case E_BLOCK_GRASS:
{
char AboveBlock = GetBlock( Index+1 );
if (!( (AboveBlock == 0) || (g_BlockOneHitDig[AboveBlock]) || (g_BlockTransparent[AboveBlock]) ) ) //changed to not allow grass if any one hit object is on top
@@ -414,13 +378,12 @@ void cChunk::Tick(float a_Dt, MTRand & a_TickRandom)
}
}
- // Tick block entities (furnace)
- std::list< cFurnaceEntity* > TickBlockEntites = m_pState->TickBlockEntities; // Dangerous stuff, better make a copy.
- for( std::list< cFurnaceEntity* >::iterator itr = TickBlockEntites.begin(); itr != TickBlockEntites.end(); ++itr )
+ // Tick block entities (furnaces)
+ for (cBlockEntityList::iterator itr = m_BlockEntities.begin(); itr != m_BlockEntities.end(); ++itr)
{
- if( !(*itr)->Tick( a_Dt ) ) // Remove from list
+ if ((*itr)->GetBlockType() == E_BLOCK_FURNACE)
{
- m_pState->TickBlockEntities.remove( *itr );
+ ((cFurnaceEntity *)(*itr))->Tick( a_Dt );
}
}
}
@@ -432,7 +395,9 @@ void cChunk::Tick(float a_Dt, MTRand & a_TickRandom)
char cChunk::GetHeight( int a_X, int a_Z )
{
if( a_X >= 0 && a_X < 16 && a_Z >= 0 && a_Z < 16 )
+ {
return m_HeightMap[a_X + a_Z*16];
+ }
return 0;
}
@@ -442,41 +407,38 @@ char cChunk::GetHeight( int a_X, int a_Z )
void cChunk::CreateBlockEntities()
{
- m_pState->BlockListCriticalSection.Lock();
- for(int x = 0; x < 16; x++)
+ cCSLock Lock(m_CSBlockLists);
+ for (int x = 0; x < 16; x++)
{
- for(int z = 0; z < 16; z++)
+ for (int z = 0; z < 16; z++)
{
- for(int y = 0; y < 128; y++)
+ for (int y = 0; y < 128; y++)
{
ENUM_BLOCK_ID BlockType = (ENUM_BLOCK_ID)m_BlockData[ MakeIndex( x, y, z ) ];
- switch( BlockType )
+ switch ( BlockType )
{
- case E_BLOCK_CHEST:
- {
- m_pState->BlockEntities.push_back( new cChestEntity( x + m_PosX*16, y + m_PosY*128, z + m_PosZ*16, this ) );
- }
- break;
- case E_BLOCK_FURNACE:
+ case E_BLOCK_CHEST:
{
- m_pState->BlockEntities.push_back( new cFurnaceEntity( x + m_PosX*16, y + m_PosY*128, z + m_PosZ*16, this ) );
+ m_BlockEntities.push_back( new cChestEntity( x + m_PosX * 16, y + m_PosY * 128, z + m_PosZ * 16, m_World) );
+ break;
}
- break;
- case E_BLOCK_SIGN_POST:
- case E_BLOCK_WALLSIGN:
+
+ case E_BLOCK_FURNACE:
{
- m_pState->BlockEntities.push_back( new cSignEntity( BlockType, x + m_PosX*16, y + m_PosY*128, z + m_PosZ*16, this ) );
+ m_BlockEntities.push_back( new cFurnaceEntity( x + m_PosX * 16, y + m_PosY * 128, z + m_PosZ * 16, m_World) );
+ break;
}
- break;
- default:
+
+ case E_BLOCK_SIGN_POST:
+ case E_BLOCK_WALLSIGN:
{
+ m_BlockEntities.push_back( new cSignEntity( BlockType, x + m_PosX * 16, y + m_PosY * 128, z + m_PosZ * 16, m_World) );
+ break;
}
- break;
- }
- }
- }
- }
- m_pState->BlockListCriticalSection.Unlock();
+ } // switch (BlockType)
+ } // for y
+ } // for z
+ } // for x
}
@@ -486,21 +448,21 @@ void cChunk::CreateBlockEntities()
void cChunk::CalculateHeightmap()
{
m_bCalculateHeightmap = false;
- for(int x = 0; x < 16; x++)
+ for (int x = 0; x < 16; x++)
{
- for(int z = 0; z < 16; z++)
+ for (int z = 0; z < 16; z++)
{
- for(int y = 127; y > -1; y--)
+ for (int y = 127; y > -1; y--)
{
int index = MakeIndex( x, y, z );
- if(m_BlockData[index] != E_BLOCK_AIR)
+ if (m_BlockData[index] != E_BLOCK_AIR)
{
- m_HeightMap[x + z*16] = (char)y;
+ m_HeightMap[x + z * 16] = (char)y;
break;
}
- }
- }
- }
+ } // for y
+ } // for z
+ } // for x
}
@@ -510,7 +472,7 @@ void cChunk::CalculateHeightmap()
void cChunk::CalculateLighting()
{
// Calculate sunlight
- memset(m_BlockSkyLight, 0xff, c_NumBlocks/2 ); // Set all to fully lit, so everything above HeightMap is lit
+ memset(m_BlockSkyLight, 0xff, c_NumBlocks / 2 ); // Set all to fully lit, so everything above HeightMap is lit
for(int x = 0; x < 16; x++)
{
for(int z = 0; z < 16; z++)
@@ -577,15 +539,23 @@ void cChunk::SpreadLight(char* a_LightBuffer)
bool bCalcLeft, bCalcRight, bCalcFront, bCalcBack;
bCalcLeft = bCalcRight = bCalcFront = bCalcBack = false;
+
// Spread to neighbour chunks X-axis
- ptr_cChunk LeftChunk = m_World->GetChunkUnreliable( m_PosX-1, m_PosY, m_PosZ );
- ptr_cChunk RightChunk = m_World->GetChunkUnreliable( m_PosX+1, m_PosY, m_PosZ );
- char* LeftSky = 0, *RightSky = 0;
- if(LeftChunk) LeftSky = (a_LightBuffer==m_BlockSkyLight)?LeftChunk->pGetSkyLight():LeftChunk->pGetLight();
- if(RightChunk) RightSky = (a_LightBuffer==m_BlockSkyLight)?RightChunk->pGetSkyLight():RightChunk->pGetLight();
- for(int z = 0; z < 16; z++) for(int y = 0; y < 128; y++)
+ cChunkPtr LeftChunk = m_World->GetChunkNoGen( m_PosX - 1, m_PosY, m_PosZ );
+ cChunkPtr RightChunk = m_World->GetChunkNoGen( m_PosX + 1, m_PosY, m_PosZ );
+ char * LeftSky = NULL, *RightSky = NULL;
+ if (LeftChunk->IsValid())
{
- if( LeftChunk )
+ LeftSky = (a_LightBuffer == m_BlockSkyLight) ? LeftChunk->pGetSkyLight() : LeftChunk->pGetLight();
+ }
+ if (RightChunk->IsValid())
+ {
+ RightSky = (a_LightBuffer == m_BlockSkyLight) ? RightChunk->pGetSkyLight() : RightChunk->pGetLight();
+ }
+
+ for (int z = 0; z < 16; z++) for(int y = 0; y < 128; y++)
+ {
+ if (LeftSky != NULL)
{
int index = y + (z * 128) + (0 * 128 * 16);
if( g_BlockSpreadLightFalloff[ m_BlockData[index] ] > 0 )
@@ -599,7 +569,7 @@ void cChunk::SpreadLight(char* a_LightBuffer)
}
}
}
- if( RightChunk )
+ if (RightSky != NULL)
{
int index = y + (z * 128) + (15 * 128 * 16);
if( g_BlockSpreadLightFalloff[ m_BlockData[index] ] > 0 )
@@ -616,14 +586,20 @@ void cChunk::SpreadLight(char* a_LightBuffer)
}
// Spread to neighbour chunks Z-axis
- ptr_cChunk FrontChunk = m_World->GetChunkUnreliable( m_PosX, m_PosY, m_PosZ-1 );
- ptr_cChunk BackChunk = m_World->GetChunkUnreliable( m_PosX, m_PosY, m_PosZ+1 );
- char* FrontSky = 0, *BackSky = 0;
- if(FrontChunk) FrontSky = (a_LightBuffer==m_BlockSkyLight)?FrontChunk->pGetSkyLight():FrontChunk->pGetLight();
- if(BackChunk) BackSky = (a_LightBuffer==m_BlockSkyLight)?BackChunk->pGetSkyLight():BackChunk->pGetLight();
+ cChunkPtr FrontChunk = m_World->GetChunkNoGen( m_PosX, m_PosY, m_PosZ - 1 );
+ cChunkPtr BackChunk = m_World->GetChunkNoGen( m_PosX, m_PosY, m_PosZ + 1 );
+ char * FrontSky = NULL, * BackSky = NULL;
+ if (FrontChunk->IsValid())
+ {
+ FrontSky = (a_LightBuffer == m_BlockSkyLight) ? FrontChunk->pGetSkyLight() : FrontChunk->pGetLight();
+ }
+ if (BackChunk->IsValid())
+ {
+ BackSky = (a_LightBuffer == m_BlockSkyLight) ? BackChunk->pGetSkyLight() : BackChunk->pGetLight();
+ }
for(int x = 0; x < 16; x++) for(int y = 0; y < 128; y++)
{
- if( FrontChunk )
+ if (FrontSky != NULL)
{
int index = y + (0 * 128) + (x * 128 * 16);
if( g_BlockSpreadLightFalloff[ m_BlockData[index] ] > 0 )
@@ -637,14 +613,14 @@ void cChunk::SpreadLight(char* a_LightBuffer)
}
}
}
- if( BackChunk )
+ if (BackSky != NULL)
{
int index = y + (15 * 128) + (x * 128 * 16);
if( g_BlockSpreadLightFalloff[ m_BlockData[index] ] > 0 )
{
char CurrentLight = GetLight( a_LightBuffer, x, y, 15 );
char BackLight = GetLight( BackSky, x, y, 0 );
- if( BackLight < CurrentLight-g_BlockSpreadLightFalloff[ m_BlockData[index] ] )
+ if ( BackLight < CurrentLight-g_BlockSpreadLightFalloff[ m_BlockData[index] ] )
{
SetLight( BackSky, x, y, 0, MAX(0, CurrentLight-g_BlockSpreadLightFalloff[ m_BlockData[index] ]) );
bCalcBack = true;
@@ -665,8 +641,8 @@ void cChunk::SpreadLight(char* a_LightBuffer)
void cChunk::AsyncUnload( cClientHandle* a_Client )
{
- m_pState->UnloadQuery.remove( a_Client ); // Make sure this client is only in the list once
- m_pState->UnloadQuery.push_back( a_Client );
+ m_UnloadQuery.remove( a_Client ); // Make sure this client is only in the list once
+ m_UnloadQuery.push_back( a_Client );
}
@@ -682,12 +658,11 @@ void cChunk::Send( cClientHandle* a_Client )
a_Client->Send( PreChunk );
a_Client->Send( cPacket_MapChunk( this ) );
- m_pState->BlockListCriticalSection.Lock();
- for( BlockEntityList::iterator itr = m_pState->BlockEntities.begin(); itr != m_pState->BlockEntities.end(); ++itr )
+ cCSLock Lock(m_CSBlockLists);
+ for (cBlockEntityList::iterator itr = m_BlockEntities.begin(); itr != m_BlockEntities.end(); ++itr )
{
(*itr)->SendTo( a_Client );
}
- m_pState->BlockListCriticalSection.Unlock();
}
@@ -701,6 +676,8 @@ void cChunk::SetBlock( int a_X, int a_Y, int a_Z, char a_BlockType, char a_Block
return; // Clip
}
+ assert(IsValid()); // Is this chunk loaded / generated?
+
int index = a_Y + (a_Z * 128) + (a_X * 128 * 16);
char OldBlockMeta = GetLight( m_BlockMeta, index );
char OldBlockType = m_BlockType[index];
@@ -713,17 +690,16 @@ void cChunk::SetBlock( int a_X, int a_Y, int a_Z, char a_BlockType, char a_Block
return;
}
- //LOG("Old: %i %i New: %i %i", OldBlockType, OldBlockMeta, a_BlockType, a_BlockMeta );
- cCSLock Lock(m_pState->BlockListCriticalSection);
- m_pState->PendingSendBlocks.push_back( index );
+ cCSLock Lock(m_CSBlockLists);
+ m_PendingSendBlocks.push_back( index );
- m_pState->ToTickBlocks[ MakeIndex( a_X, a_Y, a_Z ) ]++;
- m_pState->ToTickBlocks[ MakeIndex( a_X+1, a_Y, a_Z ) ]++;
- m_pState->ToTickBlocks[ MakeIndex( a_X-1, a_Y, a_Z ) ]++;
- m_pState->ToTickBlocks[ MakeIndex( a_X, a_Y+1, a_Z ) ]++;
- m_pState->ToTickBlocks[ MakeIndex( a_X, a_Y-1, a_Z ) ]++;
- m_pState->ToTickBlocks[ MakeIndex( a_X, a_Y, a_Z+1 ) ]++;
- m_pState->ToTickBlocks[ MakeIndex( a_X, a_Y, a_Z-1 ) ]++;
+ m_ToTickBlocks[ MakeIndex( a_X, a_Y, a_Z ) ]++;
+ m_ToTickBlocks[ MakeIndex( a_X+1, a_Y, a_Z ) ]++;
+ m_ToTickBlocks[ MakeIndex( a_X-1, a_Y, a_Z ) ]++;
+ m_ToTickBlocks[ MakeIndex( a_X, a_Y+1, a_Z ) ]++;
+ m_ToTickBlocks[ MakeIndex( a_X, a_Y-1, a_Z ) ]++;
+ m_ToTickBlocks[ MakeIndex( a_X, a_Y, a_Z+1 ) ]++;
+ m_ToTickBlocks[ MakeIndex( a_X, a_Y, a_Z-1 ) ]++;
cBlockEntity* BlockEntity = GetBlockEntity( a_X + m_PosX*16, a_Y+m_PosY*128, a_Z+m_PosZ*16 );
if( BlockEntity )
@@ -736,18 +712,18 @@ void cChunk::SetBlock( int a_X, int a_Y, int a_Z, char a_BlockType, char a_Block
{
case E_BLOCK_CHEST:
{
- AddBlockEntity( new cChestEntity( a_X + m_PosX*16, a_Y + m_PosY*128, a_Z + m_PosZ*16, this ) );
+ AddBlockEntity( new cChestEntity( a_X + m_PosX * 16, a_Y + m_PosY * 128, a_Z + m_PosZ * 16, m_World) );
break;
}
case E_BLOCK_FURNACE:
{
- AddBlockEntity( new cFurnaceEntity( a_X + m_PosX*16, a_Y + m_PosY*128, a_Z + m_PosZ*16, this ) );
+ AddBlockEntity( new cFurnaceEntity( a_X + m_PosX * 16, a_Y + m_PosY * 128, a_Z + m_PosZ * 16, m_World) );
break;
}
case E_BLOCK_SIGN_POST:
case E_BLOCK_WALLSIGN:
{
- AddBlockEntity( new cSignEntity( (ENUM_BLOCK_ID)a_BlockType, a_X + m_PosX*16, a_Y + m_PosY*128, a_Z + m_PosZ*16, this ) );
+ AddBlockEntity( new cSignEntity( (ENUM_BLOCK_ID)a_BlockType, a_X + m_PosX * 16, a_Y + m_PosY * 128, a_Z + m_PosZ * 16, m_World) );
break;
}
} // switch (a_BlockType)
@@ -761,17 +737,24 @@ void cChunk::FastSetBlock( int a_X, int a_Y, int a_Z, char a_BlockType, char a_B
{
if(a_X < 0 || a_X >= 16 || a_Y < 0 || a_Y >= 128 || a_Z < 0 || a_Z >= 16)
{
- //printf(">>>>>>>>>>>>>>>> CLIPPED SETBLOCK %i %i %i\n", a_X, a_Y, a_Z );
return; // Clip
}
+ assert(IsValid());
+
const int index = a_Y + (a_Z * 128) + (a_X * 128 * 16);
const char OldBlock = m_BlockType[index];
+ if (OldBlock == a_BlockType)
+ {
+ return;
+ }
m_BlockType[index] = a_BlockType;
- m_pState->BlockListCriticalSection.Lock();
- m_pState->PendingSendBlocks.push_back( index );
- m_pState->BlockListCriticalSection.Unlock();
+ {
+ cCSLock Lock(m_CSBlockLists);
+ m_PendingSendBlocks.push_back( index );
+ }
+
SetLight( m_BlockMeta, index, a_BlockMeta );
// ONLY recalculate lighting if it's necessary!
@@ -794,15 +777,14 @@ void cChunk::SendBlockTo( int a_X, int a_Y, int a_Z, cClientHandle* a_Client )
{
if( a_Client == 0 )
{
- m_pState->BlockListCriticalSection.Lock();
- m_pState->PendingSendBlocks.push_back( MakeIndex( a_X, a_Y, a_Z ) );
- m_pState->BlockListCriticalSection.Unlock();
+ cCSLock Lock(m_CSBlockLists);
+ m_PendingSendBlocks.push_back( MakeIndex( a_X, a_Y, a_Z ) );
return;
}
- for( std::list< cClientHandle* >::iterator itr = m_pState->LoadedByClient.begin(); itr != m_pState->LoadedByClient.end(); ++itr )
+ for (cClientHandleList::iterator itr = m_LoadedByClient.begin(); itr != m_LoadedByClient.end(); ++itr )
{
- if( *itr == a_Client )
+ if ( *itr == a_Client )
{
unsigned int index = MakeIndex( a_X, a_Y, a_Z );
cPacket_BlockChange BlockChange;
@@ -823,9 +805,85 @@ void cChunk::SendBlockTo( int a_X, int a_Y, int a_Z, cClientHandle* a_Client )
void cChunk::AddBlockEntity( cBlockEntity* a_BlockEntity )
{
- m_pState->BlockListCriticalSection.Lock();
- m_pState->BlockEntities.push_back( a_BlockEntity );
- m_pState->BlockListCriticalSection.Unlock();
+ 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::CollectPickupsByPlayer(cPlayer * a_Player)
+{
+ cCSLock Lock(m_CSEntities);
+
+ 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::E_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
+ {
+ (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
+ cCSLock Lock(m_CSEntities);
+ 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)
+ )
+ )
+ {
+ (reinterpret_cast<cSignEntity *>(*itr))->SetLines(a_Line1, a_Line2, a_Line3, a_Line4);
+ (*itr)->SendTo(NULL);
+ }
+ } // for itr - m_BlockEntities[]
}
@@ -834,9 +892,8 @@ void cChunk::AddBlockEntity( cBlockEntity* a_BlockEntity )
void cChunk::RemoveBlockEntity( cBlockEntity* a_BlockEntity )
{
- m_pState->BlockListCriticalSection.Lock();
- m_pState->BlockEntities.remove( a_BlockEntity );
- m_pState->BlockListCriticalSection.Unlock();
+ cCSLock Lock(m_CSBlockLists);
+ m_BlockEntities.remove( a_BlockEntity );
}
@@ -845,16 +902,18 @@ void cChunk::RemoveBlockEntity( cBlockEntity* a_BlockEntity )
void cChunk::AddClient( cClientHandle* a_Client )
{
- m_pState->LoadedByClient.remove( a_Client );
- m_pState->LoadedByClient.push_back( a_Client );
+ {
+ cCSLock Lock(m_CSClients);
+ m_LoadedByClient.remove( a_Client );
+ m_LoadedByClient.push_back( a_Client );
+ }
- LockEntities();
- for( EntityList::iterator itr = m_pState->Entities.begin(); itr != m_pState->Entities.end(); ++itr )
+ cCSLock Lock(m_CSEntities);
+ for (cEntityList::iterator itr = m_Entities.begin(); itr != m_Entities.end(); ++itr )
{
- LOG("%i %i %i Spawning on %s", m_PosX, m_PosY, m_PosZ, a_Client->GetUsername().c_str() );
+ LOG("Entity at [%i %i %i] spawning for player \"%s\"", m_PosX, m_PosY, m_PosZ, a_Client->GetUsername().c_str() );
(*itr)->SpawnOn( a_Client );
}
- UnlockEntities();
}
@@ -863,18 +922,20 @@ void cChunk::AddClient( cClientHandle* a_Client )
void cChunk::RemoveClient( cClientHandle* a_Client )
{
- m_pState->LoadedByClient.remove( a_Client );
+ {
+ cCSLock Lock(m_CSClients);
+ m_LoadedByClient.remove( a_Client );
+ }
- if( !a_Client->IsDestroyed() )
+ if ( !a_Client->IsDestroyed() )
{
- LockEntities();
- for( EntityList::iterator itr = m_pState->Entities.begin(); itr != m_pState->Entities.end(); ++itr )
+ cCSLock Lock(m_CSEntities);
+ for (cEntityList::iterator itr = m_Entities.begin(); itr != m_Entities.end(); ++itr )
{
- LOG("%i %i %i Destroying on %s", m_PosX, m_PosY, m_PosZ, a_Client->GetUsername().c_str() );
+ LOG("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 );
}
- UnlockEntities();
}
}
@@ -882,53 +943,52 @@ void cChunk::RemoveClient( cClientHandle* a_Client )
-void cChunk::AddEntity( cEntity & a_Entity )
+bool cChunk::HasClient( cClientHandle* a_Client )
{
- LockEntities();
- m_pState->Entities.push_back( &a_Entity );
- UnlockEntities();
+ cCSLock Lock(m_CSClients);
+ for (cClientHandleList::const_iterator itr = m_LoadedByClient.begin(); itr != m_LoadedByClient.end(); ++itr)
+ {
+ if ((*itr) == a_Client)
+ {
+ return true;
+ }
+ }
+ return false;
}
-bool cChunk::RemoveEntity( cEntity & a_Entity, cChunk* a_CalledFrom /* = 0 */ )
+bool cChunk::HasAnyClient(void)
{
- LockEntities();
- unsigned int SizeBefore = m_pState->Entities.size();
- m_pState->Entities.remove( &a_Entity );
- if( SizeBefore == m_pState->Entities.size() )
- {
- LOG("WARNING: Entity was not in chunk %i %i %i", m_PosX, m_PosY, m_PosZ );
- if( !a_CalledFrom )
- {
- UnlockEntities();
- return m_World->RemoveEntityFromChunk( a_Entity, this );
- }
- UnlockEntities();
- return false;
- }
- UnlockEntities();
- return true;
+ cCSLock Lock(m_CSClients);
+ return !m_LoadedByClient.empty();
}
-void cChunk::LockEntities()
+void cChunk::AddEntity( cEntity * a_Entity )
{
- m_EntitiesCriticalSection->Lock();
+ cCSLock Lock(m_CSEntities);
+ m_Entities.push_back( a_Entity );
}
-void cChunk::UnlockEntities()
+void cChunk::RemoveEntity(cEntity * a_Entity)
{
- m_EntitiesCriticalSection->Unlock();
+ size_t SizeBefore, SizeAfter;
+ {
+ cCSLock Lock(m_CSEntities);
+ SizeBefore = m_Entities.size();
+ m_Entities.remove(a_Entity);
+ SizeAfter = m_Entities.size();
+ }
}
@@ -937,7 +997,7 @@ void cChunk::UnlockEntities()
char cChunk::GetBlock( int a_X, int a_Y, int a_Z )
{
- if(a_X < 0 || a_X >= 16 || a_Y < 0 || a_Y >= 128 || a_Z < 0 || a_Z >= 16) return 0; // Clip
+ if ((a_X < 0) || (a_X >= 16) || (a_Y < 0) || (a_Y >= 128) || (a_Z < 0) || (a_Z >= 16)) return 0; // Clip
int index = a_Y + (a_Z * 128) + (a_X * 128 * 16);
return m_BlockType[index];
@@ -957,28 +1017,6 @@ char cChunk::GetBlock( int a_BlockIdx )
-cBlockEntity* cChunk::GetBlockEntity( int a_X, int a_Y, int a_Z )
-{
- m_pState->BlockListCriticalSection.Lock();
- for( std::list<cBlockEntity*>::iterator itr = m_pState->BlockEntities.begin(); itr != m_pState->BlockEntities.end(); ++itr)
- {
- if( (*itr)->GetPosX() == a_X &&
- (*itr)->GetPosY() == a_Y &&
- (*itr)->GetPosZ() == a_Z )
- {
- cBlockEntity* BlockEnt = *itr;
- m_pState->BlockListCriticalSection.Unlock();
- return BlockEnt;
- }
- }
- m_pState->BlockListCriticalSection.Unlock();
- return 0;
-}
-
-
-
-
-
/// Loads the chunk from the old-format disk file, erases the file afterwards. Returns true if successful
bool cChunk::LoadFromDisk()
{
@@ -998,7 +1036,7 @@ bool cChunk::LoadFromDisk()
}
// Now load Block Entities
- cCSLock Lock(m_pState->BlockListCriticalSection);
+ cCSLock Lock(m_CSEntities);
ENUM_BLOCK_ID BlockType;
while (f.Read(&BlockType, sizeof(ENUM_BLOCK_ID)) == sizeof(ENUM_BLOCK_ID))
@@ -1007,42 +1045,41 @@ bool cChunk::LoadFromDisk()
{
case E_BLOCK_CHEST:
{
- cChestEntity * ChestEntity = new cChestEntity( 0, 0, 0, this );
+ 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_pState->BlockEntities.push_back( ChestEntity );
+ m_BlockEntities.push_back( ChestEntity );
break;
}
case E_BLOCK_FURNACE:
{
- cFurnaceEntity* FurnaceEntity = new cFurnaceEntity( 0, 0, 0, this );
+ 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_pState->BlockEntities.push_back( FurnaceEntity );
- m_pState->TickBlockEntities.push_back( FurnaceEntity ); // They need tickin'
+ m_BlockEntities.push_back( FurnaceEntity );
break;
}
case E_BLOCK_SIGN_POST:
case E_BLOCK_WALLSIGN:
{
- cSignEntity * SignEntity = new cSignEntity(BlockType, 0, 0, 0, this );
+ 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_pState->BlockEntities.push_back( SignEntity );
+ m_BlockEntities.push_back( SignEntity );
break;
}
@@ -1072,9 +1109,10 @@ bool cChunk::LoadFromDisk()
-void cChunk::Broadcast( const cPacket & a_Packet, cClientHandle* a_Exclude /* = 0 */ ) const
+void cChunk::Broadcast( const cPacket * a_Packet, cClientHandle* a_Exclude)
{
- for( std::list< cClientHandle* >::const_iterator itr = m_pState->LoadedByClient.begin(); itr != m_pState->LoadedByClient.end(); ++itr )
+ cCSLock Lock(m_CSClients);
+ for (cClientHandleList::const_iterator itr = m_LoadedByClient.begin(); itr != m_LoadedByClient.end(); ++itr )
{
if (*itr == a_Exclude)
{
@@ -1088,58 +1126,69 @@ void cChunk::Broadcast( const cPacket & a_Packet, cClientHandle* a_Exclude /* =
+void cChunk::CopyBlockDataFrom(const char * a_NewBlockData)
+{
+ // Copies all blockdata, recalculates heightmap (used by chunk loaders)
+ memcpy(m_BlockData, a_NewBlockData, sizeof(m_BlockData));
+ CalculateHeightmap();
+}
+
+
+
+
+
void cChunk::LoadFromJson( const Json::Value & a_Value )
{
- cCSLock Lock(m_pState->BlockListCriticalSection);
+ cCSLock Lock(m_CSEntities);
// Load chests
Json::Value AllChests = a_Value.get("Chests", Json::nullValue);
if (!AllChests.empty())
{
- for( Json::Value::iterator itr = AllChests.begin(); itr != AllChests.end(); ++itr )
+ for ( Json::Value::iterator itr = AllChests.begin(); itr != AllChests.end(); ++itr )
{
Json::Value & Chest = *itr;
- cChestEntity* ChestEntity = new cChestEntity(0,0,0, this);
- if( !ChestEntity->LoadFromJson( Chest ) )
+ cChestEntity* ChestEntity = new cChestEntity(0, 0, 0, m_World);
+ if ( !ChestEntity->LoadFromJson( Chest ) )
{
LOGERROR("ERROR READING CHEST FROM JSON!" );
delete ChestEntity;
}
- else m_pState->BlockEntities.push_back( ChestEntity );
+ else m_BlockEntities.push_back( ChestEntity );
}
}
// Load furnaces
Json::Value AllFurnaces = a_Value.get("Furnaces", Json::nullValue);
- if( !AllFurnaces.empty() )
+ if ( !AllFurnaces.empty() )
{
- for( Json::Value::iterator itr = AllFurnaces.begin(); itr != AllFurnaces.end(); ++itr )
+ for ( Json::Value::iterator itr = AllFurnaces.begin(); itr != AllFurnaces.end(); ++itr )
{
Json::Value & Furnace = *itr;
- cFurnaceEntity* FurnaceEntity = new cFurnaceEntity(0,0,0, this);
- if( !FurnaceEntity->LoadFromJson( Furnace ) )
+ cFurnaceEntity* FurnaceEntity = new cFurnaceEntity(0, 0, 0, m_World);
+ if ( !FurnaceEntity->LoadFromJson( Furnace ) )
{
LOGERROR("ERROR READING FURNACE FROM JSON!" );
delete FurnaceEntity;
}
- else m_pState->BlockEntities.push_back( FurnaceEntity );
+ else m_BlockEntities.push_back( FurnaceEntity );
}
}
// Load signs
Json::Value AllSigns = a_Value.get("Signs", Json::nullValue);
- if( !AllSigns.empty() )
+ if ( !AllSigns.empty() )
{
- for( Json::Value::iterator itr = AllSigns.begin(); itr != AllSigns.end(); ++itr )
+ for ( Json::Value::iterator itr = AllSigns.begin(); itr != AllSigns.end(); ++itr )
{
Json::Value & Sign = *itr;
- cSignEntity* SignEntity = new cSignEntity( E_BLOCK_SIGN_POST, 0,0,0, this);
- if( !SignEntity->LoadFromJson( Sign ) )
+ cSignEntity* SignEntity = new cSignEntity( E_BLOCK_SIGN_POST, 0, 0, 0, m_World);
+ if ( !SignEntity->LoadFromJson( Sign ) )
{
LOGERROR("ERROR READING SIGN FROM JSON!" );
delete SignEntity;
}
- else m_pState->BlockEntities.push_back( SignEntity );
+ else m_BlockEntities.push_back( SignEntity );
}
}
}
@@ -1153,11 +1202,11 @@ void cChunk::SaveToJson( Json::Value & a_Value )
Json::Value AllChests;
Json::Value AllFurnaces;
Json::Value AllSigns;
- cCSLock Lock(m_pState->BlockListCriticalSection);
- for (std::list<cBlockEntity*>::iterator itr = m_pState->BlockEntities.begin(); itr != m_pState->BlockEntities.end(); ++itr)
+ cCSLock Lock(m_CSEntities);
+ for (cBlockEntityList::iterator itr = m_BlockEntities.begin(); itr != m_BlockEntities.end(); ++itr)
{
- cBlockEntity* BlockEntity = *itr;
- switch( BlockEntity->GetBlockType() )
+ cBlockEntity * BlockEntity = *itr;
+ switch ( BlockEntity->GetBlockType() )
{
case E_BLOCK_CHEST:
{
@@ -1196,48 +1245,17 @@ void cChunk::SaveToJson( Json::Value & a_Value )
} // for itr - BlockEntities[]
if( !AllChests.empty() )
+ {
a_Value["Chests"] = AllChests;
+ }
if( !AllFurnaces.empty() )
+ {
a_Value["Furnaces"] = AllFurnaces;
+ }
if( !AllSigns.empty() )
+ {
a_Value["Signs"] = AllSigns;
-}
-
-
-
-
-
-EntityList & cChunk::GetEntities()
-{
- return m_pState->Entities;
-}
-
-
-
-
-
-const ClientHandleList & cChunk::GetClients()
-{
- return m_pState->LoadedByClient;
-}
-
-
-
-
-
-void cChunk::AddTickBlockEntity( cFurnaceEntity* a_Entity )
-{
- m_pState->TickBlockEntities.remove( a_Entity );
- m_pState->TickBlockEntities.push_back( a_Entity );
-}
-
-
-
-
-
-void cChunk::RemoveTickBlockEntity( cFurnaceEntity* a_Entity )
-{
- m_pState->TickBlockEntities.remove( a_Entity );
+ }
}
@@ -1255,42 +1273,6 @@ void cChunk::PositionToWorldPosition(int a_ChunkX, int a_ChunkY, int a_ChunkZ, i
-void cChunk::AddReference()
-{
- cCSLock Lock(m_pState->ReferenceCriticalSection);
- m_pState->NumRefs++;
-}
-
-
-
-
-
-void cChunk::RemoveReference()
-{
- cCSLock Lock(m_pState->ReferenceCriticalSection);
- m_pState->NumRefs--;
- assert (m_pState->NumRefs >= 0);
- if (m_pState->NumRefs < 0)
- {
- LOGWARN("WARNING: cChunk: Tried to remove reference, but the chunk is not referenced!");
- }
-}
-
-
-
-
-
-int cChunk::GetReferenceCount()
-{
- cCSLock Lock(m_pState->ReferenceCriticalSection);
- int Refs = m_pState->NumRefs;
- return Refs;
-}
-
-
-
-
-
#if !C_CHUNK_USE_INLINE
# include "cChunk.inc"
#endif
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-01 05:48:53 +0100