/* Minetest Copyright (C) 2010-2013 celeron55, Perttu Ahola This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ #include "mapgen.h" #include "voxel.h" #include "noise.h" #include "biome.h" #include "mapblock.h" #include "mapnode.h" #include "map.h" #include "content_sao.h" #include "nodedef.h" #include "content_mapnode.h" // For content_mapnode_get_new_name #include "voxelalgorithms.h" #include "profiler.h" #include "settings.h" // For g_settings #include "main.h" // For g_profiler #include "treegen.h" #include "mapgen_v6.h" #include "mapgen_v7.h" #include "serialization.h" #include "util/serialize.h" #include "filesys.h" #include "log.h" FlagDesc flagdesc_mapgen[] = { {"trees", MG_TREES}, {"caves", MG_CAVES}, {"dungeons", MG_DUNGEONS}, {"flat", MG_FLAT}, {"light", MG_LIGHT}, {NULL, 0} }; FlagDesc flagdesc_ore[] = { {"absheight", OREFLAG_ABSHEIGHT}, {"scatter_noisedensity", OREFLAG_DENSITY}, {"claylike_nodeisnt", OREFLAG_NODEISNT}, {NULL, 0} }; FlagDesc flagdesc_deco_schematic[] = { {"place_center_x", DECO_PLACE_CENTER_X}, {"place_center_y", DECO_PLACE_CENTER_Y}, {"place_center_z", DECO_PLACE_CENTER_Z}, {NULL, 0} }; FlagDesc flagdesc_gennotify[] = { {"dungeon", 1 << GENNOTIFY_DUNGEON}, {"temple", 1 << GENNOTIFY_TEMPLE}, {"cave_begin", 1 << GENNOTIFY_CAVE_BEGIN}, {"cave_end", 1 << GENNOTIFY_CAVE_END}, {"large_cave_begin", 1 << GENNOTIFY_LARGECAVE_BEGIN}, {"large_cave_end", 1 << GENNOTIFY_LARGECAVE_END}, {NULL, 0} }; /////////////////////////////////////////////////////////////////////////////// Ore *createOre(OreType type) { switch (type) { case ORE_SCATTER: return new OreScatter; case ORE_SHEET: return new OreSheet; //case ORE_CLAYLIKE: //TODO: implement this! // return new OreClaylike; default: return NULL; } } Ore::~Ore() { delete np; delete noise; } void Ore::resolveNodeNames(INodeDefManager *ndef) { if (ore == CONTENT_IGNORE) { ore = ndef->getId(ore_name); if (ore == CONTENT_IGNORE) { errorstream << "Ore::resolveNodeNames: ore node '" << ore_name << "' not defined"; ore = CONTENT_AIR; wherein.push_back(CONTENT_AIR); return; } } for (size_t i=0; i != wherein_names.size(); i++) { std::string name = wherein_names[i]; content_t c = ndef->getId(name); if (c != CONTENT_IGNORE) { wherein.push_back(c); } } } void Ore::placeOre(Mapgen *mg, u32 blockseed, v3s16 nmin, v3s16 nmax) { int in_range = 0; in_range |= (nmin.Y <= height_max && nmax.Y >= height_min); if (flags & OREFLAG_ABSHEIGHT) in_range |= (nmin.Y >= -height_max && nmax.Y <= -height_min) << 1; if (!in_range) return; int ymin, ymax; if (in_range & ORE_RANGE_MIRROR) { ymin = MYMAX(nmin.Y, -height_max); ymax = MYMIN(nmax.Y, -height_min); } else { ymin = MYMAX(nmin.Y, height_min); ymax = MYMIN(nmax.Y, height_max); } if (clust_size >= ymax - ymin + 1) return; nmin.Y = ymin; nmax.Y = ymax; generate(mg->vm, mg->seed, blockseed, nmin, nmax); } void OreScatter::generate(ManualMapVoxelManipulator *vm, int seed, u32 blockseed, v3s16 nmin, v3s16 nmax) { PseudoRandom pr(blockseed); MapNode n_ore(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); for (size_t ii = 0; ii < wherein.size(); ii++) if (vm->m_data[i].getContent() == wherein[ii]) vm->m_data[i] = n_ore; } } } void OreSheet::generate(ManualMapVoxelManipulator *vm, int seed, u32 blockseed, v3s16 nmin, v3s16 nmax) { PseudoRandom pr(blockseed + 4234); MapNode n_ore(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 = seed + y_start; noise->perlinMap2D(nmin.X, nmin.Z); int index = 0; for (int z = nmin.Z; z <= nmax.Z; z++) for (int x = nmin.X; x <= nmax.X; x++) { float noiseval = noise->result[index++]; if (noiseval < nthresh) 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; for (size_t ii = 0; ii < wherein.size(); ii++) if (vm->m_data[i].getContent() == wherein[ii]) vm->m_data[i] = n_ore; } } } /////////////////////////////////////////////////////////////////////////////// Decoration *createDecoration(DecorationType type) { switch (type) { case DECO_SIMPLE: return new DecoSimple; case DECO_SCHEMATIC: return new DecoSchematic; //case DECO_LSYSTEM: // return new DecoLSystem; default: return NULL; } } Decoration::Decoration() { mapseed = 0; np = NULL; fill_ratio = 0; sidelen = 1; } Decoration::~Decoration() { delete np; } void Decoration::resolveNodeNames(INodeDefManager *ndef) { this->ndef = ndef; if (c_place_on == CONTENT_IGNORE) c_place_on = ndef->getId(place_on_name); } void Decoration::placeDeco(Mapgen *mg, u32 blockseed, v3s16 nmin, v3s16 nmax) { PseudoRandom 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; sidelen = carea_size; } s16 divlen = carea_size / sidelen; int area = sidelen * sidelen; for (s16 z0 = 0; z0 < divlen; z0++) for (s16 x0 = 0; x0 < divlen; x0++) { v2s16 p2d_center( // Center position of part of division nmin.X + sidelen / 2 + sidelen * x0, nmin.Z + sidelen / 2 + sidelen * z0 ); v2s16 p2d_min( // Minimum edge of part of division nmin.X + sidelen * x0, nmin.Z + sidelen * z0 ); v2s16 p2d_max( // Maximum edge of part of division nmin.X + sidelen + sidelen * x0 - 1, nmin.Z + sidelen + sidelen * z0 - 1 ); // Amount of decorations float nval = np ? NoisePerlin2D(np, p2d_center.X, p2d_center.Y, mapseed) : fill_ratio; u32 deco_count = area * MYMAX(nval, 0.f); for (u32 i = 0; i < deco_count; i++) { s16 x = ps.range(p2d_min.X, p2d_max.X); s16 z = ps.range(p2d_min.Y, p2d_max.Y); 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); if (y < nmin.Y || y > nmax.Y) continue; int height = getHeight(); int max_y = nmax.Y;// + MAP_BLOCKSIZE - 1; if (y + 1 + height > max_y) { continue; #if 0 printf("Decoration at (%d %d %d) cut off\n", x, y, z); //add to queue JMutexAutoLock cutofflock(cutoff_mutex); cutoffs.push_back(CutoffData(x, y, z, height)); #endif } if (mg->biomemap) { std::set::iterator iter; if (biomes.size()) { iter = biomes.find(mg->biomemap[mapindex]); if (iter == biomes.end()) continue; } } generate(mg, &ps, max_y, v3s16(x, y, z)); } } } #if 0 void Decoration::placeCutoffs(Mapgen *mg, u32 blockseed, v3s16 nmin, v3s16 nmax) { PseudoRandom pr(blockseed + 53); std::vector handled_cutoffs; // Copy over the cutoffs we're interested in so we don't needlessly hold a lock { JMutexAutoLock cutofflock(cutoff_mutex); for (std::list::iterator i = cutoffs.begin(); i != cutoffs.end(); ++i) { CutoffData cutoff = *i; v3s16 p = cutoff.p; s16 height = cutoff.height; if (p.X < nmin.X || p.X > nmax.X || p.Z < nmin.Z || p.Z > nmax.Z) continue; if (p.Y + height < nmin.Y || p.Y > nmax.Y) continue; handled_cutoffs.push_back(cutoff); } } // Generate the cutoffs for (size_t i = 0; i != handled_cutoffs.size(); i++) { v3s16 p = handled_cutoffs[i].p; s16 height = handled_cutoffs[i].height; if (p.Y + height > nmax.Y) { //printf("Decoration at (%d %d %d) cut off again!\n", p.X, p.Y, p.Z); cuttoffs.push_back(v3s16(p.X, p.Y, p.Z)); } generate(mg, &pr, nmax.Y, nmin.Y - p.Y, v3s16(p.X, nmin.Y, p.Z)); } // Remove cutoffs that were handled from the cutoff list { JMutexAutoLock cutofflock(cutoff_mutex); for (std::list::iterator i = cutoffs.begin(); i != cutoffs.end(); ++i) { for (size_t j = 0; j != handled_cutoffs.size(); j++) { CutoffData coff = *i; if (coff.p == handled_cutoffs[j].p) i = cutoffs.erase(i); } } } } #endif /////////////////////////////////////////////////////////////////////////////// void DecoSimple::resolveNodeNames(INodeDefManager *ndef) { Decoration::resolveNodeNames(ndef); if (c_deco == CONTENT_IGNORE && !decolist_names.size()) { c_deco = ndef->getId(deco_name); if (c_deco == CONTENT_ minetest.register_alias("clay", "default:clay") minetest.register_alias("brick", "default:brick") minetest.register_alias("tree", "default:tree") minetest.register_alias("jungletree", "default:jungletree") minetest.register_alias("junglegrass", "default:junglegrass") minetest.register_alias("leaves", "default:leaves") minetest.register_alias("cactus", "default:cactus") minetest.register_alias("papyrus", "default:papyrus") minetest.register_alias("bookshelf", "default:bookshelf") minetest.register_alias("glass", "default:glass") minetest.register_alias("wooden_fence", "default:fence_wood") minetest.register_alias("rail", "default:rail") minetest.register_alias("ladder", "default:ladder") minetest.register_alias("wood", "default:wood") minetest.register_alias("mese", "default:mese") minetest.register_alias("cloud", "default:cloud") minetest.register_alias("water_flowing", "default:water_flowing") minetest.register_alias("water_source", "default:water_source") minetest.register_alias("lava_flowing", "default:lava_flowing") minetest.register_alias("lava_source", "default:lava_source") minetest.register_alias("torch", "default:torch") minetest.register_alias("sign_wall", "default:sign_wall") minetest.register_alias("furnace", "default:furnace") minetest.register_alias("chest", "default:chest") minetest.register_alias("locked_chest", "default:chest_locked") minetest.register_alias("cobble", "default:cobble") minetest.register_alias("mossycobble", "default:mossycobble") minetest.register_alias("steelblock", "default:steelblock") minetest.register_alias("nyancat", "default:nyancat") minetest.register_alias("nyancat_rainbow", "default:nyancat_rainbow") minetest.register_alias("sapling", "default:sapling") minetest.register_alias("apple", "default:apple") minetest.register_alias("WPick", "default:pick_wood") minetest.register_alias("STPick", "default:pick_stone") minetest.register_alias("SteelPick", "default:pick_steel") minetest.register_alias("MesePick", "default:pick_mese") minetest.register_alias("WShovel", "default:shovel_wood") minetest.register_alias("STShovel", "default:shovel_stone") minetest.register_alias("SteelShovel", "default:shovel_steel") minetest.register_alias("WAxe", "default:axe_wood") minetest.register_alias("STAxe", "default:axe_stone") minetest.register_alias("SteelAxe", "default:axe_steel") minetest.register_alias("WSword", "default:sword_wood") minetest.register_alias("STSword", "default:sword_stone") minetest.register_alias("SteelSword", "default:sword_steel") minetest.register_alias("Stick", "default:stick") minetest.register_alias("paper", "default:paper") minetest.register_alias("book", "default:book") minetest.register_alias("lump_of_coal", "default:coal_lump") minetest.register_alias("lump_of_iron", "default:iron_lump") minetest.register_alias("lump_of_clay", "default:clay_lump") minetest.register_alias("steel_ingot", "default:steel_ingot") minetest.register_alias("clay_brick", "default:clay_brick") minetest.register_alias("scorched_stuff", "default:scorched_stuff") -- -- Old items -- minetest.register_craftitem(":rat", { description = "Rat", inventory_image = "rat.png", on_drop = function(item, dropper, pos) item:take_item() return item end, on_place = function(item, dropped, pointed) pos = minetest.get_pointed_thing_position(pointed, true) if pos ~= nil then item:take_item() return item end end }) minetest.register_craftitem(":cooked_rat", { description = "Cooked rat", inventory_image = "cooked_rat.png", on_use = minetest.item_eat(6), }) minetest.register_craftitem(":firefly", { description = "Firefly", inventory_image = "firefly.png", on_drop = function(item, dropper, pos) item:take_item() return item end, on_place = function(item, dropped, pointed) pos = minetest.get_pointed_thing_position(pointed,