summaryrefslogtreecommitdiffstats
path: root/source/cChunk.cpp
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--source/cChunk.cpp3286
1 files changed, 1643 insertions, 1643 deletions
diff --git a/source/cChunk.cpp b/source/cChunk.cpp
index 5d5a1d972..98415b572 100644
--- a/source/cChunk.cpp
+++ b/source/cChunk.cpp
@@ -1,1643 +1,1643 @@
-
-#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() );
- }
-
- CheckBlocks();
-
- 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::CheckBlocks(void)
-{
- cCSLock Lock2(m_CSBlockLists);
- unsigned int NumTickBlocks = m_ToTickBlocks.size();
- Lock2.Unlock();
-
- if (NumTickBlocks == 0)
- {
- return;
- }
-
- Lock2.Lock();
- std::deque< unsigned int > ToTickBlocks = m_ToTickBlocks;
- m_ToTickBlocks.clear();
- Lock2.Unlock();
-
- for (std::deque< unsigned int >::const_iterator itr = ToTickBlocks.begin(); itr != ToTickBlocks.end(); ++itr)
- {
- unsigned int index = (*itr);
- Vector3i BlockPos = IndexToCoordinate(index);
-
- BLOCKTYPE BlockType = GetBlock(index);
- NIBBLETYPE BlockMeta = GetMeta (index);
- switch (BlockType)
- {
- // Stuff that drops when block below is destroyed:
- case E_BLOCK_REDSTONE_REPEATER_OFF:
- case E_BLOCK_REDSTONE_REPEATER_ON:
- case E_BLOCK_REDSTONE_WIRE:
- 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:
- case E_BLOCK_SNOW:
- {
- 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(BlockType, 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:
- 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(BlockType, 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(BlockType, BlockMeta, E_ITEM_EMPTY, Pickups);
- m_World->SpawnItemPickups(Pickups, WorldPos.x, WorldPos.y, WorldPos.z);
- }
- break;
- }
- } // switch (BlockType)
- } // for itr - ToTickBlocks[]
-}
-
-
-
-
-
-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_CROPS:
- {
- NIBBLETYPE Meta = GetMeta(Index);
- if (Meta < 7)
- {
- FastSetBlock(m_BlockTickX, m_BlockTickY, m_BlockTickZ, E_BLOCK_CROPS, ++Meta);
- }
- break;
- }
-
- case E_BLOCK_GRASS: TickGrass (m_BlockTickX, m_BlockTickY, m_BlockTickZ, a_TickRandom); 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_SUGARCANE: GrowSugarcane (m_BlockTickX, m_BlockTickY, m_BlockTickZ, 1); break;
- case E_BLOCK_CACTUS: GrowCactus (m_BlockTickX, m_BlockTickY, m_BlockTickZ, 1); 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::TickGrass(int a_RelX, int a_RelY, int a_RelZ, MTRand & a_TickRandom)
-{
- // Grass turns into dirt if there's another block on top of it:
- {
- BLOCKTYPE AboveBlock = cChunkDef::GetBlock(m_BlockTypes, a_RelX, a_RelY + 1, a_RelZ);
- if (!((g_BlockOneHitDig[AboveBlock]) || (g_BlockTransparent[AboveBlock])))
- {
- FastSetBlock(a_RelX, a_RelY, a_RelZ, E_BLOCK_DIRT, 0);
- return;
- }
- }
-
- // Grass spreads to nearby blocks if there's enough light (TODO) and free space above that block
- // Ref.: http://www.minecraftwiki.net/wiki/Grass_Block#Growth
- for (int i = 0; i < 2; i++) // Pick two blocks to grow to
- {
- int OfsX = a_TickRandom.randInt(2) - 1; // [-1 .. 1]
- int OfsY = a_TickRandom.randInt(4) - 3; // [-3 .. 1]
- int OfsZ = a_TickRandom.randInt(2) - 1; // [-1 .. 1]
-
- BLOCKTYPE DestBlock;
- NIBBLETYPE DestMeta;
- if (
- !UnboundedRelGetBlock(a_RelX + OfsX, a_RelY + OfsY, a_RelZ + OfsZ, DestBlock, DestMeta) ||
- (DestBlock != E_BLOCK_DIRT)
- )
- {
- continue;
- }
-
- BLOCKTYPE AboveDest;
- NIBBLETYPE AboveMeta;
- if (
- UnboundedRelGetBlock(a_RelX + OfsX, a_RelY + OfsY + 1, a_RelZ + OfsZ, AboveDest, AboveMeta) &&
- ((g_BlockOneHitDig[AboveDest]) || (g_BlockTransparent[AboveDest]))
- // TODO: Query dest light, if it's enough
- )
- {
- UnboundedRelFastSetBlock(a_RelX + OfsX, a_RelY + OfsY, a_RelZ + OfsZ, E_BLOCK_GRASS, 0);
- }
- } // for i - repeat twice
-}
-
-
-
-
-
-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;
- }
- GrowMelonPumpkin(a_RelX, a_RelY, a_RelZ, a_BlockType, a_TickRandom);
-}
-
-
-
-
-
-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:
-}
-
-
-
-
-
-void cChunk::GrowMelonPumpkin(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockType, MTRand & a_TickRandom)
-{
- // 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::GrowSugarcane(int a_RelX, int a_RelY, int a_RelZ, int a_NumBlocks)
-{
- // Check the total height of the sugarcane blocks here:
- int Top = a_RelY + 1;
- while (
- (Top < cChunkDef::Height) &&
- (GetBlock(a_RelX, Top, a_RelZ) == E_BLOCK_SUGARCANE)
- )
- {
- ++Top;
- }
- int Bottom = a_RelY - 1;
- while (
- (Bottom > 0) &&
- (GetBlock(a_RelX, Bottom, a_RelZ) == E_BLOCK_SUGARCANE)
- )
- {
- --Bottom;
- }
-
- // Grow by at most a_NumBlocks, but no more than max height:
- int ToGrow = std::min(a_NumBlocks, m_World->GetMaxSugarcaneHeight() + 1 - (Top - Bottom));
- for (int i = 0; i < ToGrow; i++)
- {
- BLOCKTYPE BlockType;
- NIBBLETYPE BlockMeta;
- if (UnboundedRelGetBlock(a_RelX, Top + i, a_RelZ, BlockType, BlockMeta) && (BlockType == E_BLOCK_AIR))
- {
- UnboundedRelFastSetBlock(a_RelX, Top + i, a_RelZ, E_BLOCK_SUGARCANE, 0);
- }
- else
- {
- break;
- }
- } // for i
-}
-
-
-
-
-
-void cChunk::GrowCactus(int a_RelX, int a_RelY, int a_RelZ, int a_NumBlocks)
-{
- // Check the total height of the sugarcane blocks here:
- int Top = a_RelY + 1;
- while (
- (Top < cChunkDef::Height) &&
- (GetBlock(a_RelX, Top, a_RelZ) == E_BLOCK_CACTUS)
- )
- {
- ++Top;
- }
- int Bottom = a_RelY - 1;
- while (
- (Bottom > 0) &&
- (GetBlock(a_RelX, Bottom, a_RelZ) == E_BLOCK_CACTUS)
- )
- {
- --Bottom;
- }
-
- // Grow by at most a_NumBlocks, but no more than max height:
- int ToGrow = std::min(a_NumBlocks, m_World->GetMaxCactusHeight() + 1 - (Top - Bottom));
- for (int i = 0; i < ToGrow; i++)
- {
- BLOCKTYPE BlockType;
- NIBBLETYPE BlockMeta;
- if (UnboundedRelGetBlock(a_RelX, Top + i, a_RelZ, BlockType, BlockMeta) && (BlockType == E_BLOCK_AIR))
- {
- // TODO: Check the surrounding blocks, if they aren't air, break the cactus block into pickups (and continue breaking blocks above in the next loop iterations)
- UnboundedRelFastSetBlock(a_RelX, Top + i, a_RelZ, E_BLOCK_CACTUS, 0);
- }
- else
- {
- break;
- }
- } // for i
-}
-
-
-
-
-
-bool cChunk::UnboundedRelGetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta)
-{
- if ((a_RelY < 0) || (a_RelY > cChunkDef::Height))
- {
- return false;
- }
-
- 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 ];
-}
-
-
-
-
-
-void cChunk::GetBlockTypeMeta(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta)
-{
- int Idx = cChunkDef::MakeIndexNoCheck(a_RelX, a_RelY, a_RelZ);
- a_BlockType = cChunkDef::GetBlock (m_BlockTypes, a_RelX, a_RelY, a_RelZ);
- a_BlockMeta = cChunkDef::GetNibble(m_BlockMeta, a_RelX, a_RelY, a_RelZ);
-}
-
-
-
-
-
-/*
-// _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
-
-
-
-
+
+#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() );
+ }
+
+ CheckBlocks();
+
+ 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::CheckBlocks(void)
+{
+ cCSLock Lock2(m_CSBlockLists);
+ unsigned int NumTickBlocks = m_ToTickBlocks.size();
+ Lock2.Unlock();
+
+ if (NumTickBlocks == 0)
+ {
+ return;
+ }
+
+ Lock2.Lock();
+ std::deque< unsigned int > ToTickBlocks = m_ToTickBlocks;
+ m_ToTickBlocks.clear();
+ Lock2.Unlock();
+
+ for (std::deque< unsigned int >::const_iterator itr = ToTickBlocks.begin(); itr != ToTickBlocks.end(); ++itr)
+ {
+ unsigned int index = (*itr);
+ Vector3i BlockPos = IndexToCoordinate(index);
+
+ BLOCKTYPE BlockType = GetBlock(index);
+ NIBBLETYPE BlockMeta = GetMeta (index);
+ switch (BlockType)
+ {
+ // Stuff that drops when block below is destroyed:
+ case E_BLOCK_REDSTONE_REPEATER_OFF:
+ case E_BLOCK_REDSTONE_REPEATER_ON:
+ case E_BLOCK_REDSTONE_WIRE:
+ 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:
+ case E_BLOCK_SNOW:
+ {
+ 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(BlockType, 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:
+ 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(BlockType, 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(BlockType, BlockMeta, E_ITEM_EMPTY, Pickups);
+ m_World->SpawnItemPickups(Pickups, WorldPos.x, WorldPos.y, WorldPos.z);
+ }
+ break;
+ }
+ } // switch (BlockType)
+ } // for itr - ToTickBlocks[]
+}
+
+
+
+
+
+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_CROPS:
+ {
+ NIBBLETYPE Meta = GetMeta(Index);
+ if (Meta < 7)
+ {
+ FastSetBlock(m_BlockTickX, m_BlockTickY, m_BlockTickZ, E_BLOCK_CROPS, ++Meta);
+ }
+ break;
+ }
+
+ case E_BLOCK_GRASS: TickGrass (m_BlockTickX, m_BlockTickY, m_BlockTickZ, a_TickRandom); 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_SUGARCANE: GrowSugarcane (m_BlockTickX, m_BlockTickY, m_BlockTickZ, 1); break;
+ case E_BLOCK_CACTUS: GrowCactus (m_BlockTickX, m_BlockTickY, m_BlockTickZ, 1); 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::TickGrass(int a_RelX, int a_RelY, int a_RelZ, MTRand & a_TickRandom)
+{
+ // Grass turns into dirt if there's another block on top of it:
+ {
+ BLOCKTYPE AboveBlock = cChunkDef::GetBlock(m_BlockTypes, a_RelX, a_RelY + 1, a_RelZ);
+ if (!((g_BlockOneHitDig[AboveBlock]) || (g_BlockTransparent[AboveBlock])))
+ {
+ FastSetBlock(a_RelX, a_RelY, a_RelZ, E_BLOCK_DIRT, 0);
+ return;
+ }
+ }
+
+ // Grass spreads to nearby blocks if there's enough light (TODO) and free space above that block
+ // Ref.: http://www.minecraftwiki.net/wiki/Grass_Block#Growth
+ for (int i = 0; i < 2; i++) // Pick two blocks to grow to
+ {
+ int OfsX = a_TickRandom.randInt(2) - 1; // [-1 .. 1]
+ int OfsY = a_TickRandom.randInt(4) - 3; // [-3 .. 1]
+ int OfsZ = a_TickRandom.randInt(2) - 1; // [-1 .. 1]
+
+ BLOCKTYPE DestBlock;
+ NIBBLETYPE DestMeta;
+ if (
+ !UnboundedRelGetBlock(a_RelX + OfsX, a_RelY + OfsY, a_RelZ + OfsZ, DestBlock, DestMeta) ||
+ (DestBlock != E_BLOCK_DIRT)
+ )
+ {
+ continue;
+ }
+
+ BLOCKTYPE AboveDest;
+ NIBBLETYPE AboveMeta;
+ if (
+ UnboundedRelGetBlock(a_RelX + OfsX, a_RelY + OfsY + 1, a_RelZ + OfsZ, AboveDest, AboveMeta) &&
+ ((g_BlockOneHitDig[AboveDest]) || (g_BlockTransparent[AboveDest]))
+ // TODO: Query dest light, if it's enough
+ )
+ {
+ UnboundedRelFastSetBlock(a_RelX + OfsX, a_RelY + OfsY, a_RelZ + OfsZ, E_BLOCK_GRASS, 0);
+ }
+ } // for i - repeat twice
+}
+
+
+
+
+
+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;
+ }
+ GrowMelonPumpkin(a_RelX, a_RelY, a_RelZ, a_BlockType, a_TickRandom);
+}
+
+
+
+
+
+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:
+}
+
+
+
+
+
+void cChunk::GrowMelonPumpkin(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockType, MTRand & a_TickRandom)
+{
+ // 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::GrowSugarcane(int a_RelX, int a_RelY, int a_RelZ, int a_NumBlocks)
+{
+ // Check the total height of the sugarcane blocks here:
+ int Top = a_RelY + 1;
+ while (
+ (Top < cChunkDef::Height) &&
+ (GetBlock(a_RelX, Top, a_RelZ) == E_BLOCK_SUGARCANE)
+ )
+ {
+ ++Top;
+ }
+ int Bottom = a_RelY - 1;
+ while (
+ (Bottom > 0) &&
+ (GetBlock(a_RelX, Bottom, a_RelZ) == E_BLOCK_SUGARCANE)
+ )
+ {
+ --Bottom;
+ }
+
+ // Grow by at most a_NumBlocks, but no more than max height:
+ int ToGrow = std::min(a_NumBlocks, m_World->GetMaxSugarcaneHeight() + 1 - (Top - Bottom));
+ for (int i = 0; i < ToGrow; i++)
+ {
+ BLOCKTYPE BlockType;
+ NIBBLETYPE BlockMeta;
+ if (UnboundedRelGetBlock(a_RelX, Top + i, a_RelZ, BlockType, BlockMeta) && (BlockType == E_BLOCK_AIR))
+ {
+ UnboundedRelFastSetBlock(a_RelX, Top + i, a_RelZ, E_BLOCK_SUGARCANE, 0);
+ }
+ else
+ {
+ break;
+ }
+ } // for i
+}
+
+
+
+
+
+void cChunk::GrowCactus(int a_RelX, int a_RelY, int a_RelZ, int a_NumBlocks)
+{
+ // Check the total height of the sugarcane blocks here:
+ int Top = a_RelY + 1;
+ while (
+ (Top < cChunkDef::Height) &&
+ (GetBlock(a_RelX, Top, a_RelZ) == E_BLOCK_CACTUS)
+ )
+ {
+ ++Top;
+ }
+ int Bottom = a_RelY - 1;
+ while (
+ (Bottom > 0) &&
+ (GetBlock(a_RelX, Bottom, a_RelZ) == E_BLOCK_CACTUS)
+ )
+ {
+ --Bottom;
+ }
+
+ // Grow by at most a_NumBlocks, but no more than max height:
+ int ToGrow = std::min(a_NumBlocks, m_World->GetMaxCactusHeight() + 1 - (Top - Bottom));
+ for (int i = 0; i < ToGrow; i++)
+ {
+ BLOCKTYPE BlockType;
+ NIBBLETYPE BlockMeta;
+ if (UnboundedRelGetBlock(a_RelX, Top + i, a_RelZ, BlockType, BlockMeta) && (BlockType == E_BLOCK_AIR))
+ {
+ // TODO: Check the surrounding blocks, if they aren't air, break the cactus block into pickups (and continue breaking blocks above in the next loop iterations)
+ UnboundedRelFastSetBlock(a_RelX, Top + i, a_RelZ, E_BLOCK_CACTUS, 0);
+ }
+ else
+ {
+ break;
+ }
+ } // for i
+}
+
+
+
+
+
+bool cChunk::UnboundedRelGetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta)
+{
+ if ((a_RelY < 0) || (a_RelY > cChunkDef::Height))
+ {
+ return false;
+ }
+
+ 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 ];
+}
+
+
+
+
+
+void cChunk::GetBlockTypeMeta(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta)
+{
+ int Idx = cChunkDef::MakeIndexNoCheck(a_RelX, a_RelY, a_RelZ);
+ a_BlockType = cChunkDef::GetBlock (m_BlockTypes, a_RelX, a_RelY, a_RelZ);
+ a_BlockMeta = cChunkDef::GetNibble(m_BlockMeta, a_RelX, a_RelY, a_RelZ);
+}
+
+
+
+
+
+/*
+// _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
+
+
+
+