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

Rewritten SandSimulator to use direct chunk access; and sand falling on torches now creates a pickup.

Browse Source 
git-svn-id: http://mc-server.googlecode.com/svn/trunk@1240 0a769ca7-a7f5-676a-18bf-c427514a06d6
This commit is contained in:
madmaxoft@gmail.com 2013-03-02 19:57:09 +00:00
parent cadf97a70a
commit 6744738a85
8 changed files with 287 additions and 93 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
source/Chunk.h
View File

@ -5,6 +5,7 @@
#include "ChunkDef.h"
#include "Simulator/FireSimulator.h"
#include "Simulator/SandSimulator.h"
@ -271,6 +272,7 @@ public:
cFireSimulatorChunkData & GetFireSimulatorData (void) { return m_FireSimulatorData; }
cFluidSimulatorData * GetWaterSimulatorData(void) { return m_WaterSimulatorData; }
cFluidSimulatorData * GetLavaSimulatorData (void) { return m_LavaSimulatorData; }
cSandSimulatorChunkData & GetSandSimulatorData (void) { return m_SandSimulatorData; }
private:
@ -319,6 +321,7 @@ private:
cFireSimulatorChunkData m_FireSimulatorData;
cFluidSimulatorData * m_WaterSimulatorData;
cFluidSimulatorData * m_LavaSimulatorData;
cSandSimulatorChunkData m_SandSimulatorData;
void RemoveBlockEntity(cBlockEntity * a_BlockEntity);

4
source/Entity.cpp
View File

@ -50,9 +50,9 @@ cEntity::cEntity(eEntityType a_EntityType, double a_X, double a_Y, double a_Z)
cEntity::~cEntity()
{
LOGD("Deleting entity %d at pos {%.2f, %.2f} ~ [%d, %d]; ptr %p",
LOGD("Deleting entity %d at pos {%.2f, %.2f, %.2f} ~ [%d, %d]; ptr %p",
m_UniqueID,
m_Pos.x, m_Pos.z,
m_Pos.x, m_Pos.y, m_Pos.z,
(int)(m_Pos.x / cChunkDef::Width), (int)(m_Pos.z / cChunkDef::Width),
this
);

45
source/FallingBlock.cpp
View File

@ -3,15 +3,17 @@
#include "FallingBlock.h"
#include "World.h"
#include "ClientHandle.h"
#include "Simulator/SandSimulator.h"
cFallingBlock::cFallingBlock(const Vector3i & a_BlockPosition, BLOCKTYPE a_BlockType)
: super(etFallingBlock, a_BlockPosition.x + 0.5f, a_BlockPosition.y + 0.5f, a_BlockPosition.z + 0.5f)
, m_BlockType(a_BlockType)
, m_OriginalPosition(a_BlockPosition)
cFallingBlock::cFallingBlock(const Vector3i & a_BlockPosition, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta) :
super(etFallingBlock, a_BlockPosition.x + 0.5f, a_BlockPosition.y + 0.5f, a_BlockPosition.z + 0.5f),
m_BlockType(a_BlockType),
m_BlockMeta(a_BlockMeta),
m_OriginalPosition(a_BlockPosition)
{
}
@ -21,7 +23,7 @@ cFallingBlock::cFallingBlock(const Vector3i & a_BlockPosition, BLOCKTYPE a_Block
void cFallingBlock::Initialize(cWorld * a_World)
{
super::Initialize( a_World );
super::Initialize(a_World);
a_World->BroadcastSpawn(*this);
}
@ -44,13 +46,34 @@ void cFallingBlock::Tick(float a_Dt, MTRand & a_TickRandom)
m_Speed.y -= MilliDt * 9.8f;
m_Pos.y += m_Speed.y * MilliDt;
// GetWorld()->BroadcastTeleportEntity(*this); // Testing position
Vector3i BlockPos( m_OriginalPosition.x, (int)(m_Pos.y - 0.5), m_OriginalPosition.z);
if (!IsPassable(GetWorld()->GetBlock(BlockPos)))
// GetWorld()->BroadcastTeleportEntity(*this); // Test position
int BlockX = (int)m_OriginalPosition.x;
int BlockY = (int)(m_Pos.y - 0.5);
int BlockZ = (int)m_OriginalPosition.z;
if (BlockY < 0)
{
Destroy();
GetWorld()->SetBlock(BlockPos.x, BlockPos.y + 1, BlockPos.z, m_BlockType, 0);
// Fallen out of this world, just continue falling until out of sight, then destroy:
if (BlockY < 100)
{
Destroy();
}
return;
}
if (BlockY < cChunkDef::Height - 1)
{
BLOCKTYPE BlockBelow = GetWorld()->GetBlock(BlockX, BlockY, BlockZ);
if (
cSandSimulator::DoesBreakFallingThrough(BlockBelow) || // Fallen onto a block that breaks this into pickups (e. g. half-slab)
!cSandSimulator::CanContinueFallThrough(BlockBelow) // Fallen onto a solid block
)
{
cSandSimulator::FinishFalling(m_World, BlockX, BlockY + 1, BlockZ, m_BlockType, m_BlockMeta);
Destroy();
return;
}
}
}

15
source/FallingBlock.h
View File

@ -23,9 +23,10 @@ class cFallingBlock :
public:
CLASS_PROTODEF(cFallingBlock);
cFallingBlock(const Vector3i & a_BlockPosition, BLOCKTYPE a_BlockType);
cFallingBlock(const Vector3i & a_BlockPosition, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta);
BLOCKTYPE GetBlockType(void) const { return m_BlockType; }
BLOCKTYPE GetBlockType(void) const { return m_BlockType; }
NIBBLETYPE GetBlockMeta(void) const { return m_BlockMeta; }
// cEntity overrides:
virtual void Initialize(cWorld * a_World) override;
@ -33,13 +34,9 @@ public:
virtual void Tick(float a_Dt, MTRand & a_TickRandom) override;
private:
BLOCKTYPE m_BlockType;
Vector3i m_OriginalPosition;
static bool IsPassable(BLOCKTYPE a_BlockType)
{
return ((a_BlockType == E_BLOCK_AIR) || IsBlockLiquid(a_BlockType));
}
BLOCKTYPE m_BlockType;
NIBBLETYPE m_BlockMeta;
Vector3i m_OriginalPosition;
} ;

245
source/Simulator/SandSimulator.cpp
View File

@ -12,60 +12,72 @@
cSandSimulator::cSandSimulator(cWorld & a_World)
: cSimulator(a_World)
, m_Blocks(new BlockList)
, m_Buffer(new BlockList)
cSandSimulator::cSandSimulator(cWorld & a_World, cIniFile & a_IniFile) :
cSimulator(a_World),
m_TotalBlocks(0)
{
m_IsInstantFall = a_IniFile.GetValueSetB("Physics", "SandInstantFall", false);
}
cSandSimulator::~cSandSimulator()
void cSandSimulator::SimulateChunk(float a_Dt, int a_ChunkX, int a_ChunkZ, cChunk * a_Chunk)
{
delete m_Buffer;
delete m_Blocks;
}
void cSandSimulator::Simulate(float a_Dt)
{
m_Buffer->clear();
std::swap( m_Blocks, m_Buffer );
for( BlockList::iterator itr = m_Buffer->begin(); itr != m_Buffer->end(); ++itr )
cSandSimulatorChunkData & ChunkData = a_Chunk->GetSandSimulatorData();
if (ChunkData.empty())
{
Vector3i Pos = *itr;
BLOCKTYPE BlockID = m_World.GetBlock(Pos.x, Pos.y, Pos.z);
if(!IsAllowedBlock(BlockID))
continue;
return;
}
BLOCKTYPE BottomBlock = m_World.GetBlock( Pos.x, Pos.y - 1, Pos.z );
if( IsPassable(BottomBlock) )
int BaseX = a_Chunk->GetPosX() * cChunkDef::Width;
int BaseZ = a_Chunk->GetPosZ() * cChunkDef::Width;
for (cSandSimulatorChunkData::const_iterator itr = ChunkData.begin(), end = ChunkData.end(); itr != end; ++itr)
{
BLOCKTYPE BlockType = a_Chunk->GetBlock(itr->x, itr->y, itr->z);
if (!IsAllowedBlock(BlockType) || (itr->y <= 0))
{
cFallingBlock * FallingBlock = new cFallingBlock(Pos, BlockID);
continue;
}
BLOCKTYPE BlockBelow = (itr->y > 0) ? a_Chunk->GetBlock(itr->x, itr->y - 1, itr->z) : E_BLOCK_AIR;
if (CanStartFallingThrough(BlockBelow))
{
if (m_IsInstantFall)
{
DoInstantFall(a_Chunk, itr->x, itr->y, itr->z);
continue;
}
Vector3i Pos;
Pos.x = itr->x + BaseX;
Pos.y = itr->y;
Pos.z = itr->z + BaseZ;
cFallingBlock * FallingBlock = new cFallingBlock(Pos, BlockType, a_Chunk->GetMeta(itr->x, itr->y, itr->z));
FallingBlock->Initialize(&m_World);
m_World.SetBlock( Pos.x, Pos.y, Pos.z, E_BLOCK_AIR, 0 );
a_Chunk->SetBlock(itr->x, itr->y, itr->z, E_BLOCK_AIR, 0);
}
}
m_TotalBlocks -= ChunkData.size();
ChunkData.clear();
}
bool cSandSimulator::IsAllowedBlock( BLOCKTYPE a_BlockType )
bool cSandSimulator::IsAllowedBlock(BLOCKTYPE a_BlockType)
{
return a_BlockType == E_BLOCK_SAND
|| a_BlockType == E_BLOCK_GRAVEL;
switch (a_BlockType)
{
case E_BLOCK_SAND:
case E_BLOCK_GRAVEL:
case E_BLOCK_ANVIL:
{
return true;
}
}
return false;
}
@ -74,40 +86,169 @@ bool cSandSimulator::IsAllowedBlock( BLOCKTYPE a_BlockType )
void cSandSimulator::AddBlock(int a_BlockX, int a_BlockY, int a_BlockZ, cChunk * a_Chunk)
{
// TODO: Optimize this by passing the block type along
int RelX = a_BlockX;
int RelY = a_BlockY;
int RelZ = a_BlockZ;
int ChunkX, ChunkZ;
cChunkDef::AbsoluteToRelative(RelX, RelY, RelZ, ChunkX, ChunkZ);
if (!IsAllowedBlock(a_Chunk->GetBlock(RelX, RelY, RelZ)))
if (a_Chunk == NULL)
{
return;
}
int RelX = a_BlockX - a_Chunk->GetPosX() * cChunkDef::Width;
int RelZ = a_BlockZ - a_Chunk->GetPosZ() * cChunkDef::Width;
if (!IsAllowedBlock(a_Chunk->GetBlock(RelX, a_BlockY, RelZ)))
{
return;
}
Vector3i Block(a_BlockX, a_BlockY, a_BlockZ);
//check for duplicates
for (BlockList::iterator itr = m_Blocks->begin(); itr != m_Blocks->end(); ++itr)
// Check for duplicates:
cSandSimulatorChunkData & ChunkData = a_Chunk->GetSandSimulatorData();
for (cSandSimulatorChunkData::iterator itr = ChunkData.begin(); itr != ChunkData.end(); ++itr)
{
Vector3i Pos = *itr;
if ((Pos.x == a_BlockX) && (Pos.y == a_BlockY) && (Pos.z == a_BlockZ))
if ((itr->x == RelX) && (itr->y == a_BlockY) && (itr->z == a_BlockZ))
{
return;
}
}
m_Blocks->push_back(Block);
m_TotalBlocks += 1;
ChunkData.push_back(cCoordWithInt(RelX, a_BlockY, RelZ));
}
bool cSandSimulator::IsPassable(BLOCKTYPE a_BlockType)
bool cSandSimulator::CanStartFallingThrough(BLOCKTYPE a_BlockType)
{
return (a_BlockType == E_BLOCK_AIR)
|| IsBlockWater(a_BlockType)
|| IsBlockLava(a_BlockType)
|| (a_BlockType == E_BLOCK_FIRE);
switch (a_BlockType)
{
case E_BLOCK_AIR:
case E_BLOCK_FIRE:
case E_BLOCK_WATER:
case E_BLOCK_STATIONARY_WATER:
case E_BLOCK_LAVA:
case E_BLOCK_STATIONARY_LAVA:
{
return true;
}
}
return false;
}
bool cSandSimulator::CanContinueFallThrough(BLOCKTYPE a_BlockType)
{
switch (a_BlockType)
{
case E_BLOCK_AIR:
case E_BLOCK_FIRE:
case E_BLOCK_WATER:
case E_BLOCK_STATIONARY_WATER:
case E_BLOCK_LAVA:
case E_BLOCK_STATIONARY_LAVA:
case E_BLOCK_POWERED_RAIL:
case E_BLOCK_DETECTOR_RAIL:
case E_BLOCK_COBWEB:
case E_BLOCK_TALL_GRASS:
case E_BLOCK_DEAD_BUSH:
case E_BLOCK_YELLOW_FLOWER:
case E_BLOCK_RED_ROSE:
case E_BLOCK_BROWN_MUSHROOM:
case E_BLOCK_RED_MUSHROOM:
case E_BLOCK_TORCH:
case E_BLOCK_REDSTONE_WIRE:
case E_BLOCK_CROPS:
case E_BLOCK_PUMPKIN_STEM:
case E_BLOCK_MELON_STEM:
case E_BLOCK_REDSTONE_TORCH_OFF:
case E_BLOCK_REDSTONE_TORCH_ON:
case E_BLOCK_STONE_BUTTON:
case E_BLOCK_STONE_PRESSURE_PLATE:
case E_BLOCK_WOODEN_BUTTON:
case E_BLOCK_WOODEN_PRESSURE_PLATE:
case E_BLOCK_REDSTONE_REPEATER_OFF:
case E_BLOCK_REDSTONE_REPEATER_ON:
{
return true;
}
}
return false;
}
bool cSandSimulator::IsReplacedOnRematerialization(BLOCKTYPE a_BlockType)
{
switch (a_BlockType)
{
case E_BLOCK_AIR:
case E_BLOCK_FIRE:
case E_BLOCK_WATER:
case E_BLOCK_STATIONARY_WATER:
case E_BLOCK_LAVA:
case E_BLOCK_STATIONARY_LAVA:
case E_BLOCK_TALL_GRASS:
case E_BLOCK_DEAD_BUSH:
{
return true;
}
}
return false;
}
bool cSandSimulator::DoesBreakFallingThrough(BLOCKTYPE a_BlockType)
{
switch (a_BlockType)
{
case E_BLOCK_STONE_SLAB:
case E_BLOCK_WOODEN_SLAB:
{
return true;
}
}
return false;
}
void cSandSimulator::FinishFalling(
cWorld * a_World, int a_BlockX, int a_BlockY, int a_BlockZ,
BLOCKTYPE a_FallingBlockType, NIBBLETYPE a_FallingBlockMeta
)
{
ASSERT(a_BlockY < cChunkDef::Height);
BLOCKTYPE CurrentBlockType = a_World->GetBlock(a_BlockX, a_BlockY, a_BlockZ);
if ((a_FallingBlockType == E_BLOCK_ANVIL) || IsReplacedOnRematerialization(CurrentBlockType))
{
// Rematerialize the material here:
a_World->SetBlock(a_BlockX, a_BlockY, a_BlockZ, a_FallingBlockType, a_FallingBlockMeta);
return;
}
// Create a pickup instead:
cItems Pickups;
Pickups.Add((ENUM_ITEM_ID)a_FallingBlockType, 1, a_FallingBlockMeta);
a_World->SpawnItemPickups(Pickups, (double)a_BlockX + 0.5, (double)a_BlockY + 0.5, (double)a_BlockZ + 0.5, 0);
}
void cSandSimulator::DoInstantFall(cChunk * a_Chunk, int a_RelX, int a_RelY, int a_RelZ)
{
// TODO
}

56
source/Simulator/SandSimulator.h
View File

@ -2,32 +2,62 @@
#pragma once
#include "Simulator.h"
#include "../BlockEntity.h"
#include "../Vector3i.h"
class cSandSimulator : public cSimulator
/// Despite the class name, this simulator takes care of all blocks that fall when suspended in the air.
class cSandSimulator :
public cSimulator
{
public:
cSandSimulator(cWorld & a_World);
~cSandSimulator();
cSandSimulator(cWorld & a_World, cIniFile & a_IniFile);
virtual void Simulate( float a_Dt ) override;
virtual bool IsAllowedBlock( BLOCKTYPE a_BlockType ) override;
virtual bool IsPassable( BLOCKTYPE a_BlockType );
// cSimulator overrides:
virtual void Simulate(float a_Dt) override {} // Unused in this simulator
virtual void SimulateChunk(float a_Dt, int a_ChunkX, int a_ChunkZ, cChunk * a_Chunk) override;
virtual bool IsAllowedBlock(BLOCKTYPE a_BlockType) override;
/// Returns true if a falling-able block can start falling through the specified block type
static bool CanStartFallingThrough(BLOCKTYPE a_BlockType);
/// Returns true if an already-falling block can pass through the specified block type (e. g. torch)
static bool CanContinueFallThrough(BLOCKTYPE a_BlockType);
/// Returns true if the falling block rematerializing will replace the specified block type (e. g. tall grass)
static bool IsReplacedOnRematerialization(BLOCKTYPE a_BlockType);
/// Returns true if the specified block breaks falling blocks while they fall through it (e. g. halfslabs)
static bool DoesBreakFallingThrough(BLOCKTYPE a_BlockType);
/** Called when a block finishes falling at the specified coords, either by insta-fall,
or through cFallingBlock entity.
It either rematerializes the block (a_FallingBlockType) at the specified coords, or creates a pickup,
based on the block currently present in the world at the dest specified coords
*/
static void FinishFalling(
cWorld * a_World, int a_BlockX, int a_BlockY, int a_BlockZ,
BLOCKTYPE a_FallingBlockType, NIBBLETYPE a_FallingBlockMeta
);
protected:
bool m_IsInstantFall; // If set to true, blocks don't fall using cFallingBlock entity, but instantly instead
int m_TotalBlocks; // Total number of blocks currently in the queue for simulating
virtual void AddBlock(int a_BlockX, int a_BlockY, int a_BlockZ, cChunk * a_Chunk) override;
typedef std::list <Vector3i> BlockList;
BlockList * m_Blocks;
BlockList * m_Buffer;
/// Performs the instant fall of the block - removes it from top, Finishes it at the bottom
void DoInstantFall(cChunk * a_Chunk, int a_RelX, int a_RelY, int a_RelZ);
};
/// Per-chunk data for the simulator, specified individual chunks to simulate; Data is not used
typedef cCoordWithIntList cSandSimulatorChunkData;

10
source/World.cpp
View File

@ -250,10 +250,10 @@ cWorld::cWorld(const AString & a_WorldName) :
m_BlockTickQueueCopy.reserve(1000);
// Simulators:
m_SimulatorManager = new cSimulatorManager(*this);
m_SimulatorManager = new cSimulatorManager(*this);
m_WaterSimulator = InitializeFluidSimulator(IniFile, "Water", E_BLOCK_WATER, E_BLOCK_STATIONARY_WATER);
m_LavaSimulator = InitializeFluidSimulator(IniFile, "Lava", E_BLOCK_LAVA, E_BLOCK_STATIONARY_LAVA);
m_SandSimulator = new cSandSimulator(*this);
m_SandSimulator = new cSandSimulator(*this, IniFile);
m_FireSimulator = new cFireSimulator(*this, IniFile);
m_RedstoneSimulator = new cRedstoneSimulator(*this);
@ -1166,9 +1166,9 @@ void cWorld::SpawnItemPickups(const cItems & a_Pickups, double a_BlockX, double
float SpeedY = (float)(a_FlyAwaySpeed * r1.randInt(1000));
float SpeedZ = (float)(a_FlyAwaySpeed * (r1.randInt(1000) - 500));
cPickup * Pickup = new cPickup(
(int)(a_BlockX * 32) + r1.randInt(16) + r1.randInt(16),
(int)(a_BlockY * 32) + r1.randInt(16) + r1.randInt(16),
(int)(a_BlockZ * 32) + r1.randInt(16) + r1.randInt(16),
(int)(a_BlockX * 32) + (r1.randInt(16) + r1.randInt(16) - 16),
(int)(a_BlockY * 32) + (r1.randInt(16) + r1.randInt(16) - 16),
(int)(a_BlockZ * 32) + (r1.randInt(16) + r1.randInt(16) - 16),
*itr, SpeedX, SpeedY, SpeedZ
);
Pickup->Initialize(this);

2
source/World.h
View File

@ -479,7 +479,7 @@ private:
bool m_IsDeepSnowEnabled;
// The cRedstone class simulates redstone and needs access to m_RSList
friend class cRedstone;
// friend class cRedstone;
std::vector<int> m_RSList;
std::vector<BlockTickQueueItem *> m_BlockTickQueue;