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

Moved growing from cWorld / cChunk to cBlockHandler descendants.

Browse Source
This commit is contained in:
Mattes D
2019-10-11 11:02:53 +02:00
parent f4bf025db9
commit 61904af626
42 changed files with 1527 additions and 1314 deletions
Download Patch File Download Diff File Expand all files Collapse all files

152
src/Blocks/BlockStems.h
View File

@@ -7,7 +7,11 @@
class cBlockStemsHandler :
/** Handler for stems from which produce grows in an adjacent block (melon, pumpkin) after it becomes ripe (meta == 7).
ProduceBlockType is the blocktype for the produce to be grown.
StemPickupType is the item type for the pickup resulting from breaking the stem. */
template <BLOCKTYPE ProduceBlockType, ENUM_ITEM_ID StemPickupType>
class cBlockStemsHandler:
public cBlockPlant<true>
{
using super = cBlockPlant<true>;
@@ -25,51 +29,143 @@ public:
virtual cItems ConvertToPickups(NIBBLETYPE a_BlockMeta, cBlockEntity * a_BlockEntity, const cEntity * a_Digger, const cItem * a_Tool) override
{
auto itemType = (m_BlockType == E_BLOCK_MELON_STEM) ? E_ITEM_MELON_SEEDS : E_ITEM_PUMPKIN_SEEDS;
return cItem(itemType, 1, 0);
return cItem(StemPickupType, 1, 0);
}
virtual void OnUpdate(cChunkInterface & cChunkInterface, cWorldInterface & a_WorldInterface, cBlockPluginInterface & a_PluginInterface, cChunk & a_Chunk, int a_RelX, int a_RelY, int a_RelZ) override
{
auto Action = CanGrow(a_Chunk, a_RelX, a_RelY, a_RelZ);
if (Action == paGrowth)
{
NIBBLETYPE Meta = a_Chunk.GetMeta(a_RelX, a_RelY, a_RelZ);
if (Meta >= 7)
{
// Grow the produce:
int BlockX = a_RelX + a_Chunk.GetPosX() * cChunkDef::Width;
int BlockZ = a_RelZ + a_Chunk.GetPosZ() * cChunkDef::Width;
a_Chunk.GetWorld()->GrowMelonPumpkin(BlockX, a_RelY, BlockZ, m_BlockType);
}
else
{
// Grow the stem:
a_Chunk.FastSetBlock(a_RelX, a_RelY, a_RelZ, m_BlockType, Meta + 1);
}
}
else if (Action == paDeath)
{
a_Chunk.GetWorld()->DigBlock(a_RelX + a_Chunk.GetPosX() * cChunkDef::Width, a_RelY, a_RelZ + a_Chunk.GetPosZ() * cChunkDef::Width);
}
}
virtual bool CanBeAt(cChunkInterface & a_ChunkInterface, int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
{
return ((a_RelY > 0) && (a_Chunk.GetBlock(a_RelX, a_RelY - 1, a_RelZ) == E_BLOCK_FARMLAND));
}
virtual ColourID GetMapBaseColourID(NIBBLETYPE a_Meta) override
{
UNUSED(a_Meta);
return 7;
}
virtual int Grow(cChunk & a_Chunk, Vector3i a_RelPos, int a_NumStages = 1) override
{
auto oldMeta = a_Chunk.GetMeta(a_RelPos);
auto meta = oldMeta + a_NumStages;
a_Chunk.SetBlock(a_RelPos, m_BlockType, static_cast<NIBBLETYPE>(std::min(meta, 7))); // Update the stem
if (meta > 7)
{
if (growProduce(a_Chunk, a_RelPos))
{
return 8 - oldMeta;
}
else
{
return 7 - oldMeta;
}
}
return meta - oldMeta;
}
protected:
/** Grows the final produce next to the stem at the specified pos.
Returns true if successful, false if not. */
bool growProduce(cChunk & a_Chunk, Vector3i a_StemRelPos)
{
auto & random = GetRandomProvider();
// Check if there's another produce around the stem, if so, abort:
static const Vector3i neighborOfs[] =
{
{ 1, 0, 0},
{-1, 0, 0},
{ 0, 0, 1},
{ 0, 0, -1},
};
bool isValid;
BLOCKTYPE blockType[4];
NIBBLETYPE blockMeta; // unused
isValid = a_Chunk.UnboundedRelGetBlock(a_StemRelPos + neighborOfs[0], blockType[0], blockMeta);
isValid = isValid && a_Chunk.UnboundedRelGetBlock(a_StemRelPos + neighborOfs[1], blockType[1], blockMeta);
isValid = isValid && a_Chunk.UnboundedRelGetBlock(a_StemRelPos + neighborOfs[2], blockType[2], blockMeta);
isValid = isValid && a_Chunk.UnboundedRelGetBlock(a_StemRelPos + neighborOfs[3], blockType[3], blockMeta);
if (
!isValid ||
(blockType[0] == ProduceBlockType) ||
(blockType[1] == ProduceBlockType) ||
(blockType[2] == ProduceBlockType) ||
(blockType[3] == ProduceBlockType)
)
{
// Neighbors not valid or already taken by the same produce
return false;
}
// Pick a direction in which to place the produce:
int x = 0, z = 0;
int checkType = random.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 false;
}
// Check if there's soil under the neighbor. We already know the neighbors are valid. Place produce if ok
BLOCKTYPE soilType;
auto produceRelPos = a_StemRelPos + Vector3i(x, 0, z);
VERIFY(a_Chunk.UnboundedRelGetBlock(produceRelPos.addedY(-1), soilType, blockMeta));
switch (soilType)
{
case E_BLOCK_DIRT:
case E_BLOCK_GRASS:
case E_BLOCK_FARMLAND:
{
// Place a randomly-facing produce:
NIBBLETYPE meta = (ProduceBlockType == E_BLOCK_MELON) ? 0 : static_cast<NIBBLETYPE>(random.RandInt(4) % 4);
auto produceAbsPos = a_Chunk.RelativeToAbsolute(produceRelPos);
FLOGD("Growing melon / pumpkin at {0} (<{1}, {2}> from stem), overwriting {3}, growing on top of {4}, meta {5}",
produceAbsPos,
x, z,
ItemTypeToString(blockType[checkType]),
ItemTypeToString(soilType),
meta
);
a_Chunk.GetWorld()->SetBlock(produceAbsPos, ProduceBlockType, meta);
return true;
}
}
return false;
}
} ;
using cBlockMelonStemHandler = cBlockStemsHandler<E_BLOCK_MELON, E_ITEM_MELON_SEEDS>;
using cBlockPumpkinStemHandler = cBlockStemsHandler<E_BLOCK_PUMPKIN, E_ITEM_PUMPKIN_SEEDS>;