299 lines
11 KiB
C++
299 lines
11 KiB
C++
#include "vf/NetherGen.h"
|
|
|
|
#include <cmath>
|
|
#include <cstdlib>
|
|
|
|
namespace vf {
|
|
|
|
namespace {
|
|
|
|
uint32_t mixCoord(uint32_t seed, int gx, int gy, int gz) {
|
|
uint64_t h = 1469598103934665603ull;
|
|
auto mix = [&h](uint32_t v) {
|
|
h ^= v;
|
|
h *= 1099511628211ull;
|
|
};
|
|
mix(seed);
|
|
mix(static_cast<uint32_t>(gx));
|
|
mix(static_cast<uint32_t>(gy));
|
|
mix(static_cast<uint32_t>(gz));
|
|
h ^= h >> 33;
|
|
return static_cast<uint32_t>(h ^ (h >> 32));
|
|
}
|
|
|
|
bool replaceable(Block block) {
|
|
return block == Block::Air || block == Block::Lava;
|
|
}
|
|
|
|
} // namespace
|
|
|
|
NetherGenerator::NetherGenerator() : NetherGenerator(Params{}) {}
|
|
|
|
NetherGenerator::NetherGenerator(const Params& netherParams)
|
|
: params(netherParams),
|
|
floorNoise(netherParams.seed ^ 0x4e455448u),
|
|
ceilingNoise(netherParams.seed ^ 0x524f4f46u),
|
|
caveNoise(netherParams.seed ^ 0x43415645u),
|
|
blobNoise(netherParams.seed ^ 0x424c4f42u),
|
|
oreNoise(netherParams.seed ^ 0x5155415au),
|
|
biomeNoise(netherParams.seed ^ 0x42494f4du) {}
|
|
|
|
NetherBiome NetherGenerator::biomeAt(int gx, int gz) const {
|
|
float f = params.biomeFrequency;
|
|
float heat = biomeNoise.simplex2D(gx * f, gz * f);
|
|
float damp = biomeNoise.simplex2D(gx * f * 1.7f + 91.3f, gz * f * 1.7f - 44.7f);
|
|
|
|
if (damp < -0.30f) return NetherBiome::SoulSandValley;
|
|
if (heat > 0.34f) return NetherBiome::BasaltDeltas;
|
|
if (damp > 0.26f) return NetherBiome::CrimsonForest;
|
|
return NetherBiome::NetherWastes;
|
|
}
|
|
|
|
NetherColumn NetherGenerator::columnAt(int gx, int gz) const {
|
|
NetherColumn column;
|
|
column.biome = biomeAt(gx, gz);
|
|
column.lavaLevel = params.lavaLevel;
|
|
|
|
float ff = params.floorFrequency;
|
|
float broad = floorNoise.fbm2D(gx * ff, gz * ff, 4, 2.0f, 0.5f);
|
|
float rough = floorNoise.noise2D(gx * ff * 3.1f + 17.0f, gz * ff * 3.1f - 9.0f);
|
|
|
|
int floorCentre = params.lavaLevel + 3;
|
|
float amplitude = 12.0f;
|
|
switch (column.biome) {
|
|
case NetherBiome::SoulSandValley:
|
|
floorCentre -= 8;
|
|
amplitude = 15.0f;
|
|
break;
|
|
case NetherBiome::BasaltDeltas:
|
|
floorCentre -= 3;
|
|
amplitude = 9.0f;
|
|
break;
|
|
case NetherBiome::CrimsonForest:
|
|
floorCentre += 4;
|
|
amplitude = 8.0f;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
float shaped = broad * 0.78f + rough * 0.22f;
|
|
column.floorHeight = floorCentre + static_cast<int>(std::lround(shaped * amplitude));
|
|
|
|
float cf = params.ceilingFrequency;
|
|
float roof = ceilingNoise.fbm2D(gx * cf, gz * cf, 3, 2.0f, 0.5f);
|
|
column.ceilingHeight = params.ceilingY - params.roofThickness +
|
|
static_cast<int>(std::lround(roof * 7.0f));
|
|
|
|
int lowest = params.floorY + params.bedrockThickness + 1;
|
|
int highest = params.ceilingY - params.bedrockThickness - 2;
|
|
if (column.floorHeight < lowest) column.floorHeight = lowest;
|
|
if (column.floorHeight > highest - 12) column.floorHeight = highest - 12;
|
|
if (column.ceilingHeight > highest) column.ceilingHeight = highest;
|
|
if (column.ceilingHeight < column.floorHeight + 10) column.ceilingHeight = column.floorHeight + 10;
|
|
|
|
column.drowned = column.floorHeight < params.lavaLevel;
|
|
return column;
|
|
}
|
|
|
|
bool NetherGenerator::isCarved(int gx, int gy, int gz) const {
|
|
float f = params.caveFrequency;
|
|
float first = 1.0f - std::fabs(caveNoise.noise3D(gx * f, gy * f * 1.9f, gz * f));
|
|
float second = 1.0f - std::fabs(caveNoise.noise3D(gx * f + 41.3f, gy * f * 1.9f - 17.9f,
|
|
gz * f + 23.1f));
|
|
return first > params.caveThreshold && second > params.caveThreshold;
|
|
}
|
|
|
|
bool NetherGenerator::isBlob(int gx, int gy, int gz) const {
|
|
float broad = blobNoise.noise3D(gx * 0.026f, gy * 0.019f, gz * 0.026f);
|
|
float detail = blobNoise.noise3D(gx * 0.056f + 7.3f, gy * 0.048f - 3.1f, gz * 0.056f + 2.7f);
|
|
return broad + detail * 0.42f > params.blobThreshold;
|
|
}
|
|
|
|
bool NetherGenerator::isBedrock(int gx, int gy, int gz) const {
|
|
if (gy == params.floorY || gy == params.ceilingY - 1) return true;
|
|
|
|
int fromFloor = gy - params.floorY;
|
|
int fromCeiling = params.ceilingY - 1 - gy;
|
|
int band = -1;
|
|
if (fromFloor > 0 && fromFloor < params.bedrockThickness) band = fromFloor;
|
|
else if (fromCeiling > 0 && fromCeiling < params.bedrockThickness) band = fromCeiling;
|
|
if (band < 0) return false;
|
|
|
|
uint32_t roll = mixCoord(params.seed ^ 0x42454452u, gx, gy, gz);
|
|
return static_cast<int>(roll % static_cast<uint32_t>(params.bedrockThickness)) >= band;
|
|
}
|
|
|
|
Block NetherGenerator::topFor(NetherBiome biome) const {
|
|
switch (biome) {
|
|
case NetherBiome::SoulSandValley: return Block::SoulSand;
|
|
case NetherBiome::BasaltDeltas: return Block::Basalt;
|
|
case NetherBiome::CrimsonForest: return Block::Moss;
|
|
default: return Block::Netherrack;
|
|
}
|
|
}
|
|
|
|
Block NetherGenerator::fillerFor(NetherBiome biome) const {
|
|
switch (biome) {
|
|
case NetherBiome::SoulSandValley: return Block::SoulSoil;
|
|
case NetherBiome::BasaltDeltas: return Block::Blackstone;
|
|
default: return Block::Netherrack;
|
|
}
|
|
}
|
|
|
|
Block NetherGenerator::blockAt(const NetherColumn& column, int gx, int gy, int gz) const {
|
|
if (gy < params.floorY || gy >= params.ceilingY) return Block::Air;
|
|
if (isBedrock(gx, gy, gz)) return Block::Bedrock;
|
|
|
|
bool inMass = gy <= column.floorHeight || gy >= column.ceilingHeight;
|
|
bool solid = inMass || isBlob(gx, gy, gz);
|
|
if (solid && isCarved(gx, gy, gz)) solid = false;
|
|
if (!solid) return gy <= params.lavaLevel ? Block::Lava : Block::Air;
|
|
|
|
Block material = Block::Netherrack;
|
|
if (gy <= column.floorHeight) {
|
|
int depth = column.floorHeight - gy;
|
|
if (depth == 0) material = topFor(column.biome);
|
|
else if (depth <= 3) material = fillerFor(column.biome);
|
|
}
|
|
|
|
float qf = params.quartzFrequency;
|
|
float vein = oreNoise.noise3D(gx * qf, gy * qf, gz * qf);
|
|
if (material == Block::Netherrack) {
|
|
if (vein > params.quartzThreshold) material = Block::NetherQuartzOre;
|
|
else if (vein < -0.78f && column.biome == NetherBiome::BasaltDeltas)
|
|
material = Block::Blackstone;
|
|
}
|
|
|
|
if (gy >= column.ceilingHeight && gy <= column.ceilingHeight + 2) {
|
|
float glow = oreNoise.noise3D(gx * 0.09f + 53.1f, gy * 0.09f - 21.7f, gz * 0.09f + 11.9f);
|
|
if (glow > 0.66f) material = Block::Glowstone;
|
|
}
|
|
|
|
if (gy >= column.floorHeight - 1 && gy <= column.floorHeight &&
|
|
gy >= params.lavaLevel - 1 && gy <= params.lavaLevel + 2 && vein > 0.30f) {
|
|
material = Block::Magma;
|
|
}
|
|
|
|
return material;
|
|
}
|
|
|
|
void NetherGenerator::generateChunk(Chunk& chunk, const Vec3i& chunkCoord) const {
|
|
int ox = chunkCoord.x * chunkSize;
|
|
int oy = chunkCoord.y * chunkSize;
|
|
int oz = chunkCoord.z * chunkSize;
|
|
|
|
for (int lx = 0; lx < chunkSize; ++lx) {
|
|
for (int lz = 0; lz < chunkSize; ++lz) {
|
|
NetherColumn column = columnAt(ox + lx, oz + lz);
|
|
for (int ly = 0; ly < chunkSize; ++ly)
|
|
chunk.set(lx, ly, lz, blockAt(column, ox + lx, oy + ly, oz + lz));
|
|
}
|
|
}
|
|
}
|
|
|
|
void NetherGenerator::generateColumn(World& world, int columnX, int columnZ) const {
|
|
for (int cy = 0; cy < stackChunkCount(); ++cy) {
|
|
Chunk& chunk = world.ensureChunk({columnX, cy, columnZ});
|
|
generateChunk(chunk, {columnX, cy, columnZ});
|
|
}
|
|
if (params.decorate) decorateColumn(world, columnX, columnZ);
|
|
}
|
|
|
|
void NetherGenerator::raiseBasaltPillar(World& world, int gx, int gz, const NetherColumn& column,
|
|
uint32_t roll) const {
|
|
int base = column.floorHeight + 1;
|
|
if (base <= params.lavaLevel) base = params.lavaLevel + 1;
|
|
int tall = 3 + static_cast<int>((roll >> 4) % 10u);
|
|
int top = base + tall;
|
|
if (top >= column.ceilingHeight) top = column.ceilingHeight - 1;
|
|
|
|
for (int y = base; y <= top; ++y) {
|
|
if (!replaceable(world.blockAt(gx, y, gz))) break;
|
|
world.setBlock(gx, y, gz, Block::Basalt);
|
|
}
|
|
if ((roll & 3u) == 0u && replaceable(world.blockAt(gx, base - 1, gz)))
|
|
world.setBlock(gx, base - 1, gz, Block::Magma);
|
|
}
|
|
|
|
void NetherGenerator::pourLavafall(World& world, int gx, int gz, const NetherColumn& column) const {
|
|
int start = column.ceilingHeight - 1;
|
|
for (int y = start; y > params.lavaLevel; --y) {
|
|
if (world.blockAt(gx, y, gz) != Block::Air) break;
|
|
world.setBlock(gx, y, gz, Block::Lava);
|
|
}
|
|
if (world.blockAt(gx, start + 1, gz) == Block::Netherrack)
|
|
world.setBlock(gx, start + 1, gz, Block::Magma);
|
|
}
|
|
|
|
void NetherGenerator::hangGlowstone(World& world, int gx, int gz, const NetherColumn& column,
|
|
uint32_t roll) const {
|
|
int drop = 1 + static_cast<int>((roll >> 6) % 3u);
|
|
int spread = static_cast<int>((roll >> 9) % 2u);
|
|
|
|
for (int dx = -spread; dx <= spread; ++dx) {
|
|
for (int dz = -spread; dz <= spread; ++dz) {
|
|
int reach = drop - (std::abs(dx) + std::abs(dz));
|
|
for (int step = 0; step < reach; ++step) {
|
|
int y = column.ceilingHeight - 1 - step;
|
|
if (world.blockAt(gx + dx, y, gz + dz) != Block::Air) break;
|
|
world.setBlock(gx + dx, y, gz + dz, Block::Glowstone);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void NetherGenerator::plantFungus(World& world, int gx, int gz, const NetherColumn& column,
|
|
uint32_t roll) const {
|
|
int base = column.floorHeight + 1;
|
|
if (base <= params.lavaLevel) return;
|
|
if (world.blockAt(gx, base - 1, gz) != Block::Moss) return;
|
|
|
|
int stem = 3 + static_cast<int>((roll >> 12) % 5u);
|
|
int top = base + stem - 1;
|
|
if (top + 1 >= column.ceilingHeight) return;
|
|
|
|
for (int y = base; y <= top; ++y) {
|
|
if (world.blockAt(gx, y, gz) != Block::Air) return;
|
|
world.setBlock(gx, y, gz, Block::Wood);
|
|
}
|
|
for (int dx = -1; dx <= 1; ++dx) {
|
|
for (int dz = -1; dz <= 1; ++dz) {
|
|
if (std::abs(dx) + std::abs(dz) > 1) continue;
|
|
if (world.blockAt(gx + dx, top + 1, gz + dz) == Block::Air)
|
|
world.setBlock(gx + dx, top + 1, gz + dz, Block::Leaves);
|
|
}
|
|
}
|
|
}
|
|
|
|
void NetherGenerator::decorateColumn(World& world, int columnX, int columnZ) const {
|
|
int ox = columnX * chunkSize;
|
|
int oz = columnZ * chunkSize;
|
|
|
|
for (int lx = 3; lx < chunkSize - 3; ++lx) {
|
|
for (int lz = 3; lz < chunkSize - 3; ++lz) {
|
|
int gx = ox + lx;
|
|
int gz = oz + lz;
|
|
NetherColumn column = columnAt(gx, gz);
|
|
uint32_t roll = mixCoord(params.seed ^ 0x4445434fu, gx, 0, gz);
|
|
|
|
if (roll % 27u == 0u) hangGlowstone(world, gx, gz, column, roll);
|
|
|
|
switch (column.biome) {
|
|
case NetherBiome::BasaltDeltas:
|
|
if ((roll >> 3) % 23u == 0u) raiseBasaltPillar(world, gx, gz, column, roll);
|
|
break;
|
|
case NetherBiome::CrimsonForest:
|
|
if ((roll >> 3) % 17u == 0u) plantFungus(world, gx, gz, column, roll);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if ((roll >> 7) % 97u == 0u) pourLavafall(world, gx, gz, column);
|
|
}
|
|
}
|
|
}
|
|
|
|
} // namespace vf
|