void MapgenV5::actuallyGenerate() { ManualMapVoxelManipulator &vmanip = *vm; v2s16 p2d_center(node_min.X+MAP_BLOCKSIZE/2, node_min.Z+MAP_BLOCKSIZE/2); /* Get average ground level from noise */ s16 minimum_groundlevel = (s16)get_sector_minimum_ground_level( seed, node_min, node_max); // Minimum amount of ground above the top of the central block s16 minimum_ground_depth = minimum_groundlevel - node_max.Y; s16 maximum_groundlevel = (s16)get_sector_maximum_ground_level( seed, node_min, node_max, 1); // Maximum amount of ground above the bottom of the central block s16 maximum_ground_depth = maximum_groundlevel - node_min.Y; #if 0 /* Special case for high air or water: Just fill with air and water. */ if(maximum_ground_depth < -20) { for(s16 x=node_min.X; x<=node_max.X; x++) for(s16 z=node_min.Z; z<=node_max.Z; z++) { // Node position v2s16 p2d(x,z); { // Use fast index incrementing v3s16 em = vmanip.m_area.getExtent(); u32 i = vmanip.m_area.index(v3s16(p2d.X, node_min.Y, p2d.Y)); for(s16 y=node_min.Y; y<=node_max.Y; y++) { // Only modify places that have no content if(vmanip.m_data[i].getContent() == CONTENT_IGNORE) { if(y <= WATER_LEVEL) vmanip.m_data[i] = MapNode(c_water_source); else vmanip.m_data[i] = MapNode(CONTENT_AIR); } vmanip.m_area.add_y(em, i, 1); } } } // We're done return; } #endif /* If block is deep underground, this is set to true and ground density noise is not generated, for speed optimization. */ bool all_is_ground_except_caves = (minimum_ground_depth > 40); /* Create a block-specific seed */ u32 blockseed = (u32)(seed%0x100000000ULL) + full_node_min.Z*38134234 + full_node_min.Y*42123 + full_node_min.X*23; /* Make some 3D noise */ //OldNoiseBuffer noisebuf1; //OldNoiseBuffer noisebuf2; OldNoiseBuffer noisebuf_cave; OldNoiseBuffer noisebuf_ground; OldNoiseBuffer noisebuf_ground_crumbleness; OldNoiseBuffer noisebuf_ground_wetness; { v3f minpos_f(node_min.X, node_min.Y, node_min.Z); v3f maxpos_f(node_max.X, node_max.Y, node_max.Z); //TimeTaker timer("noisebuf.create"); /* Cave noise */ #if 1 noisebuf_cave.create(get_cave_noise1_params(seed), minpos_f.X, minpos_f.Y, minpos_f.Z, maxpos_f.X, maxpos_f.Y, maxpos_f.Z, 2, 2, 2); noisebuf_cave.multiply(get_cave_noise2_params(seed)); #endif /* Ground noise */ // Sample length v3f sl = v3f(4.0, 4.0, 4.0); /* Density noise */ if(all_is_ground_except_caves == false) //noisebuf_ground.create(seed+983240, 6, 0.60, false, noisebuf_ground.create(get_ground_noise1_params(seed), minpos_f.X, minpos_f.Y, minpos_f.Z, maxpos_f.X, maxpos_f.Y, maxpos_f.Z, sl.X, sl.Y, sl.Z); /* Ground property noise */ sl = v3f(2.5, 2.5, 2.5); noisebuf_ground_crumbleness.create( get_ground_crumbleness_params(seed), minpos_f.X, minpos_f.Y, minpos_f.Z, maxpos_f.X, maxpos_f.Y+5, maxpos_f.Z, sl.X, sl.Y, sl.Z); noisebuf_ground_wetness.create( get_ground_wetness_params(seed), minpos_f.X, minpos_f.Y, minpos_f.Z, maxpos_f.X, maxpos_f.Y+5, maxpos_f.Z, sl.X, sl.Y, sl.Z); } /* Make base ground level */ for(s16 x=node_min.X; x<=node_max.X; x++) for(s16 z=node_min.Z; z<=node_max.Z; z++) { // Node position v2s16 p2d(x,z); { // Use fast index incrementing v3s16 em = vmanip.m_area.getExtent(); u32 i = vmanip.m_area.index(v3s16(p2d.X, node_min.Y, p2d.Y)); for(s16 y=node_min.Y; y<=node_max.Y; y++) { // Only modify places that have no content if(vmanip.m_data[i].getContent() == CONTENT_IGNORE) { // First priority: make air and water. // This avoids caves inside water. if(all_is_ground_except_caves == false && val_is_ground(noisebuf_ground.get(x,y,z), v3s16(x,y,z), seed) == false) { if(y <= WATER_LEVEL) vmanip.m_data[i] = MapNode(c_water_source); else vmanip.m_data[i] = MapNode(CONTENT_AIR); } else if(noisebuf_cave.get(x,y,z) > CAVE_NOISE_THRESHOLD) vmanip.m_data[i] = MapNode(CONTENT_AIR); else vmanip.m_data[i] = MapNode(c_stone); } vmanip.m_area.add_y(em, i, 1); } } } /* Add mud and sand and others underground (in place of stone) */ for(s16 x=node_min.X; x<=node_max.X; x++) for(s16 z=node_min.Z; z<=node_max.Z; z++) { // Node position v2s16 p2d(x,z); { // Use fast index incrementing v3s16 em = vmanip.m_area.getExtent(); u32 i = vmanip.m_area.index(v3s16(p2d.X, node_max.Y, p2d.Y)); for(s16 y=node_max.Y; y>=node_min.Y; y--) { if(vmanip.m_data[i].getContent() == c_stone) { if(noisebuf_ground_crumbleness.get(x,y,z) > 1.3) { if(noisebuf_ground_wetness.get(x,y,z) > 0.0) vmanip.m_data[i] = MapNode(c_dirt); else vmanip.m_data[i] = MapNode(c_sand); } else if(noisebuf_ground_crumbleness.get(x,y,z) > 0.7) { if(noisebuf_ground_wetness.get(x,y,z) < -0.6) vmanip.m_data[i] = MapNode(c_gravel); } else if(noisebuf_ground_crumbleness.get(x,y,z) < -3.0 + MYMIN(0.1 * sqrt((float)MYMAX(0, -y)), 1.5)) { vmanip.m_data[i] = MapNode(c_lava_source); // TODO: Is this needed? /*for(s16 x1=-1; x1<=1; x1++) for(s16 y1=-1; y1<=1; y1++) for(s16 z1=-1; z1<=1; z1++) data->transforming_liquid.push_back( v3s16(p2d.X+x1, y+y1, p2d.Y+z1));*/ } } vmanip.m_area.add_y(em, i, -1); } } } // Add dungeons { DungeonParams dp; dp.np_rarity = nparams_dungeon_rarity; dp.np_density = nparams_dungeon_density; dp.np_wetness = nparams_dungeon_wetness; dp.c_water = c_water_source; // TODO //if (getBiome(0, v2s16(node_min.X, node_min.Z)) == BT_NORMAL) { if (1) { dp.c_cobble = c_cobble; dp.c_moss = c_mossycobble; dp.c_stair = c_stair_cobble; dp.diagonal_dirs = false; dp.mossratio = 3.0; dp.holesize = v3s16(1, 2, 1); dp.roomsize = v3s16(0, 0, 0); dp.notifytype = GENNOTIFY_DUNGEON; } /*else { dp.c_cobble = c_sandbrick; dp.c_moss = c_sandbrick; // should make this 'cracked sandstone' later dp.c_stair = c_stair_sandstone; dp.diagonal_dirs = true; dp.mossratio = 0.0; dp.holesize = v3s16(2, 3, 2); dp.roomsize = v3s16(2, 5, 2); dp.notifytype = GENNOTIFY_TEMPLE; }*/ DungeonGen dgen(this, &dp); dgen.generate(blockseed, full_node_min, full_node_max); } /* If close to ground level */ //if(abs(approx_ground_depth) < 30) if(minimum_ground_depth < 5 && maximum_ground_depth > -5) { /* Add grass and mud */ for(s16 x=node_min.X; x<=node_max.X; x++) for(s16 z=node_min.Z; z<=node_max.Z; z++) { // Node position v2s16 p2d(x,z); { bool possibly_have_sand = get_have_sand(seed, p2d); bool have_sand = false; u32 current_depth = 0; bool air_detected = false; bool water_detected = false; // Use fast index incrementing s16 start_y = node_max.Y+2; v3s16 em = vmanip.m_area.getExtent(); u32 i = vmanip.m_area.index(v3s16(p2d.X, start_y, p2d.Y)); for(s16 y=start_y; y>=node_min.Y-3; y--) { if(vmanip.m_data[i].getContent() == c_water_source) water_detected = true; if(vmanip.m_data[i].getContent() == CONTENT_AIR) air_detected = true; if((vmanip.m_data[i].getContent() == c_stone || vmanip.m_data[i].getContent() == c_dirt_with_grass || vmanip.m_data[i].getContent() == c_dirt || vmanip.m_data[i].getContent() == c_sand || vmanip.m_data[i].getContent() == c_gravel ) && (air_detected || water_detected)) { if(current_depth == 0 && y <= WATER_LEVEL+2 && possibly_have_sand) have_sand = true; if(current_depth < 4) { if(have_sand) vmanip.m_data[i] = MapNode(c_sand); #if 1 else if(current_depth==0 && !water_detected && y >= WATER_LEVEL && air_detected) vmanip.m_data[i] = MapNode(c_dirt_with_grass); #endif else vmanip.m_data[i] = MapNode(c_dirt); } else { if(vmanip.m_data[i].getContent() == c_dirt || vmanip.m_data[i].getContent() == c_dirt_with_grass) vmanip.m_data[i] = MapNode(c_stone); } current_depth++; if(current_depth >= 8) break; } else if(current_depth != 0) break; vmanip.m_area.add_y(em, i, -1); } } } } }
collisionMoveResult collisionMoveSimple(Environment *env, IGameDef *gamedef, f32 pos_max_d, const aabb3f &box_0, f32 stepheight, f32 dtime, v3f *pos_f, v3f *speed_f, v3f accel_f, ActiveObject *self, bool collideWithObjects) { static bool time_notification_done = false; Map *map = &env->getMap(); //TimeTaker tt("collisionMoveSimple"); ScopeProfiler sp(g_profiler, "collisionMoveSimple avg", SPT_AVG); collisionMoveResult result; /* Calculate new velocity */ if (dtime > 0.5f) { if (!time_notification_done) { time_notification_done = true; infostream << "collisionMoveSimple: maximum step interval exceeded," " lost movement details!"<<std::endl; } dtime = 0.5f; } else { time_notification_done = false; } *speed_f += accel_f * dtime; // If there is no speed, there are no collisions if (speed_f->getLength() == 0) return result; // Limit speed for avoiding hangs speed_f->Y = rangelim(speed_f->Y, -5000, 5000); speed_f->X = rangelim(speed_f->X, -5000, 5000); speed_f->Z = rangelim(speed_f->Z, -5000, 5000); /* Collect node boxes in movement range */ std::vector<NearbyCollisionInfo> cinfo; { //TimeTaker tt2("collisionMoveSimple collect boxes"); ScopeProfiler sp2(g_profiler, "collisionMoveSimple collect boxes avg", SPT_AVG); v3f newpos_f = *pos_f + *speed_f * dtime; v3f minpos_f( MYMIN(pos_f->X, newpos_f.X), MYMIN(pos_f->Y, newpos_f.Y) + 0.01f * BS, // bias rounding, player often at +/-n.5 MYMIN(pos_f->Z, newpos_f.Z) ); v3f maxpos_f( MYMAX(pos_f->X, newpos_f.X), MYMAX(pos_f->Y, newpos_f.Y), MYMAX(pos_f->Z, newpos_f.Z) ); v3s16 min = floatToInt(minpos_f + box_0.MinEdge, BS) - v3s16(1, 1, 1); v3s16 max = floatToInt(maxpos_f + box_0.MaxEdge, BS) + v3s16(1, 1, 1); bool any_position_valid = false; v3s16 p; for (p.X = min.X; p.X <= max.X; p.X++) for (p.Y = min.Y; p.Y <= max.Y; p.Y++) for (p.Z = min.Z; p.Z <= max.Z; p.Z++) { bool is_position_valid; MapNode n = map->getNodeNoEx(p, &is_position_valid); if (is_position_valid && n.getContent() != CONTENT_IGNORE) { // Object collides into walkable nodes any_position_valid = true; const NodeDefManager *nodedef = gamedef->getNodeDefManager(); const ContentFeatures &f = nodedef->get(n); if (!f.walkable) continue; int n_bouncy_value = itemgroup_get(f.groups, "bouncy"); int neighbors = 0; if (f.drawtype == NDT_NODEBOX && f.node_box.type == NODEBOX_CONNECTED) { v3s16 p2 = p; p2.Y++; getNeighborConnectingFace(p2, nodedef, map, n, 1, &neighbors); p2 = p; p2.Y--; getNeighborConnectingFace(p2, nodedef, map, n, 2, &neighbors); p2 = p; p2.Z--; getNeighborConnectingFace(p2, nodedef, map, n, 4, &neighbors); p2 = p; p2.X--; getNeighborConnectingFace(p2, nodedef, map, n, 8, &neighbors); p2 = p; p2.Z++; getNeighborConnectingFace(p2, nodedef, map, n, 16, &neighbors); p2 = p; p2.X++; getNeighborConnectingFace(p2, nodedef, map, n, 32, &neighbors); } std::vector<aabb3f> nodeboxes; n.getCollisionBoxes(gamedef->ndef(), &nodeboxes, neighbors); // Calculate float position only once v3f posf = intToFloat(p, BS); for (auto box : nodeboxes) { box.MinEdge += posf; box.MaxEdge += posf; cinfo.emplace_back(false, false, n_bouncy_value, p, box); } } else { // Collide with unloaded nodes (position invalid) and loaded // CONTENT_IGNORE nodes (position valid) aabb3f box = getNodeBox(p, BS); cinfo.emplace_back(true, false, 0, p, box); } } // Do not move if world has not loaded yet, since custom node boxes // are not available for collision detection. // This also intentionally occurs in the case of the object being positioned // solely on loaded CONTENT_IGNORE nodes, no matter where they come from. if (!any_position_valid) { *speed_f = v3f(0, 0, 0); return result; } } // tt2 if(collideWithObjects) { ScopeProfiler sp2(g_profiler, "collisionMoveSimple objects avg", SPT_AVG); //TimeTaker tt3("collisionMoveSimple collect object boxes"); /* add object boxes to cinfo */ std::vector<ActiveObject*> objects; #ifndef SERVER ClientEnvironment *c_env = dynamic_cast<ClientEnvironment*>(env); if (c_env != 0) { f32 distance = speed_f->getLength(); std::vector<DistanceSortedActiveObject> clientobjects; c_env->getActiveObjects(*pos_f, distance * 1.5f, clientobjects); for (auto &clientobject : clientobjects) { if (!self || (self != clientobject.obj)) { objects.push_back((ActiveObject*) clientobject.obj); } } } else #endif { ServerEnvironment *s_env = dynamic_cast<ServerEnvironment*>(env); if (s_env != NULL) { f32 distance = speed_f->getLength(); std::vector<u16> s_objects; s_env->getObjectsInsideRadius(s_objects, *pos_f, distance * 1.5f); for (u16 obj_id : s_objects) { ServerActiveObject *current = s_env->getActiveObject(obj_id); if (!self || (self != current)) { objects.push_back((ActiveObject*)current); } } } } for (std::vector<ActiveObject*>::const_iterator iter = objects.begin(); iter != objects.end(); ++iter) { ActiveObject *object = *iter; if (object) { aabb3f object_collisionbox; if (object->getCollisionBox(&object_collisionbox) && object->collideWithObjects()) { cinfo.emplace_back(false, true, 0, v3s16(), object_collisionbox); } } } } //tt3 /* Collision detection */ /* Collision uncertainty radius Make it a bit larger than the maximum distance of movement */ f32 d = pos_max_d * 1.1f; // A fairly large value in here makes moving smoother //f32 d = 0.15*BS; // This should always apply, otherwise there are glitches assert(d > pos_max_d); // invariant int loopcount = 0; while(dtime > BS * 1e-10f) { //TimeTaker tt3("collisionMoveSimple dtime loop"); ScopeProfiler sp2(g_profiler, "collisionMoveSimple dtime loop avg", SPT_AVG); // Avoid infinite loop loopcount++; if (loopcount >= 100) { warningstream << "collisionMoveSimple: Loop count exceeded, aborting to avoid infiniite loop" << std::endl; break; } aabb3f movingbox = box_0; movingbox.MinEdge += *pos_f; movingbox.MaxEdge += *pos_f; int nearest_collided = -1; f32 nearest_dtime = dtime; int nearest_boxindex = -1; /* Go through every nodebox, find nearest collision */ for (u32 boxindex = 0; boxindex < cinfo.size(); boxindex++) { const NearbyCollisionInfo &box_info = cinfo[boxindex]; // Ignore if already stepped up this nodebox. if (box_info.is_step_up) continue; // Find nearest collision of the two boxes (raytracing-like) f32 dtime_tmp; int collided = axisAlignedCollision(box_info.box, movingbox, *speed_f, d, &dtime_tmp); if (collided == -1 || dtime_tmp >= nearest_dtime) continue; nearest_dtime = dtime_tmp; nearest_collided = collided; nearest_boxindex = boxindex; } if (nearest_collided == -1) { // No collision with any collision box. *pos_f += *speed_f * dtime; dtime = 0; // Set to 0 to avoid "infinite" loop due to small FP numbers } else { // Otherwise, a collision occurred. NearbyCollisionInfo &nearest_info = cinfo[nearest_boxindex]; const aabb3f& cbox = nearest_info.box; // Check for stairs. bool step_up = (nearest_collided != 1) && // must not be Y direction (movingbox.MinEdge.Y < cbox.MaxEdge.Y) && (movingbox.MinEdge.Y + stepheight > cbox.MaxEdge.Y) && (!wouldCollideWithCeiling(cinfo, movingbox, cbox.MaxEdge.Y - movingbox.MinEdge.Y, d)); // Get bounce multiplier float bounce = -(float)nearest_info.bouncy / 100.0f; // Move to the point of collision and reduce dtime by nearest_dtime if (nearest_dtime < 0) { // Handle negative nearest_dtime (can be caused by the d allowance) if (!step_up) { if (nearest_collided == 0) pos_f->X += speed_f->X * nearest_dtime; if (nearest_collided == 1) pos_f->Y += speed_f->Y * nearest_dtime; if (nearest_collided == 2) pos_f->Z += speed_f->Z * nearest_dtime; } } else { *pos_f += *speed_f * nearest_dtime; dtime -= nearest_dtime; } bool is_collision = true; if (nearest_info.is_unloaded) is_collision = false; CollisionInfo info; if (nearest_info.is_object) info.type = COLLISION_OBJECT; else info.type = COLLISION_NODE; info.node_p = nearest_info.position; info.old_speed = *speed_f; // Set the speed component that caused the collision to zero if (step_up) { // Special case: Handle stairs nearest_info.is_step_up = true; is_collision = false; } else if (nearest_collided == 0) { // X if (fabs(speed_f->X) > BS * 3) speed_f->X *= bounce; else speed_f->X = 0; result.collides = true; } else if (nearest_collided == 1) { // Y if(fabs(speed_f->Y) > BS * 3) speed_f->Y *= bounce; else speed_f->Y = 0; result.collides = true; } else if (nearest_collided == 2) { // Z if (fabs(speed_f->Z) > BS * 3) speed_f->Z *= bounce; else speed_f->Z = 0; result.collides = true; } info.new_speed = *speed_f; if (info.new_speed.getDistanceFrom(info.old_speed) < 0.1f * BS) is_collision = false; if (is_collision) { result.collisions.push_back(info); } } } /* Final touches: Check if standing on ground, step up stairs. */ aabb3f box = box_0; box.MinEdge += *pos_f; box.MaxEdge += *pos_f; for (const auto &box_info : cinfo) { const aabb3f &cbox = box_info.box; /* See if the object is touching ground. Object touches ground if object's minimum Y is near node's maximum Y and object's X-Z-area overlaps with the node's X-Z-area. Use 0.15*BS so that it is easier to get on a node. */ if (cbox.MaxEdge.X - d > box.MinEdge.X && cbox.MinEdge.X + d < box.MaxEdge.X && cbox.MaxEdge.Z - d > box.MinEdge.Z && cbox.MinEdge.Z + d < box.MaxEdge.Z) { if (box_info.is_step_up) { pos_f->Y += cbox.MaxEdge.Y - box.MinEdge.Y; box = box_0; box.MinEdge += *pos_f; box.MaxEdge += *pos_f; } if (std::fabs(cbox.MaxEdge.Y - box.MinEdge.Y) < 0.15f * BS) { result.touching_ground = true; if (box_info.is_object) result.standing_on_object = true; } } } return result; }