133 lines
4.4 KiB
C++
133 lines
4.4 KiB
C++
#include "vf/Structures.h"
|
|
|
|
#include <cstdlib>
|
|
|
|
namespace vf {
|
|
|
|
namespace {
|
|
|
|
struct Rng {
|
|
uint32_t state;
|
|
uint32_t next() {
|
|
state ^= state << 13;
|
|
state ^= state >> 17;
|
|
state ^= state << 5;
|
|
return state;
|
|
}
|
|
int range(int lo, int hi) { return lo + static_cast<int>(next() % static_cast<uint32_t>(hi - lo + 1)); }
|
|
bool chance(int percent) { return static_cast<int>(next() % 100u) < percent; }
|
|
};
|
|
|
|
void addTrunk(std::vector<StructureEdit>& edits, int height) {
|
|
for (int y = 0; y < height; ++y) edits.push_back({{0, y, 0}, Block::Wood});
|
|
}
|
|
|
|
std::vector<StructureEdit> buildOak(Rng& rng) {
|
|
std::vector<StructureEdit> edits;
|
|
int trunk = rng.range(4, 6);
|
|
addTrunk(edits, trunk);
|
|
|
|
int canopyBottom = trunk - 2;
|
|
for (int dy = 0; dy <= 2; ++dy) {
|
|
int radius = dy == 2 ? 1 : 2;
|
|
int y = canopyBottom + dy;
|
|
for (int dx = -radius; dx <= radius; ++dx) {
|
|
for (int dz = -radius; dz <= radius; ++dz) {
|
|
if (dx == 0 && dz == 0 && y < trunk) continue; // trunk occupies the core
|
|
int manhattan = std::abs(dx) + std::abs(dz);
|
|
if (manhattan > radius + (dy == 0 ? 1 : 0)) continue;
|
|
if (manhattan == radius + 1 && rng.chance(50)) continue; // ragged edge
|
|
edits.push_back({{dx, y, dz}, Block::Leaves});
|
|
}
|
|
}
|
|
}
|
|
edits.push_back({{0, trunk, 0}, Block::Leaves}); // crown
|
|
return edits;
|
|
}
|
|
|
|
std::vector<StructureEdit> buildPine(Rng& rng) {
|
|
std::vector<StructureEdit> edits;
|
|
int trunk = rng.range(6, 9);
|
|
addTrunk(edits, trunk);
|
|
|
|
for (int y = 2; y <= trunk; ++y) {
|
|
int fromTop = trunk - y;
|
|
int radius = fromTop >= 3 ? 2 : (fromTop >= 1 ? 1 : 0);
|
|
for (int dx = -radius; dx <= radius; ++dx)
|
|
for (int dz = -radius; dz <= radius; ++dz) {
|
|
if (std::abs(dx) + std::abs(dz) > radius) continue;
|
|
if (dx == 0 && dz == 0 && y < trunk) continue;
|
|
edits.push_back({{dx, y, dz}, Block::Leaves});
|
|
}
|
|
}
|
|
edits.push_back({{0, trunk + 1, 0}, Block::Leaves}); // tip
|
|
return edits;
|
|
}
|
|
|
|
std::vector<StructureEdit> buildHut(Rng& rng) {
|
|
std::vector<StructureEdit> edits;
|
|
int height = rng.range(3, 4);
|
|
const int half = 2;
|
|
|
|
for (int dx = -half; dx <= half; ++dx)
|
|
for (int dz = -half; dz <= half; ++dz)
|
|
edits.push_back({{dx, 0, dz}, Block::Wood}); // floor
|
|
|
|
for (int y = 1; y <= height; ++y)
|
|
for (int dx = -half; dx <= half; ++dx)
|
|
for (int dz = -half; dz <= half; ++dz) {
|
|
bool perimeter = std::abs(dx) == half || std::abs(dz) == half;
|
|
if (!perimeter) continue;
|
|
bool door = dx == 0 && dz == -half && y <= 2; // doorway on the -z wall
|
|
if (door) continue;
|
|
edits.push_back({{dx, y, dz}, Block::Wood});
|
|
}
|
|
|
|
for (int dx = -half; dx <= half; ++dx)
|
|
for (int dz = -half; dz <= half; ++dz)
|
|
edits.push_back({{dx, height + 1, dz}, Block::Leaves}); // thatched roof
|
|
|
|
edits.push_back({{0, height, 0}, Block::Glowstone}); // lantern (distinct marker)
|
|
(void)rng;
|
|
return edits;
|
|
}
|
|
|
|
} // namespace
|
|
|
|
uint32_t structureHash(uint32_t seed, int x, int y, int z) {
|
|
uint32_t h = seed * 2654435761u;
|
|
h ^= static_cast<uint32_t>(x) * 0x9e3779b9u;
|
|
h = (h << 13) | (h >> 19);
|
|
h ^= static_cast<uint32_t>(y) * 0x85ebca6bu;
|
|
h = (h << 7) | (h >> 25);
|
|
h ^= static_cast<uint32_t>(z) * 0xc2b2ae35u;
|
|
h ^= h >> 16;
|
|
h *= 0x7feb352du;
|
|
h ^= h >> 15;
|
|
return h;
|
|
}
|
|
|
|
std::vector<StructureEdit> buildStructure(StructureKind kind, uint32_t seed) {
|
|
Rng rng{seed ? seed : 0x9e3779b9u};
|
|
switch (kind) {
|
|
case StructureKind::OakTree: return buildOak(rng);
|
|
case StructureKind::PineTree: return buildPine(rng);
|
|
case StructureKind::Hut: return buildHut(rng);
|
|
}
|
|
return {};
|
|
}
|
|
|
|
void stampStructure(World& world, const Vec3i& base, const std::vector<StructureEdit>& edits,
|
|
int maxY) {
|
|
for (const StructureEdit& edit : edits) {
|
|
int gx = base.x + edit.offset.x;
|
|
int gy = base.y + edit.offset.y;
|
|
int gz = base.z + edit.offset.z;
|
|
if (gy < 0 || gy >= maxY) continue;
|
|
if (edit.block == Block::Leaves && world.blockAt(gx, gy, gz) != Block::Air) continue;
|
|
world.setBlock(gx, gy, gz, edit.block);
|
|
}
|
|
}
|
|
|
|
} // namespace vf
|