/* Helper: Do a successful Extended ORPort authentication handshake. */
static void
do_ext_or_handshake(or_connection_t *conn)
{
char b[256];
tt_int_op(0, OP_EQ, connection_ext_or_start_auth(conn));
CONTAINS("\x01\x00", 2);
WRITE("\x01", 1);
WRITE("But when I look ahead up the whi", 32);
MOCK(crypto_rand, crypto_rand_return_tse_str);
tt_int_op(0, OP_EQ, connection_ext_or_process_inbuf(conn));
UNMOCK(crypto_rand);
tt_int_op(TO_CONN(conn)->state, OP_EQ,
EXT_OR_CONN_STATE_AUTH_WAIT_CLIENT_HASH);
CONTAINS("\xec\x80\xed\x6e\x54\x6d\x3b\x36\xfd\xfc\x22\xfe\x13\x15\x41\x6b"
"\x02\x9f\x1a\xde\x76\x10\xd9\x10\x87\x8b\x62\xee\xb7\x40\x38\x21"
"te road There is always another ", 64);
/* Send the right response this time. */
WRITE("\xab\x39\x17\x32\xdd\x2e\xd9\x68\xcd\x40\xc0\x87\xd1\xb1\xf2\x5b"
"\x33\xb3\xcd\x77\xff\x79\xbd\x80\xc2\x07\x4b\xbf\x43\x81\x19\xa2",
32);
tt_int_op(0, OP_EQ, connection_ext_or_process_inbuf(conn));
CONTAINS("\x01", 1);
tt_assert(! TO_CONN(conn)->marked_for_close);
tt_int_op(TO_CONN(conn)->state, OP_EQ, EXT_OR_CONN_STATE_OPEN);
done: ;
}
static int range_cmp_for_search(const void *l, const void *r) {
range_t *left = (range_t *)l, *right = (range_t *)r;
if (INTERSECT(left, right) ||
CONTAINS(left, right) ||
CONTAINS(right, left)) {
return 0;
}
return left->start - right->start;
}
bool DecoSimple::canPlaceDecoration(MMVManip *vm, 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[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 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;
}
void printFaceTupleFaces(bitset tuple){
int i, j;
for(i=0; i<nf; i++){
if(CONTAINS(tuple, i)){
fprintf(stderr, "%d) ", i+1);
for(j=0; j<nv; j++){
if(CONTAINS(faceSets[i], j)){
fprintf(stderr, "%d ", j+1);
}
}
fprintf(stderr, "\n");
}
}
}
void Dashboard::addWidget(DashboardWidget *widget)
{
if (CONTAINS(widgets, widget))
return;
widgets.push_back(widget);
}
void OreScatter::generate(ManualMapVoxelManipulator *vm, int seed,
u32 blockseed, v3s16 nmin, v3s16 nmax) {
PseudoRandom pr(blockseed);
MapNode n_ore(c_ore, 0, ore_param2);
int volume = (nmax.X - nmin.X + 1) *
(nmax.Y - nmin.Y + 1) *
(nmax.Z - nmin.Z + 1);
int csize = clust_size;
int orechance = (csize * csize * csize) / clust_num_ores;
int nclusters = volume / clust_scarcity;
for (int i = 0; i != nclusters; i++) {
int x0 = pr.range(nmin.X, nmax.X - csize + 1);
int y0 = pr.range(nmin.Y, nmax.Y - csize + 1);
int z0 = pr.range(nmin.Z, nmax.Z - csize + 1);
if (np && (NoisePerlin3D(np, x0, y0, z0, seed) < nthresh))
continue;
for (int z1 = 0; z1 != csize; z1++)
for (int y1 = 0; y1 != csize; y1++)
for (int x1 = 0; x1 != csize; x1++) {
if (pr.range(1, orechance) != 1)
continue;
u32 i = vm->m_area.index(x0 + x1, y0 + y1, z0 + z1);
if (!CONTAINS(c_wherein, vm->m_data[i].getContent()))
continue;
vm->m_data[i] = n_ore;
}
}
}
void VirtualNetwork::removeDevice(NetworkDevice *device)
{
if (CONTAINS(devices, device)) {
this->devices.erase(FIND(devices, device));
device->disconnectFromNetwork();
}
}
size_t DecoSchematic::generate(MMVManip *vm, PseudoRandom *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))
return 0;
if (flags & DECO_PLACE_CENTER_X)
p.X -= (schematic->size.X - 1) / 2;
if (flags & DECO_PLACE_CENTER_Y)
p.Y -= (schematic->size.Y - 1) / 2;
if (flags & DECO_PLACE_CENTER_Z)
p.Z -= (schematic->size.Z - 1) / 2;
Rotation rot = (rotation == ROTATE_RAND) ?
(Rotation)pr->range(ROTATE_0, ROTATE_270) : rotation;
bool force_placement = (flags & DECO_FORCE_PLACEMENT);
schematic->blitToVManip(p, vm, rot, force_placement);
return 1;
}
boolean findEOPD(bitset tuple){
int i, j;
//first we check the stored OPD's
for(i = 0; i < eopdCount; i++){
bitset intersectionOpd = INTERSECTION(tuple, opdFaces[i]);
bitset intersectionExtensions = INTERSECTION(tuple, extensionFaces[i]);
if((IS_NOT_EMPTY(intersectionOpd) && IS_NOT_EMPTY(intersectionExtensions)) ||
(HAS_MORE_THAN_ONE_ELEMENT(intersectionOpd))){
numberOfTuplesCoveredByStoredOpd++;
return TRUE;
}
}
//then we try to find a new eOPD
for(i = 0; i < nf; i++){
if(CONTAINS(tuple, i)){
//try to find a eOPD with face i as extension
bitset remainingFaces = MINUS(tuple, i);
//we use each edge once as a possible shared edge
EDGE *sharedEdge = facestart[i];
for(j = 0; j < 3; j++){
//construct initial eopd
int neighbouringFace = sharedEdge->inverse->rightface;
bitset currentEopdVertices = faceSets[neighbouringFace];
bitset currentEopdFaces = UNION(SINGLETON(i), SINGLETON(neighbouringFace));
if(findEOPD_impl(currentEopdVertices, currentEopdFaces, i, remainingFaces, sharedEdge->inverse)){
return TRUE;
}
sharedEdge = sharedEdge->next->inverse;
}
}
}
return FALSE;
}
void printVector(FILE *f, bitset vector){
int i;
for(i = 0; i < n; i++){
fprintf(f, CONTAINS(vector, i) ? "1" : "0");
}
fprintf(f, "\n");
}
void VirtualNetwork::addDevice(NetworkDevice *device)
{
if (CONTAINS(devices, device))
return;
devices.push_back(device);
device->connectToNetwork(this);
}
bool NodeDefManager::nodeboxConnects(MapNode from, MapNode to,
u8 connect_face) const
{
const ContentFeatures &f1 = get(from);
if ((f1.drawtype != NDT_NODEBOX) || (f1.node_box.type != NODEBOX_CONNECTED))
return false;
// lookup target in connected set
if (!CONTAINS(f1.connects_to_ids, to.param0))
return false;
const ContentFeatures &f2 = get(to);
if ((f2.drawtype == NDT_NODEBOX) && (f2.node_box.type == NODEBOX_CONNECTED))
// ignores actually looking if back connection exists
return CONTAINS(f2.connects_to_ids, from.param0);
// does to node declare usable faces?
if (f2.connect_sides > 0) {
if ((f2.param_type_2 == CPT2_FACEDIR ||
f2.param_type_2 == CPT2_COLORED_FACEDIR)
&& (connect_face >= 4)) {
static const u8 rot[33 * 4] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 4, 32, 16, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, // 4 - back
8, 4, 32, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, // 8 - right
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 8, 4, 32, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, // 16 - front
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 32, 16, 8, 4 // 32 - left
};
return (f2.connect_sides
& rot[(connect_face * 4) + (to.param2 & 0x1F)]);
}
return (f2.connect_sides & connect_face);
}
// the target is just a regular node, so connect no matter back connection
return true;
}
bool ModChannel::registerConsumer(session_t peer_id)
{
// ignore if peer_id already joined
if (CONTAINS(m_client_consumers, peer_id))
return false;
m_client_consumers.push_back(peer_id);
return true;
}
void printVertexTuple(bitset tuple){
int i;
fprintf(stderr, "Vertex tuple: ");
for(i=0; i<nv; i++){
if(CONTAINS(tuple, i)){
fprintf(stderr, "%d ", i+1);
}
}
fprintf(stderr, "\n");
}
void printFaceTuple(bitset tuple){
int i;
fprintf(stderr, "Face tuple: ");
for(i=0; i<nf; i++){
if(CONTAINS(tuple, i)){
fprintf(stderr, "%d ", i+1);
}
}
fprintf(stderr, "\n");
}
void OreStratum::generate(MMVManip *vm, int mapseed, u32 blockseed,
v3s16 nmin, v3s16 nmax, u8 *biomemap)
{
PcgRandom pr(blockseed + 4234);
MapNode n_ore(c_ore, 0, ore_param2);
if (flags & OREFLAG_USE_NOISE) {
if (!(noise && noise_stratum_thickness)) {
int sx = nmax.X - nmin.X + 1;
int sz = nmax.Z - nmin.Z + 1;
noise = new Noise(&np, 0, sx, sz);
noise_stratum_thickness = new Noise(&np_stratum_thickness, 0, sx, sz);
}
noise->perlinMap2D(nmin.X, nmin.Z);
noise_stratum_thickness->perlinMap2D(nmin.X, nmin.Z);
}
size_t index = 0;
for (int z = nmin.Z; z <= nmax.Z; z++)
for (int x = nmin.X; x <= nmax.X; x++, index++) {
if (biomemap && !biomes.empty()) {
std::unordered_set<u8>::const_iterator it = biomes.find(biomemap[index]);
if (it == biomes.end())
continue;
}
int y0;
int y1;
if (flags & OREFLAG_USE_NOISE) {
float nmid = noise->result[index];
float nhalfthick = noise_stratum_thickness->result[index] / 2.0f;
y0 = MYMAX(nmin.Y, nmid - nhalfthick);
y1 = MYMIN(nmax.Y, nmid + nhalfthick);
} else {
y0 = nmin.Y;
y1 = nmax.Y;
}
for (int y = y0; y <= y1; y++) {
if (pr.range(1, clust_scarcity) != 1)
continue;
u32 i = vm->m_area.index(x, y, z);
if (!vm->m_area.contains(i))
continue;
if (!CONTAINS(c_wherein, vm->m_data[i].getContent()))
continue;
vm->m_data[i] = n_ore;
}
}
}
void OreBlob::generate(MMVManip *vm, int mapseed, u32 blockseed,
v3s16 nmin, v3s16 nmax)
{
PseudoRandom pr(blockseed + 2404);
MapNode n_ore(c_ore, 0, ore_param2);
int volume = (nmax.X - nmin.X + 1) *
(nmax.Y - nmin.Y + 1) *
(nmax.Z - nmin.Z + 1);
int csize = clust_size;
int nblobs = volume / clust_scarcity;
if (!noise)
noise = new Noise(&np, mapseed, csize, csize, csize);
for (int i = 0; i != nblobs; i++) {
int x0 = pr.range(nmin.X, nmax.X - csize + 1);
int y0 = pr.range(nmin.Y, nmax.Y - csize + 1);
int z0 = pr.range(nmin.Z, nmax.Z - csize + 1);
bool noise_generated = false;
noise->seed = blockseed + i;
size_t index = 0;
for (int z1 = 0; z1 != csize; z1++)
for (int y1 = 0; y1 != csize; y1++)
for (int x1 = 0; x1 != csize; x1++, index++) {
u32 i = vm->m_area.index(x0 + x1, y0 + y1, z0 + z1);
if (!CONTAINS(c_wherein, vm->m_data[i].getContent()))
continue;
// Lazily generate noise only if there's a chance of ore being placed
// This simple optimization makes calls 6x faster on average
if (!noise_generated) {
noise_generated = true;
noise->perlinMap3D(x0, y0, z0);
}
float noiseval = noise->result[index];
float xdist = x1 - csize / 2;
float ydist = y1 - csize / 2;
float zdist = z1 - csize / 2;
noiseval -= (sqrt(xdist * xdist + ydist * ydist + zdist * zdist) / csize);
if (noiseval < nthresh)
continue;
vm->m_data[i] = n_ore;
}
}
}
void greedyExtendOpdAndStore(bitset currentOpdVertices, bitset currentOpdFaces){
int i;
int top;
EDGE *boundaryStack[MAXE];
top = 0;
//fill the stack with the current boundary
for(i = 0; i < ne; i++){
if(CONTAINS_ALL(currentOpdVertices, edges[i].vertices) &&
!CONTAINS(currentOpdFaces, edges[i].rightface)){
PUSH(boundaryStack, edges + i);
}
}
while(STACKISNOTEMPTY){
EDGE *currentEdge = POP(boundaryStack);
if(INTERSECTION(currentOpdVertices, neighbourhood[currentEdge->next->end])
== currentEdge->vertices){
//modify OPD by adding face to the right of current edge
ADD_ALL(currentOpdVertices, faceSets[currentEdge->rightface]);
ADD(currentOpdFaces, currentEdge->rightface);
//push new boundary edges on stack
PUSH(boundaryStack, currentEdge->next);
PUSH(boundaryStack, currentEdge->inverse->prev->inverse);
}
}
//store the OPD together with all possible extensions
opdFaces[eopdCount] = currentOpdFaces;
extensionFaces[eopdCount] = EMPTY_SET;
for(i = 0; i < nf; i++){
if(!CONTAINS(currentOpdFaces, i) &&
HAS_MORE_THAN_ONE_ELEMENT(INTERSECTION(faceSets[i], currentOpdVertices))){
ADD(extensionFaces[eopdCount], i);
}
}
eopdCount++;
}
void OreVein::generate(MMVManip *vm, int mapseed, u32 blockseed,
v3s16 nmin, v3s16 nmax, u8 *biomemap)
{
PcgRandom pr(blockseed + 520);
MapNode n_ore(c_ore, 0, ore_param2);
u32 sizex = (nmax.X - nmin.X + 1);
if (!noise) {
int sx = nmax.X - nmin.X + 1;
int sy = nmax.Y - nmin.Y + 1;
int sz = nmax.Z - nmin.Z + 1;
noise = new Noise(&np, mapseed, sx, sy, sz);
noise2 = new Noise(&np, mapseed + 436, sx, sy, sz);
}
bool noise_generated = false;
size_t index = 0;
for (int z = nmin.Z; z <= nmax.Z; z++)
for (int y = nmin.Y; y <= nmax.Y; y++)
for (int x = nmin.X; x <= nmax.X; x++, index++) {
u32 i = vm->m_area.index(x, y, z);
if (!vm->m_area.contains(i))
continue;
if (!CONTAINS(c_wherein, vm->m_data[i].getContent()))
continue;
if (biomemap && !biomes.empty()) {
u32 bmapidx = sizex * (z - nmin.Z) + (x - nmin.X);
std::set<u8>::iterator it = biomes.find(biomemap[bmapidx]);
if (it == biomes.end())
continue;
}
// Same lazy generation optimization as in OreBlob
if (!noise_generated) {
noise_generated = true;
noise->perlinMap3D(nmin.X, nmin.Y, nmin.Z);
noise2->perlinMap3D(nmin.X, nmin.Y, nmin.Z);
}
// randval ranges from -1..1
float randval = (float)pr.next() / (pr.RANDOM_RANGE / 2) - 1.f;
float noiseval = contour(noise->result[index]);
float noiseval2 = contour(noise2->result[index]);
if (noiseval * noiseval2 + randval * random_factor < nthresh)
continue;
vm->m_data[i] = n_ore;
}
}
void OreSheet::generate(MMVManip *vm, int mapseed, u32 blockseed,
v3s16 nmin, v3s16 nmax, u8 *biomemap)
{
PcgRandom pr(blockseed + 4234);
MapNode n_ore(c_ore, 0, ore_param2);
u16 max_height = column_height_max;
int y_start_min = nmin.Y + max_height;
int y_start_max = nmax.Y - max_height;
int y_start = y_start_min < y_start_max ?
pr.range(y_start_min, y_start_max) :
(y_start_min + y_start_max) / 2;
if (!noise) {
int sx = nmax.X - nmin.X + 1;
int sz = nmax.Z - nmin.Z + 1;
noise = new Noise(&np, 0, sx, sz);
}
noise->seed = mapseed + y_start;
noise->perlinMap2D(nmin.X, nmin.Z);
size_t index = 0;
for (int z = nmin.Z; z <= nmax.Z; z++)
for (int x = nmin.X; x <= nmax.X; x++, index++) {
float noiseval = noise->result[index];
if (noiseval < nthresh)
continue;
if (biomemap && !biomes.empty()) {
std::set<u8>::iterator it = biomes.find(biomemap[index]);
if (it == biomes.end())
continue;
}
u16 height = pr.range(column_height_min, column_height_max);
int ymidpoint = y_start + noiseval;
int y0 = MYMAX(nmin.Y, ymidpoint - height * (1 - column_midpoint_factor));
int y1 = MYMIN(nmax.Y, y0 + height - 1);
for (int y = y0; y <= y1; y++) {
u32 i = vm->m_area.index(x, y, z);
if (!vm->m_area.contains(i))
continue;
if (!CONTAINS(c_wherein, vm->m_data[i].getContent()))
continue;
vm->m_data[i] = n_ore;
}
}
}
static int check_overlap(struct hlist_head *ptype,
unsigned long paddr,
unsigned long len)
{
struct msm_pmem_region *region;
struct msm_pmem_region t = { .paddr = paddr, .len = len };
struct hlist_node *node;
hlist_for_each_entry(region, node, ptype, list) {
if (CONTAINS(region, &t, paddr) ||
CONTAINS(&t, region, paddr) ||
OVERLAPS(region, &t, paddr)) {
CDBG(" region (PHYS %p len %ld)"
" clashes with registered region"
" (paddr %p len %ld)\n",
(void *)t.paddr, t.len,
(void *)region->paddr, region->len);
return -EINVAL;
}
}
return 0;
}
static inline void run_checks(const void *l, const void *r) {
range_t *left = (range_t *)l, *right = (range_t *)r;
if (CONTAINS(left, right)) {
if (left->err_fn)
left->err_fn(ERROR_CONTAINS, left, right);
FAILIF(1, "Range sorting error: [%lld, %lld) contains [%lld, %lld)!\n",
left->start, left->start + left->length,
right->start, right->start + right->length);
}
if (CONTAINS(right, left)) {
if (right->err_fn)
right->err_fn(ERROR_CONTAINS, left, right);
FAILIF(1, "Range sorting error: [%lld, %lld) contains [%lld, %lld)!\n",
right->start, right->start + right->length,
left->start, left->start + left->length);
}
if (INTERSECT(left, right)) {
if (left->err_fn)
left->err_fn(ERROR_OVERLAPS, left, right);
FAILIF(1, "Range sorting error: [%lld, %lld)and [%lld, %lld) intersect!\n",
left->start, left->start + left->length,
right->start, right->start + right->length);
}
}
void constructInitialEopds(){
int i;
greedyExtendOpdAndStore(faceSets[0], SINGLETON(0));
bitset coveredFaces = UNION(opdFaces[eopdCount-1], extensionFaces[eopdCount-1]);
for(i = nf -1; i > 0; i--){
if(!CONTAINS(coveredFaces, i)){
greedyExtendOpdAndStore(faceSets[i], SINGLETON(i));
ADD_ALL(coveredFaces, opdFaces[eopdCount-1]);
ADD_ALL(coveredFaces, extensionFaces[eopdCount-1]);
}
}
}
range_list_t* subtract_ranges(const range_list_t *r, const range_list_t *s)
{
ASSERT(r); ASSERT(r->is_sorted);
ASSERT(s); ASSERT(s->is_sorted);
range_list_t *result = init_range_list();
int r_num_ranges, r_idx;
range_t *r_ranges = get_sorted_ranges(r, &r_num_ranges);
ASSERT(r_ranges);
int s_num_ranges, s_idx;
range_t *s_ranges = get_sorted_ranges(s, &s_num_ranges);
ASSERT(s_ranges);
s_idx = 0;
for (r_idx = 0; r_idx < r_num_ranges; r_idx++) {
GElf_Off last_start = r_ranges[r_idx].start;
for (; s_idx < s_num_ranges; s_idx++) {
if (CONTAINS(&r_ranges[r_idx], &s_ranges[s_idx])) {
if (last_start ==
r_ranges[r_idx].start + r_ranges[r_idx].length) {
break;
}
if (last_start == s_ranges[s_idx].start) {
last_start += s_ranges[s_idx].length;
continue;
}
INFO("Adding subtracted range [%lld, %lld)\n",
last_start,
s_ranges[s_idx].start);
add_unique_range_nosort(
result,
last_start,
s_ranges[s_idx].start - last_start,
NULL,
NULL,
NULL);
last_start = s_ranges[s_idx].start + s_ranges[s_idx].length;
} else {
ASSERT(!INTERSECT(&r_ranges[r_idx], &s_ranges[s_idx]));
break;
}
} /* while (s_idx < s_num_ranges) */
} /* for (r_idx = 0; r_idx < r_num_ranges; r_idx++) */
return result;
}
__attribute__((always_inline)) inline
void connect(stack *st, agent *cars) {
agent m = st->n[N];
const agent *p = st->n + N + 1;
agent *q = (agent *)malloc(sizeof(agent) * N);
agent *l = (agent *)malloc(sizeof(agent) * N * N);
agent *h = (agent *)calloc(N, sizeof(agent));
chunk tmp[C];
memcpy(tmp, st->c, sizeof(chunk) * C);
MASKAND(tmp, st->r, tmp, C);
edge popc = MASKPOPCNT(tmp, C);
for (edge i = 0, e = MASKFFS(tmp, C); i < popc; i++, e = MASKCLEARANDFFS(tmp, e, C)) {
agent v1 = X(st->a, e);
agent v2 = l[v1 * N + h[v1]++] = Y(st->a, e);
l[v2 * N + h[v2]++] = v1;
}
do {
edge e = 1, f = 0;
agent i = *(p++);
q[f] = i;
do {
for (agent j = 0; j < h[q[f]]; j++) {
agent b = l[q[f] * N + j];
if (i != b && CONTAINS(st->n, b)) {
//printf("merge %u %u\n", i, b);
q[e++] = b;
//printbuf(st->cs, N, "cs");
merge(st, i, b);
//printbuf(st->cs, N, "cs");
m--;
cars[i] += cars[b];
}
}
f++;
}
while (f != e);
} while (--m);
free(q);
free(l);
free(h);
}
// find_node_near(pos, radius, nodenames, search_center) -> pos or nil
// nodenames: eg. {"ignore", "group:tree"} or "default:dirt"
int ModApiEnvMod::l_find_node_near(lua_State *L)
{
Environment *env = getEnv(L);
if (!env) {
return 0;
}
INodeDefManager *ndef = getGameDef(L)->ndef();
v3s16 pos = read_v3s16(L, 1);
int radius = luaL_checkinteger(L, 2);
std::vector<content_t> filter;
if (lua_istable(L, 3)) {
lua_pushnil(L);
while (lua_next(L, 3) != 0) {
// key at index -2 and value at index -1
luaL_checktype(L, -1, LUA_TSTRING);
ndef->getIds(lua_tostring(L, -1), filter);
// removes value, keeps key for next iteration
lua_pop(L, 1);
}
} else if (lua_isstring(L, 3)) {
ndef->getIds(lua_tostring(L, 3), filter);
}
int start_radius = (lua_toboolean(L, 4)) ? 0 : 1;
#ifndef SERVER
// Client API limitations
if (getClient(L) &&
getClient(L)->checkCSMFlavourLimit(CSMFlavourLimit::CSM_FL_LOOKUP_NODES)) {
radius = std::max<int>(radius, getClient(L)->getCSMNodeRangeLimit());
}
#endif
for (int d = start_radius; d <= radius; d++) {
std::vector<v3s16> list = FacePositionCache::getFacePositions(d);
for (const v3s16 &i : list) {
v3s16 p = pos + i;
content_t c = env->getMap().getNodeNoEx(p).getContent();
if (CONTAINS(filter, c)) {
push_v3s16(L, p);
return 1;
}
}
}
return 0;
}
void OreScatter::generate(MMVManip *vm, int mapseed, u32 blockseed,
v3s16 nmin, v3s16 nmax, u8 *biomemap)
{
PcgRandom pr(blockseed);
MapNode n_ore(c_ore, 0, ore_param2);
u32 sizex = (nmax.X - nmin.X + 1);
u32 volume = (nmax.X - nmin.X + 1) *
(nmax.Y - nmin.Y + 1) *
(nmax.Z - nmin.Z + 1);
u32 csize = clust_size;
u32 cvolume = csize * csize * csize;
u32 nclusters = volume / clust_scarcity;
if (clust_scarcity > volume && 1 >= pr.range(0, clust_scarcity/volume))
nclusters = 1;
for (u32 i = 0; i != nclusters; i++) {
int x0 = pr.range(nmin.X, nmax.X - csize + 1);
int y0 = pr.range(nmin.Y, nmax.Y - csize + 1);
int z0 = pr.range(nmin.Z, nmax.Z - csize + 1);
if ((flags & OREFLAG_USE_NOISE) &&
(NoisePerlin3D(&np, x0, y0, z0, mapseed) < nthresh))
continue;
if (biomemap && !biomes.empty()) {
u32 index = sizex * (z0 - nmin.Z) + (x0 - nmin.X);
std::set<u8>::iterator it = biomes.find(biomemap[index]);
if (it == biomes.end())
continue;
}
for (u32 z1 = 0; z1 != csize; z1++)
for (u32 y1 = 0; y1 != csize; y1++)
for (u32 x1 = 0; x1 != csize; x1++) {
if (pr.range(1, cvolume) > clust_num_ores)
continue;
u32 i = vm->m_area.index(x0 + x1, y0 + y1, z0 + z1);
if (!CONTAINS(c_wherein, vm->m_data[i].getContent()))
continue;
vm->m_data[i] = n_ore;
}
}
}
void OreSheet::generate(MMVManip *vm, int mapseed, u32 blockseed,
v3s16 nmin, v3s16 nmax, u8 *biomemap)
{
PseudoRandom pr(blockseed + 4234);
MapNode n_ore(c_ore, 0, ore_param2);
int max_height = clust_size;
int y_start = pr.range(nmin.Y, nmax.Y - max_height);
if (!noise) {
int sx = nmax.X - nmin.X + 1;
int sz = nmax.Z - nmin.Z + 1;
noise = new Noise(&np, 0, sx, sz);
}
noise->seed = mapseed + y_start;
noise->perlinMap2D(nmin.X, nmin.Z);
size_t index = 0;
for (int z = nmin.Z; z <= nmax.Z; z++)
for (int x = nmin.X; x <= nmax.X; x++, index++) {
float noiseval = noise->result[index];
if (noiseval < nthresh)
continue;
if (biomemap && !biomes.empty()) {
std::set<u8>::iterator it = biomes.find(biomemap[index]);
if (it == biomes.end())
continue;
}
int height = max_height * (1. / pr.range(1, 3));
int y0 = y_start + np.scale * noiseval; //pr.range(1, 3) - 1;
int y1 = y0 + height;
for (int y = y0; y != y1; y++) {
u32 i = vm->m_area.index(x, y, z);
if (!vm->m_area.contains(i))
continue;
if (!CONTAINS(c_wherein, vm->m_data[i].getContent()))
continue;
vm->m_data[i] = n_ore;
}
}
}
void OreVein::generate(MMVManip *vm, int mapseed, u32 blockseed,
v3s16 nmin, v3s16 nmax)
{
PseudoRandom pr(blockseed + 520);
MapNode n_ore(c_ore, 0, ore_param2);
if (!noise) {
int sx = nmax.X - nmin.X + 1;
int sy = nmax.Y - nmin.Y + 1;
int sz = nmax.Z - nmin.Z + 1;
noise = new Noise(&np, mapseed, sx, sy, sz);
noise2 = new Noise(&np, mapseed + 436, sx, sy, sz);
}
bool noise_generated = false;
size_t index = 0;
for (int z = nmin.Z; z <= nmax.Z; z++)
for (int y = nmin.Y; y <= nmax.Y; y++)
for (int x = nmin.X; x <= nmax.X; x++, index++) {
u32 i = vm->m_area.index(x, y, z);
if (!vm->m_area.contains(i))
continue;
if (!CONTAINS(c_wherein, vm->m_data[i].getContent()))
continue;
// Same lazy generation optimization as in OreBlob
if (!noise_generated) {
noise_generated = true;
noise->perlinMap3D(nmin.X, nmin.Y, nmin.Z);
noise2->perlinMap3D(nmin.X, nmin.Y, nmin.Z);
}
// randval ranges from -1..1
float randval = (float)pr.next() / (PSEUDORANDOM_MAX / 2) - 1.f;
float noiseval = contour(noise->result[index]);
float noiseval2 = contour(noise2->result[index]);
if (noiseval * noiseval2 + randval * random_factor < nthresh)
continue;
vm->m_data[i] = n_ore;
}
}
void DecoSchematic::generate(Mapgen *mg, PseudoRandom *pr, s16 max_y, v3s16 p) {
ManualMapVoxelManipulator *vm = mg->vm;
if (flags & DECO_PLACE_CENTER_X)
p.X -= (size.X + 1) / 2;
if (flags & DECO_PLACE_CENTER_Y)
p.Y -= (size.Y + 1) / 2;
if (flags & DECO_PLACE_CENTER_Z)
p.Z -= (size.Z + 1) / 2;
u32 vi = vm->m_area.index(p);
content_t c = vm->m_data[vi].getContent();
if (!CONTAINS(c_place_on, c))
return;
Rotation rot = (rotation == ROTATE_RAND) ?
(Rotation)pr->range(ROTATE_0, ROTATE_270) : rotation;
blitToVManip(p, vm, rot, false);
}
