#include "map.h"
#include "log.h"
#include "util/numeric.h"
+#include <algorithm>
+
FlagDesc flagdesc_deco[] = {
- {"place_center_x", DECO_PLACE_CENTER_X},
- {"place_center_y", DECO_PLACE_CENTER_Y},
- {"place_center_z", DECO_PLACE_CENTER_Z},
+ {"place_center_x", DECO_PLACE_CENTER_X},
+ {"place_center_y", DECO_PLACE_CENTER_Y},
+ {"place_center_z", DECO_PLACE_CENTER_Z},
{"force_placement", DECO_FORCE_PLACEMENT},
- {NULL, 0}
+ {"liquid_surface", DECO_LIQUID_SURFACE},
+ {NULL, 0}
};
void Decoration::resolveNodeNames()
{
getIdsFromNrBacklog(&c_place_on);
+ getIdsFromNrBacklog(&c_spawnby);
+}
+
+
+bool Decoration::canPlaceDecoration(MMVManip *vm, v3s16 p)
+{
+ // Check if the decoration can be placed on this node
+ u32 vi = vm->m_area.index(p);
+ if (!CONTAINS(c_place_on, vm->m_data[vi].getContent()))
+ return false;
+
+ // Don't continue if there are no spawnby constraints
+ if (nspawnby == -1)
+ return true;
+
+ int nneighs = 0;
+ static const v3s16 dirs[16] = {
+ v3s16( 0, 0, 1),
+ v3s16( 0, 0, -1),
+ v3s16( 1, 0, 0),
+ v3s16(-1, 0, 0),
+ v3s16( 1, 0, 1),
+ v3s16(-1, 0, 1),
+ v3s16(-1, 0, -1),
+ v3s16( 1, 0, -1),
+
+ v3s16( 0, 1, 1),
+ v3s16( 0, 1, -1),
+ v3s16( 1, 1, 0),
+ v3s16(-1, 1, 0),
+ v3s16( 1, 1, 1),
+ v3s16(-1, 1, 1),
+ v3s16(-1, 1, -1),
+ v3s16( 1, 1, -1)
+ };
+
+ // Check these 16 neighbouring nodes for enough spawnby nodes
+ for (size_t i = 0; i != ARRLEN(dirs); i++) {
+ u32 index = vm->m_area.index(p + dirs[i]);
+ if (!vm->m_area.contains(index))
+ continue;
+
+ if (CONTAINS(c_spawnby, vm->m_data[index].getContent()))
+ nneighs++;
+ }
+
+ if (nneighs < nspawnby)
+ return false;
+
+ return true;
}
size_t Decoration::placeDeco(Mapgen *mg, u32 blockseed, v3s16 nmin, v3s16 nmax)
{
- PseudoRandom ps(blockseed + 53);
+ PcgRandom ps(blockseed + 53);
int carea_size = nmax.X - nmin.X + 1;
// Divide area into parts
- if (carea_size % sidelen) {
- errorstream << "Decoration::placeDeco: chunk size is not divisible by "
- "sidelen; setting sidelen to " << carea_size << std::endl;
+ // If chunksize is changed it may no longer be divisable by sidelen
+ if (carea_size % sidelen)
sidelen = carea_size;
- }
s16 divlen = carea_size / sidelen;
int area = sidelen * sidelen;
float nval = (flags & DECO_USE_NOISE) ?
NoisePerlin2D(&np, p2d_center.X, p2d_center.Y, mapseed) :
fill_ratio;
- u32 deco_count = area * MYMAX(nval, 0.f);
+ u32 deco_count = 0;
+ float deco_count_f = (float)area * nval;
+ if (deco_count_f >= 1.f) {
+ deco_count = deco_count_f;
+ } else if (deco_count_f > 0.f) {
+ // For low density decorations calculate a chance for 1 decoration
+ if (ps.range(1000) <= deco_count_f * 1000.f)
+ deco_count = 1;
+ }
for (u32 i = 0; i < deco_count; i++) {
s16 x = ps.range(p2d_min.X, p2d_max.X);
int mapindex = carea_size * (z - nmin.Z) + (x - nmin.X);
- s16 y = mg->heightmap ?
- mg->heightmap[mapindex] :
- mg->findGroundLevel(v2s16(x, z), nmin.Y, nmax.Y);
- y = MYMAX(y, mg->water_level);
+ s16 y = -MAX_MAP_GENERATION_LIMIT;
+ if (flags & DECO_LIQUID_SURFACE)
+ y = mg->findLiquidSurface(v2s16(x, z), nmin.Y, nmax.Y);
+ else if (mg->heightmap)
+ y = mg->heightmap[mapindex];
+ else
+ y = mg->findGroundLevel(v2s16(x, z), nmin.Y, nmax.Y);
if (y < nmin.Y || y > nmax.Y ||
y < y_min || y > y_max)
continue;
- if (y + getHeight() >= mg->vm->m_area.MaxEdge.Y) {
+ if (y + getHeight() > mg->vm->m_area.MaxEdge.Y) {
continue;
#if 0
printf("Decoration at (%d %d %d) cut off\n", x, y, z);
//add to queue
- JMutexAutoLock cutofflock(cutoff_mutex);
+ MutexAutoLock cutofflock(cutoff_mutex);
cutoffs.push_back(CutoffData(x, y, z, height));
#endif
}
if (mg->biomemap) {
- std::set<u8>::iterator iter;
+ UNORDERED_SET<u8>::iterator iter;
if (!biomes.empty()) {
iter = biomes.find(mg->biomemap[mapindex]);
#if 0
void Decoration::placeCutoffs(Mapgen *mg, u32 blockseed, v3s16 nmin, v3s16 nmax)
{
- PseudoRandom pr(blockseed + 53);
+ PcgRandom pr(blockseed + 53);
std::vector<CutoffData> handled_cutoffs;
// Copy over the cutoffs we're interested in so we don't needlessly hold a lock
{
- JMutexAutoLock cutofflock(cutoff_mutex);
+ MutexAutoLock cutofflock(cutoff_mutex);
for (std::list<CutoffData>::iterator i = cutoffs.begin();
i != cutoffs.end(); ++i) {
CutoffData cutoff = *i;
// Remove cutoffs that were handled from the cutoff list
{
- JMutexAutoLock cutofflock(cutoff_mutex);
+ MutexAutoLock cutofflock(cutoff_mutex);
for (std::list<CutoffData>::iterator i = cutoffs.begin();
i != cutoffs.end(); ++i) {
{
Decoration::resolveNodeNames();
getIdsFromNrBacklog(&c_decos);
- getIdsFromNrBacklog(&c_spawnby);
}
-bool DecoSimple::canPlaceDecoration(MMVManip *vm, v3s16 p)
+size_t DecoSimple::generate(MMVManip *vm, PcgRandom *pr, v3s16 p)
{
// Don't bother if there aren't any decorations to place
if (c_decos.size() == 0)
- return false;
-
- u32 vi = vm->m_area.index(p);
-
- // Check if the decoration can be placed on this node
- if (!CONTAINS(c_place_on, vm->m_data[vi].getContent()))
- return false;
-
- // Don't continue if there are no spawnby constraints
- if (nspawnby == -1)
- return true;
-
- int nneighs = 0;
- v3s16 dirs[8] = {
- v3s16( 0, 0, 1),
- v3s16( 0, 0, -1),
- v3s16( 1, 0, 0),
- v3s16(-1, 0, 0),
- v3s16( 1, 0, 1),
- v3s16(-1, 0, 1),
- v3s16(-1, 0, -1),
- v3s16( 1, 0, -1)
- };
-
- // Check a Moore neighborhood if there are enough spawnby nodes
- for (size_t i = 0; i != ARRLEN(dirs); i++) {
- u32 index = vm->m_area.index(p + dirs[i]);
- if (!vm->m_area.contains(index))
- continue;
-
- if (CONTAINS(c_spawnby, vm->m_data[index].getContent()))
- nneighs++;
- }
-
- if (nneighs < nspawnby)
- return false;
-
- return true;
-}
-
+ return 0;
-size_t DecoSimple::generate(MMVManip *vm, PseudoRandom *pr, v3s16 p)
-{
if (!canPlaceDecoration(vm, p))
return 0;
s16 height = (deco_height_max > 0) ?
pr->range(deco_height, deco_height_max) : deco_height;
+ bool force_placement = (flags & DECO_FORCE_PLACEMENT);
+
v3s16 em = vm->m_area.getExtent();
u32 vi = vm->m_area.index(p);
for (int i = 0; i < height; i++) {
vm->m_area.add_y(em, vi, 1);
content_t c = vm->m_data[vi].getContent();
- if (c != CONTENT_AIR && c != CONTENT_IGNORE)
+ if (c != CONTENT_AIR && c != CONTENT_IGNORE &&
+ !force_placement)
break;
- vm->m_data[vi] = MapNode(c_place);
+ vm->m_data[vi] = MapNode(c_place, 0, deco_param2);
}
return 1;
///////////////////////////////////////////////////////////////////////////////
-DecoSchematic::DecoSchematic() :
- Decoration::Decoration()
+DecoSchematic::DecoSchematic()
{
schematic = NULL;
}
-size_t DecoSchematic::generate(MMVManip *vm, PseudoRandom *pr, v3s16 p)
+size_t DecoSchematic::generate(MMVManip *vm, PcgRandom *pr, v3s16 p)
{
// Schematic could have been unloaded but not the decoration
// In this case generate() does nothing (but doesn't *fail*)
if (schematic == NULL)
return 0;
- u32 vi = vm->m_area.index(p);
- content_t c = vm->m_data[vi].getContent();
- if (!CONTAINS(c_place_on, c))
+ if (!canPlaceDecoration(vm, p))
return 0;
if (flags & DECO_PLACE_CENTER_X)
bool force_placement = (flags & DECO_FORCE_PLACEMENT);
- schematic->blitToVManip(p, vm, rot, force_placement, m_ndef);
+ schematic->blitToVManip(vm, p, rot, force_placement);
return 1;
}
int DecoSchematic::getHeight()
{
- return schematic->size.Y;
+ // Account for a schematic being sunk into the ground by flag.
+ // When placed normally account for how a schematic is placed
+ // sunk 1 node into the ground.
+ return (flags & DECO_PLACE_CENTER_Y) ?
+ (schematic->size.Y - 1) / 2 : schematic->size.Y - 1;
}
projects / minetest.git / blobdiff