public bool Generate(IBlockManager blockMan, Random rand, int x, int y, int z)
{
float rpi = (float)(rand.NextDouble() * Math.PI);
double x1 = x + 8 + MathHelper.Sin(rpi) * _size / 8.0F;
double x2 = x + 8 - MathHelper.Sin(rpi) * _size / 8.0F;
double z1 = z + 8 + MathHelper.Cos(rpi) * _size / 8.0F;
double z2 = z + 8 - MathHelper.Cos(rpi) * _size / 8.0F;
double y1 = y + rand.Next(3) + 2;
double y2 = y + rand.Next(3) + 2;
for (int i = 0; i <= _size; i++)
{
double xPos = x1 + (x2 - x1) * i / _size;
double yPos = y1 + (y2 - y1) * i / _size;
double zPos = z1 + (z2 - z1) * i / _size;
double fuzz = rand.NextDouble() * _size / 16.0D;
double fuzzXZ = (MathHelper.Sin((float)(i * Math.PI / _size)) + 1.0F) * fuzz + 1.0D;
double fuzzY = (MathHelper.Sin((float)(i * Math.PI / _size)) + 1.0F) * fuzz + 1.0D;
int xStart, yStart, zStart, xEnd, yEnd, zEnd;
if (_mathFix)
{
xStart = (int)Math.Floor(xPos - fuzzXZ / 2.0D);
yStart = (int)Math.Floor(yPos - fuzzY / 2.0D);
zStart = (int)Math.Floor(zPos - fuzzXZ / 2.0D);
xEnd = (int)Math.Floor(xPos + fuzzXZ / 2.0D);
yEnd = (int)Math.Floor(yPos + fuzzY / 2.0D);
zEnd = (int)Math.Floor(zPos + fuzzXZ / 2.0D);
}
else
{
xStart = (int)(xPos - fuzzXZ / 2.0D);
yStart = (int)(yPos - fuzzY / 2.0D);
zStart = (int)(zPos - fuzzXZ / 2.0D);
xEnd = (int)(xPos + fuzzXZ / 2.0D);
yEnd = (int)(yPos + fuzzY / 2.0D);
zEnd = (int)(zPos + fuzzXZ / 2.0D);
}
for (int ix = xStart; ix <= xEnd; ix++)
{
double xThresh = (ix + 0.5D - xPos) / (fuzzXZ / 2.0D);
if (xThresh * xThresh < 1.0D)
{
for (int iy = yStart; iy <= yEnd; iy++)
{
double yThresh = (iy + 0.5D - yPos) / (fuzzY / 2.0D);
if (xThresh * xThresh + yThresh * yThresh < 1.0D)
{
for (int iz = zStart; iz <= zEnd; iz++)
{
double zThresh = (iz + 0.5D - zPos) / (fuzzXZ / 2.0D);
if (xThresh * xThresh + yThresh * yThresh + zThresh * zThresh < 1.0D)
{
AlphaBlockRef block = blockMan.GetBlockRef(ix, iy, iz);
if (block.IsValid)
{
block.ID = _blockId;
block.Data = _blockData;
}
}
}
}
}
}
}
}
return(true);
}
public void ApplyChunk(NbtWorld world, ChunkRef chunk)
{
IBlockFilter opt_b = opt.GetBlockFilter();
//chunk.Blocks.AutoLight = false;
//chunk.Blocks.AutoTileTick = false;
int xBase = chunk.X * chunk.Blocks.XDim;
int zBase = chunk.Z * chunk.Blocks.ZDim;
// Determine X range
int xmin = 0;
int xmax = 15;
if (opt_b.XAboveEq != null)
{
xmin = (int)opt_b.XAboveEq - xBase;
}
if (opt_b.XBelowEq != null)
{
xmax = (int)opt_b.XBelowEq - xBase;
}
xmin = (xmin < 0) ? 0 : xmin;
xmax = (xmax > 15) ? 15 : xmax;
if (xmin > 15 || xmax < 0 || xmin > xmax)
{
return;
}
// Determine Y range
int ymin = 0;
int ymax = 127;
if (opt_b.YAboveEq != null)
{
ymin = (int)opt_b.YAboveEq;
}
if (opt_b.YBelowEq != null)
{
ymax = (int)opt_b.YBelowEq;
}
if (ymin > ymax)
{
return;
}
// Determine X range
int zmin = 0;
int zmax = 15;
if (opt_b.ZAboveEq != null)
{
zmin = (int)opt_b.ZAboveEq - zBase;
}
if (opt_b.ZBelowEq != null)
{
zmax = (int)opt_b.ZBelowEq - zBase;
}
zmin = (zmin < 0) ? 0 : zmin;
zmax = (zmax > 15) ? 15 : zmax;
if (zmin > 15 || zmax < 0 || zmin > zmax)
{
return;
}
int xdim = chunk.Blocks.XDim;
int ydim = chunk.Blocks.YDim;
int zdim = chunk.Blocks.ZDim;
// Bin blocks
for (int y = ymin; y <= ymax; y++)
{
for (int x = xmin; x <= xmax; x++)
{
for (int z = zmin; z <= zmax; z++)
{
int id = chunk.Blocks.GetID(x, y, z);
if (!_sort.ContainsKey(id))
{
_sort[id] = new List <BlockKey>();
}
_sort[id].Add(new BlockKey(x, y, z));
}
}
}
// Process bins
//for (int i = 0; i < maxBin; i++) {
foreach (var kv in _sort)
{
if (kv.Value.Count == 0)
{
continue;
}
if (opt_b.IncludedBlockCount > 0)
{
if (!opt_b.IncludedBlocksContains(kv.Key))
{
bool found = false;
foreach (var range in opt_b.IncludedBlockRanges)
{
if (kv.Key >= range.Key && kv.Key <= range.Value)
{
found = true;
}
}
if (!found)
{
continue;
}
}
}
if (opt_b.ExcludedBlockCount > 0)
{
if (opt_b.ExcludedBlocksContains(kv.Key))
{
continue;
}
foreach (var range in opt_b.ExcludedBlockRanges)
{
if (kv.Key >= range.Key && kv.Key <= range.Value)
{
continue;
}
}
}
if (opt_b.IncludedBlockCount > 0 & !opt_b.IncludedBlocksContains(kv.Key))
{
continue;
}
if (opt_b.ExcludedBlockCount > 0 & opt_b.ExcludedBlocksContains(kv.Key))
{
continue;
}
foreach (BlockKey key in kv.Value)
{
// Probability test
if (opt_b.ProbMatch != null)
{
double c = rand.NextDouble();
if (c > opt_b.ProbMatch)
{
continue;
}
}
if (opt_b.BlocksAboveCount > 0 && key.y < ydim - 1)
{
int neighborId = chunk.Blocks.GetID(key.x, key.y + 1, key.z);
if (!opt_b.BlocksAboveContains(neighborId))
{
continue;
}
}
if (opt_b.BlocksBelowCount > 0 && key.y > 0)
{
int neighborId = chunk.Blocks.GetID(key.x, key.y - 1, key.z);
if (!opt_b.BlocksBelowContains(neighborId))
{
continue;
}
}
if (opt_b.BlocksSideCount > 0)
{
bool validNeighbor = false;
AlphaBlockRef block1 = GetNeighborBlock(chunk, key.x - 1, key.y, key.z);
if (block1.IsValid && opt_b.BlocksSideContains(block1.ID) && !validNeighbor)
{
validNeighbor = true;
}
AlphaBlockRef block2 = GetNeighborBlock(chunk, key.x + 1, key.y, key.z);
if (block2.IsValid && opt_b.BlocksSideContains(block2.ID) && !validNeighbor)
{
validNeighbor = true;
}
AlphaBlockRef block3 = GetNeighborBlock(chunk, key.x, key.y, key.z - 1);
if (block3.IsValid && opt_b.BlocksSideContains(block3.ID) && !validNeighbor)
{
validNeighbor = true;
}
AlphaBlockRef block4 = GetNeighborBlock(chunk, key.x, key.y, key.z + 1);
if (block4.IsValid && opt_b.BlocksSideContains(block4.ID) && !validNeighbor)
{
validNeighbor = true;
}
if (!validNeighbor)
{
continue;
}
}
if (opt_b.BlocksNAboveCount > 0 && key.y < ydim - 1)
{
int neighborId = chunk.Blocks.GetID(key.x, key.y + 1, key.z);
if (opt_b.BlocksNAboveContains(neighborId))
{
continue;
}
}
if (opt_b.BlocksNBelowCount > 0 && key.y > 0)
{
int neighborId = chunk.Blocks.GetID(key.x, key.y - 1, key.z);
if (opt_b.BlocksNBelowContains(neighborId))
{
continue;
}
}
if (opt_b.BlocksNSideCount > 0)
{
AlphaBlockRef block1 = GetNeighborBlock(chunk, key.x - 1, key.y, key.z);
if (block1.IsValid && opt_b.BlocksNSideContains(block1.ID))
{
continue;
}
AlphaBlockRef block2 = GetNeighborBlock(chunk, key.x + 1, key.y, key.z);
if (block2.IsValid && opt_b.BlocksNSideContains(block2.ID))
{
continue;
}
AlphaBlockRef block3 = GetNeighborBlock(chunk, key.x, key.y, key.z - 1);
if (block3.IsValid && opt_b.BlocksNSideContains(block3.ID))
{
continue;
}
AlphaBlockRef block4 = GetNeighborBlock(chunk, key.x, key.y, key.z + 1);
if (block4.IsValid && opt_b.BlocksNSideContains(block4.ID))
{
continue;
}
}
if (opt_b.IncludedDataCount > 0 || opt_b.ExcludedDataCount > 0)
{
int data = chunk.Blocks.GetData(key.x, key.y, key.z);
if (opt_b.IncludedDataCount > 0 && !opt_b.IncludedDataContains(data))
{
continue;
}
if (opt_b.ExcludedDataCount > 0 && opt_b.ExcludedDataContains(data))
{
continue;
}
}
chunk.Blocks.SetID(key.x, key.y, key.z, (int)opt.OPT_AFTER);
if (opt.OPT_VV)
{
int gx = chunk.X * xdim + key.x;
int gz = chunk.Z * zdim + key.z;
Console.WriteLine("Replaced block {0} at {1},{2},{3}", kv.Key, gx, key.y, gz);
}
if (opt.OPT_DATA != null)
{
chunk.Blocks.SetData(key.x, key.y, key.z, (int)opt.OPT_DATA);
}
}
}
// Reset bins
_sort.Clear();
// Process Chunk
/*for (int y = ymin; y <= ymax; y++) {
* for (int x = xmin; x <= xmax; x++) {
* for (int z = zmin; z <= zmax; z++) {
* // Probability test
* if (opt_b.ProbMatch != null) {
* double c = rand.NextDouble();
* if (c > opt_b.ProbMatch) {
* continue;
* }
* }
*
* int lx = x % xdim;
* int ly = y % ydim;
* int lz = z % zdim;
*
* // Get the old block
* int oldBlock = chunk.Blocks.GetID(lx , ly, lz);
*
* // Skip block if it doesn't match the inclusion list
* if (opt_b.IncludedBlockCount > 0) {
* bool match = false;
* foreach (int ib in opt_b.IncludedBlocks) {
* if (oldBlock == ib) {
* match = true;
* break;
* }
* }
*
* if (!match) {
* continue;
* }
* }
*
* // Skip block if it does match the exclusion list
* if (opt_b.ExcludedBlockCount > 0) {
* bool match = false;
* foreach (int xb in opt_b.ExcludedBlocks) {
* if (oldBlock == xb) {
* match = true;
* break;
* }
* }
*
* if (match) {
* continue;
* }
* }
*
* // Replace the block
* chunk.Blocks.SetID(lx, ly, lz, (int)opt.OPT_AFTER);
*
* if (opt.OPT_VV) {
* int gx = chunk.X * xdim + lx;
* int gz = chunk.Z * zdim + lz;
* Console.WriteLine("Replaced block at {0},{1},{2}", gx, ly, gz);
* }
*
* if (opt.OPT_DATA != null) {
* chunk.Blocks.SetData(lx, ly, lz, (int)opt.OPT_DATA);
* }
* }
* }
* }*/
}
private bool CheckBlockFilter(int x, int y, int z, int blockId)
{
IBlockFilter opt_b = opt.GetBlockFilter();
if (!opt_b.InvertXYZ)
{
if (opt_b.XAboveEq != null && x < opt_b.XAboveEq)
{
return(false);
}
if (opt_b.XBelowEq != null && x > opt_b.XBelowEq)
{
return(false);
}
if (opt_b.YAboveEq != null && y < opt_b.YAboveEq)
{
return(false);
}
if (opt_b.YBelowEq != null && y > opt_b.YBelowEq)
{
return(false);
}
if (opt_b.ZAboveEq != null && z < opt_b.ZAboveEq)
{
return(false);
}
if (opt_b.ZBelowEq != null && z > opt_b.ZBelowEq)
{
return(false);
}
}
else
{
if (opt_b.XAboveEq != null && opt_b.XBelowEq != null &&
opt_b.YAboveEq != null && opt_b.YBelowEq != null &&
opt_b.ZAboveEq != null && opt_b.ZBelowEq != null &&
x > opt_b.XAboveEq && x < opt_b.XBelowEq &&
y > opt_b.YAboveEq && y < opt_b.YBelowEq &&
z > opt_b.ZAboveEq && z < opt_b.ZBelowEq)
{
return(false);
}
}
if (opt_b.IncludedBlockCount > 0)
{
if (!opt_b.IncludedBlocksContains(blockId))
{
bool found = false;
foreach (var range in opt_b.IncludedBlockRanges)
{
if (blockId >= range.Key && blockId <= range.Value)
{
found = true;
}
}
if (!found)
{
return(false);
}
}
}
if (opt_b.ExcludedBlockCount > 0)
{
if (opt_b.ExcludedBlocksContains(blockId))
{
return(false);
}
foreach (var range in opt_b.ExcludedBlockRanges)
{
if (blockId >= range.Key && blockId <= range.Value)
{
return(false);
}
}
}
if (opt_b.BlocksAboveCount > 0 && y < chunkYDim - 1)
{
int neighborId = cache.Blocks.GetID(x & chunkXMask, (y + 1) & chunkYMask, z & chunkZMask);
if (!opt_b.BlocksAboveContains(neighborId))
{
return(false);
}
}
if (opt_b.BlocksBelowCount > 0 && y > 0)
{
int neighborId = cache.Blocks.GetID(x & chunkXMask, (y - 1) & chunkYMask, z & chunkZMask);
if (!opt_b.BlocksBelowContains(neighborId))
{
return(false);
}
}
if (opt_b.BlocksSideCount > 0)
{
while (true)
{
AlphaBlockRef block1 = GetBlockRefUnchecked(x - 1, y, z);
if (block1.IsValid && opt_b.BlocksSideContains(block1.ID))
{
break;
}
AlphaBlockRef block2 = GetBlockRefUnchecked(x + 1, y, z);
if (block2.IsValid && opt_b.BlocksSideContains(block2.ID))
{
break;
}
AlphaBlockRef block3 = GetBlockRefUnchecked(x, y, z - 1);
if (block3.IsValid && opt_b.BlocksSideContains(block3.ID))
{
break;
}
AlphaBlockRef block4 = GetBlockRefUnchecked(x, y, z + 1);
if (block4.IsValid && opt_b.BlocksSideContains(block4.ID))
{
break;
}
return(false);
}
}
if (opt_b.BlocksNAboveCount > 0 && y < chunkYDim - 1)
{
int neighborId = cache.Blocks.GetID(x & chunkXMask, (y + 1) & chunkYMask, z & chunkZMask);
if (opt_b.BlocksNAboveContains(neighborId))
{
return(false);
}
}
if (opt_b.BlocksNBelowCount > 0 && y > 0)
{
int neighborId = cache.Blocks.GetID(x & chunkXMask, (y - 1) & chunkYMask, z & chunkZMask);
if (opt_b.BlocksNBelowContains(neighborId))
{
return(false);
}
}
if (opt_b.BlocksNSideCount > 0)
{
while (true)
{
AlphaBlockRef block1 = GetBlockRefUnchecked(x - 1, y, z);
if (block1.IsValid && opt_b.BlocksNSideContains(block1.ID))
{
return(false);
}
AlphaBlockRef block2 = GetBlockRefUnchecked(x + 1, y, z);
if (block2.IsValid && opt_b.BlocksNSideContains(block2.ID))
{
return(false);
}
AlphaBlockRef block3 = GetBlockRefUnchecked(x, y, z - 1);
if (block3.IsValid && opt_b.BlocksNSideContains(block3.ID))
{
return(false);
}
AlphaBlockRef block4 = GetBlockRefUnchecked(x, y, z + 1);
if (block4.IsValid && opt_b.BlocksNSideContains(block4.ID))
{
return(false);
}
break;
}
}
if (opt_b.ProbMatch != null)
{
double c = rand.NextDouble();
if (c > opt_b.ProbMatch)
{
return(false);
}
}
if (opt_b.IncludedDataCount > 0 || opt_b.ExcludedDataCount > 0)
{
int data = cache.Blocks.GetData(x & chunkXMask, y & chunkYMask, z & chunkZMask);
if (opt_b.IncludedDataCount > 0 && !opt_b.IncludedDataContains(data))
{
return(false);
}
if (opt_b.ExcludedDataCount > 0 && opt_b.ExcludedDataContains(data))
{
return(false);
}
}
return(true);
}
