Re-add jungles, apple trees

diff --git a/minetest.conf.example b/minetest.conf.example
index 41a691b1a917230140f07752a88e060c658842cc..649717ee8f54ea3d0310650d4868579355bf8e12 100644 (file)
--- a/minetest.conf.example
+++ b/minetest.conf.example
@@ -314,22 +314,25 @@
 #water_level = 1
 # Size of chunks to be generated.
 #chunksize = 5
-# Map generation attributes.  Currently supported: trees, caves, flat, v6_biome_blend
+# Map generation attributes.  Currently supported: trees, caves, flat, v6_biome_blend, v6_jungles
 #mg_flags = trees, caves, v6_biome_blend
 # How large deserts and beaches are
 #mgv6_freq_desert = 0.45
 #mgv6_freq_beach = 0.15
 # Perlin noise attributes for different map generation parameters
 # Offset, scale, spread factor, seed offset, number of octaves, persistence
-#mgv6_np_terrain_base = -4, 20, (250.0, 250, 250), 82341, 5, 0.6
+#mgv6_np_terrain_base = -4, 20, (250, 250, 250), 82341, 5, 0.6
 #mgv6_np_terrain_higher = 20, 16, (500, 500, 500), 85039, 5, 0.6
 #mgv6_np_steepness = 0.85, 0.5, (125, 125, 125), -932, 5, 0.7
 #mgv6_np_height_select = 0.5, 1, (250, 250, 250), 4213, 5, 0.69
-#mgv6_np_trees = 0, 1, (125, 125, 125), 2, 4, 0.66
 #mgv6_np_mud = 4, 2, (200, 200, 200), 91013, 3, 0.55
 #mgv6_np_beach = 0, 1, (250, 250, 250), 59420, 3, 0.50
 #mgv6_np_biome = 0, 1, (250, 250, 250), 9130, 3, 0.50
 #mgv6_np_cave = 6, 6, (250, 250, 250), 34329, 3, 0.50
+#mgv6_np_humidity = 0.5, 0.5, (500, 500, 500), 72384, 4, 0.66
+#mgv6_np_trees = 0, 1, (125, 125, 125), 2, 4, 0.66
+#mgv6_np_apple_trees = 0, 1, (100, 100, 100), 342902, 3, 0.45
+
 #mgv7_np_terrain = 10, 12, (350, 350, 350), 82341, 5, 0.6
 #mgv7_np_bgroup = 0.5, 0.3125, (350, 350, 350), 5923, 2, 0.6
 #mgv7_np_heat = 25, 50, (500, 500, 500), 35293, 1, 0

diff --git a/src/content_abm.cpp b/src/content_abm.cpp
index a88450095398f94d0a868ff245714e51076c2f04..e50edddd7def9aaa8b86f48e8fc6272ff7840bf9 100644 (file)
--- a/src/content_abm.cpp
+++ b/src/content_abm.cpp
@@ -99,6 +99,7 @@ public:
        {
                std::set<std::string> s;
                s.insert("sapling");
+               s.insert("junglesapling");
                return s;
        }
        virtual float getTriggerInterval()
@@ -111,16 +112,25 @@ public:
                INodeDefManager *ndef = env->getGameDef()->ndef();
                ServerMap *map = &env->getServerMap();
                
-               actionstream<<"A sapling grows into a tree at "
-                               <<PP(p)<<std::endl;
+               bool is_jungle_tree = n.getContent() == ndef->getId("junglesapling");
+               
+               actionstream <<"A " << (is_jungle_tree ? "jungle " : "")
+                               << "sapling grows into a tree at "
+                               << PP(p) << std::endl;
 
                std::map<v3s16, MapBlock*> modified_blocks;
                v3s16 tree_p = p;
                ManualMapVoxelManipulator vmanip(map);
                v3s16 tree_blockp = getNodeBlockPos(tree_p);
                vmanip.initialEmerge(tree_blockp - v3s16(1,1,1), tree_blockp + v3s16(1,1,1));
-               bool is_apple_tree = myrand()%4 == 0;
-               treegen::make_tree(vmanip, tree_p, is_apple_tree, ndef, myrand());
+               
+               if (is_jungle_tree) {
+                       treegen::make_jungletree(vmanip, tree_p, ndef, myrand());
+               } else {
+                       bool is_apple_tree = myrand() % 4 == 0;
+                       treegen::make_tree(vmanip, tree_p, is_apple_tree, ndef, myrand());
+               }
+               
                vmanip.blitBackAll(&modified_blocks);
 
                // update lighting

diff --git a/src/defaultsettings.cpp b/src/defaultsettings.cpp
index 8f878648af3e68b1764d1bfc4777b4350bcfcb25..f7724fa110378dc70e5f93e71bb12880cc6fd1dc 100644 (file)
--- a/src/defaultsettings.cpp
+++ b/src/defaultsettings.cpp
@@ -219,15 +219,17 @@ void set_default_settings(Settings *settings)
        settings->setDefault("mgv6_freq_desert", "0.45");
        settings->setDefault("mgv6_freq_beach", "0.15");
 
-       settings->setDefault("mgv6_np_terrain_base",   "-4, 20, (250.0, 250, 250), 82341, 5, 0.6");
+       settings->setDefault("mgv6_np_terrain_base",   "-4, 20, (250, 250, 250), 82341, 5, 0.6");
        settings->setDefault("mgv6_np_terrain_higher", "20, 16, (500, 500, 500), 85039, 5, 0.6");
        settings->setDefault("mgv6_np_steepness",      "0.85, 0.5, (125, 125, 125), -932, 5, 0.7");
        settings->setDefault("mgv6_np_height_select",  "0.5, 1, (250, 250, 250), 4213, 5, 0.69");
-       settings->setDefault("mgv6_np_trees",          "0, 1, (125, 125, 125), 2, 4, 0.66");
        settings->setDefault("mgv6_np_mud",            "4, 2, (200, 200, 200), 91013, 3, 0.55");
        settings->setDefault("mgv6_np_beach",          "0, 1, (250, 250, 250), 59420, 3, 0.50");
        settings->setDefault("mgv6_np_biome",          "0, 1, (250, 250, 250), 9130, 3, 0.50");
        settings->setDefault("mgv6_np_cave",           "6, 6, (250, 250, 250), 34329, 3, 0.50");
+       settings->setDefault("mgv6_np_humidity",       "0.5, 0.5, (500, 500, 500), 72384, 4, 0.66");
+       settings->setDefault("mgv6_np_trees",          "0, 1, (125, 125, 125), 2, 4, 0.66");
+       settings->setDefault("mgv6_np_apple_trees",    "0, 1, (100, 100, 100), 342902, 3, 0.45");
 
        settings->setDefault("mgv7_np_terrain",  "10, 12, (350, 350, 350), 82341, 5, 0.6");
        settings->setDefault("mgv7_np_bgroup",   "0.5, 0.3125, (350, 350, 350), 5923, 2, 0.6");

diff --git a/src/mapgen.cpp b/src/mapgen.cpp
index 699b51789af3619b0a934e808dc488342045a9ac..4316be6fedddc4c460c8c9b198f2e3a45acc9a54 100644 (file)
--- a/src/mapgen.cpp
+++ b/src/mapgen.cpp
@@ -39,7 +39,7 @@ FlagDesc flagdesc_mapgen[] = {
        {"trees",          MG_TREES},
        {"caves",          MG_CAVES},
        {"dungeons",       MG_DUNGEONS},
-       {"v6_forests",     MGV6_FORESTS},
+       {"v6_jungles",     MGV6_JUNGLES},
        {"v6_biome_blend", MGV6_BIOME_BLEND},
        {"flat",           MG_FLAT},
        {NULL,                     0}
@@ -209,16 +209,19 @@ bool MapgenV6Params::readParams(Settings *settings) {
        np_terrain_higher = settings->getNoiseParams("mgv6_np_terrain_higher");
        np_steepness      = settings->getNoiseParams("mgv6_np_steepness");
        np_height_select  = settings->getNoiseParams("mgv6_np_height_select");
-       np_trees          = settings->getNoiseParams("mgv6_np_trees");
        np_mud            = settings->getNoiseParams("mgv6_np_mud");
        np_beach          = settings->getNoiseParams("mgv6_np_beach");
        np_biome          = settings->getNoiseParams("mgv6_np_biome");
        np_cave           = settings->getNoiseParams("mgv6_np_cave");
+       np_humidity       = settings->getNoiseParams("mgv6_np_humidity");
+       np_trees          = settings->getNoiseParams("mgv6_np_trees");
+       np_apple_trees    = settings->getNoiseParams("mgv6_np_apple_trees");
 
        bool success =
                np_terrain_base  && np_terrain_higher && np_steepness &&
                np_height_select && np_trees          && np_mud       &&
-               np_beach         && np_biome          && np_cave;
+               np_beach         && np_biome          && np_cave      &&
+               np_humidity      && np_apple_trees;
        return success;
 }
 
@@ -231,11 +234,13 @@ void MapgenV6Params::writeParams(Settings *settings) {
        settings->setNoiseParams("mgv6_np_terrain_higher", np_terrain_higher);
        settings->setNoiseParams("mgv6_np_steepness",      np_steepness);
        settings->setNoiseParams("mgv6_np_height_select",  np_height_select);
-       settings->setNoiseParams("mgv6_np_trees",          np_trees);
        settings->setNoiseParams("mgv6_np_mud",            np_mud);
        settings->setNoiseParams("mgv6_np_beach",          np_beach);
        settings->setNoiseParams("mgv6_np_biome",          np_biome);
        settings->setNoiseParams("mgv6_np_cave",           np_cave);
+       settings->setNoiseParams("mgv6_np_humidity",       np_humidity);
+       settings->setNoiseParams("mgv6_np_trees",          np_trees);
+       settings->setNoiseParams("mgv6_np_apple_trees",    np_apple_trees);
 }
 
 

diff --git a/src/mapgen.h b/src/mapgen.h
index e5b0b6399680a0b275887c51c56e38fd7d16312f..3f3cd424d0be6caa05877c83867e27f2435f0c12 100644 (file)
--- a/src/mapgen.h
+++ b/src/mapgen.h
@@ -32,7 +32,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #define MG_TREES         0x01
 #define MG_CAVES         0x02
 #define MG_DUNGEONS      0x04
-#define MGV6_FORESTS     0x08
+#define MGV6_JUNGLES     0x08
 #define MGV6_BIOME_BLEND 0x10
 #define MG_FLAT          0x20
 

diff --git a/src/mapgen_v6.cpp b/src/mapgen_v6.cpp
index b60758310a18f8a1b5cd95063980c66bfa7a44ca..dca4e535354a16a4ea8e04e957b48c088f1dc096 100644 (file)
--- a/src/mapgen_v6.cpp
+++ b/src/mapgen_v6.cpp
@@ -45,8 +45,6 @@ NoiseParams nparams_v6_def_steepness =
        {0.85, 0.5, v3f(125.0, 125.0, 125.0), -932, 5, 0.7};
 NoiseParams nparams_v6_def_height_select =
        {0.5, 1.0, v3f(250.0, 250.0, 250.0), 4213, 5, 0.69};
-NoiseParams nparams_v6_def_trees =
-       {0.0, 1.0, v3f(125.0, 125.0, 125.0), 2, 4, 0.66};
 NoiseParams nparams_v6_def_mud =
        {AVERAGE_MUD_AMOUNT, 2.0, v3f(200.0, 200.0, 200.0), 91013, 3, 0.55};
 NoiseParams nparams_v6_def_beach =
@@ -55,6 +53,12 @@ NoiseParams nparams_v6_def_biome =
        {0.0, 1.0, v3f(250.0, 250.0, 250.0), 9130, 3, 0.50};
 NoiseParams nparams_v6_def_cave =
        {6.0, 6.0, v3f(250.0, 250.0, 250.0), 34329, 3, 0.50};
+NoiseParams nparams_v6_def_humidity =
+       {0.5, 0.5, v3f(500.0, 500.0, 500.0), 72384, 4, 0.66};
+NoiseParams nparams_v6_def_trees =
+       {0.0, 1.0, v3f(125.0, 125.0, 125.0), 2, 4, 0.66};
+NoiseParams nparams_v6_def_apple_trees =
+       {0.0, 1.0, v3f(100.0, 100.0, 100.0), 342902, 3, 0.45};
 
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -74,13 +78,15 @@ MapgenV6::MapgenV6(int mapgenid, MapgenV6Params *params) {
 
        this->ystride = csize.X; //////fix this
 
-       np_cave = params->np_cave;
+       np_cave        = params->np_cave;
+       np_humidity    = params->np_humidity;
+       np_trees       = params->np_trees;
+       np_apple_trees = params->np_apple_trees;
 
        noise_terrain_base   = new Noise(params->np_terrain_base,   seed, csize.X, csize.Y);
        noise_terrain_higher = new Noise(params->np_terrain_higher, seed, csize.X, csize.Y);
        noise_steepness      = new Noise(params->np_steepness,      seed, csize.X, csize.Y);
        noise_height_select  = new Noise(params->np_height_select,  seed, csize.X, csize.Y);
-       noise_trees          = new Noise(params->np_trees,          seed, csize.X, csize.Y);
        noise_mud            = new Noise(params->np_mud,            seed, csize.X, csize.Y);
        noise_beach          = new Noise(params->np_beach,          seed, csize.X, csize.Y);
        noise_biome          = new Noise(params->np_biome,          seed, csize.X, csize.Y);
@@ -92,7 +98,6 @@ MapgenV6::~MapgenV6() {
        delete noise_terrain_higher;
        delete noise_steepness;
        delete noise_height_select;
-       delete noise_trees;
        delete noise_mud;
        delete noise_beach;
        delete noise_biome;
@@ -234,12 +239,6 @@ int MapgenV6::getGroundLevelAtPoint(v2s16 p) {
 
 //////////////////////// Noise functions
 
-float MapgenV6::getTreeAmount(v2s16 p) {
-       int index = (p.Y - node_min.Z) * ystride + (p.X - node_min.X);
-       return getTreeAmount(index);
-}
-
-
 float MapgenV6::getMudAmount(v2s16 p) {
        int index = (p.Y - node_min.Z) * ystride + (p.X - node_min.X);
        return getMudAmount(index);
@@ -258,13 +257,30 @@ BiomeType MapgenV6::getBiome(v2s16 p) {
 }
 
 
-float MapgenV6::getTreeAmount(int index)
+float MapgenV6::getHumidity(v2s16 p)
+{
+       /*double noise = noise2d_perlin(
+               0.5+(float)p.X/500, 0.5+(float)p.Y/500,
+               seed+72384, 4, 0.66);
+       noise = (noise + 1.0)/2.0;*/
+
+       float noise = NoisePerlin2D(np_humidity, p.X, p.Y, seed);
+
+       if (noise < 0.0)
+               noise = 0.0;
+       if (noise > 1.0)
+               noise = 1.0;
+       return noise;
+}
+
+
+float MapgenV6::getTreeAmount(v2s16 p)
 {
        /*double noise = noise2d_perlin(
                        0.5+(float)p.X/125, 0.5+(float)p.Y/125,
                        seed+2, 4, 0.66);*/
        
-       float noise = noise_trees->result[index];
+       float noise = NoisePerlin2D(np_trees, p.X, p.Y, seed);
        float zeroval = -0.39;
        if (noise < zeroval)
                return 0;
@@ -273,6 +289,18 @@ float MapgenV6::getTreeAmount(int index)
 }
 
 
+bool MapgenV6::getHaveAppleTree(v2s16 p)
+{
+       /*is_apple_tree = noise2d_perlin(
+               0.5+(float)p.X/100, 0.5+(float)p.Z/100,
+               data->seed+342902, 3, 0.45) > 0.2;*/
+       
+       float noise = NoisePerlin2D(np_apple_trees, p.X, p.Y, seed);
+       
+       return noise > 0.2;
+}
+
+
 float MapgenV6::getMudAmount(int index)
 {
        if (flags & MG_FLAT)
@@ -465,12 +493,6 @@ void MapgenV6::calculateNoise() {
                        x + 0.5 * noise_height_select->np->spread.X,
                        z + 0.5 * noise_height_select->np->spread.Z);
        }
-       
-       if (flags & MG_TREES) {
-               noise_trees->perlinMap2D(
-                       x + 0.5 * noise_trees->np->spread.X,
-                       z + 0.5 * noise_trees->np->spread.Z);
-       }
                
        if (!(flags & MG_FLAT)) {
                noise_mud->perlinMap2D(
@@ -762,6 +784,8 @@ void MapgenV6::addDirtGravelBlobs() {
 
 
 void MapgenV6::placeTrees() {
+       //TimeTaker t("placeTrees");
+       
        // Divide area into parts
        s16 div = 8;
        s16 sidelen = central_area_size.X / div;
@@ -784,8 +808,13 @@ void MapgenV6::placeTrees() {
                        node_min.X + sidelen + sidelen * x0 - 1,
                        node_min.Z + sidelen + sidelen * z0 - 1
                );
-               // Amount of trees
-               u32 tree_count = area * getTreeAmount(p2d_center); /////////////optimize this!
+               
+               // Amount of trees, jungle area
+               u32 tree_count = area * getTreeAmount(p2d_center);
+               bool is_jungle = (flags & MGV6_JUNGLES) && (getHumidity(p2d_center) > 0.75);
+               if (is_jungle)
+                       tree_count *= 4;
+               
                // Put trees in random places on part of division
                for (u32 i = 0; i < tree_count; i++) {
                        s16 x = myrand_range(p2d_min.X, p2d_max.X);
@@ -806,10 +835,18 @@ void MapgenV6::placeTrees() {
                                        continue;
                        }
                        p.Y++;
+                       
                        // Make a tree
-                       treegen::make_tree(*vm, p, false, ndef, myrand());
+                       if (is_jungle) {
+                               treegen::make_jungletree(*vm, p, ndef, myrand());
+                       } else {
+                               bool is_apple_tree = (myrand_range(0, 3) == 0) &&
+                                                                               getHaveAppleTree(v2s16(x, z));
+                               treegen::make_tree(*vm, p, is_apple_tree, ndef, myrand());
+                       }
                }
        }
+       //printf("placeTrees: %dms\n", t.stop());
 }
 
 

diff --git a/src/mapgen_v6.h b/src/mapgen_v6.h
index 7b1e3102062593e4774b6293eb05bfa8a7e59ffb..89d72300ac641ba8d33ee3a2a5f917560171eb9e 100644 (file)
--- a/src/mapgen_v6.h
+++ b/src/mapgen_v6.h
@@ -35,11 +35,13 @@ extern NoiseParams nparams_v6_def_terrain_base;
 extern NoiseParams nparams_v6_def_terrain_higher;
 extern NoiseParams nparams_v6_def_steepness;
 extern NoiseParams nparams_v6_def_height_select;
-extern NoiseParams nparams_v6_def_trees;
 extern NoiseParams nparams_v6_def_mud;
 extern NoiseParams nparams_v6_def_beach;
 extern NoiseParams nparams_v6_def_biome;
 extern NoiseParams nparams_v6_def_cave;
+extern NoiseParams nparams_v6_def_humidity;
+extern NoiseParams nparams_v6_def_trees;
+extern NoiseParams nparams_v6_def_apple_trees;
 
 struct MapgenV6Params : public MapgenParams {
        float freq_desert;
@@ -48,12 +50,14 @@ struct MapgenV6Params : public MapgenParams {
        NoiseParams *np_terrain_higher;
        NoiseParams *np_steepness;
        NoiseParams *np_height_select;
-       NoiseParams *np_trees;
        NoiseParams *np_mud;
        NoiseParams *np_beach;
        NoiseParams *np_biome;
        NoiseParams *np_cave;
-
+       NoiseParams *np_humidity;
+       NoiseParams *np_trees;
+       NoiseParams *np_apple_trees;
+       
        MapgenV6Params() {
                freq_desert       = 0.45;
                freq_beach        = 0.15;
@@ -61,11 +65,14 @@ struct MapgenV6Params : public MapgenParams {
                np_terrain_higher = &nparams_v6_def_terrain_higher;
                np_steepness      = &nparams_v6_def_steepness;
                np_height_select  = &nparams_v6_def_height_select;
-               np_trees          = &nparams_v6_def_trees;
                np_mud            = &nparams_v6_def_mud;
                np_beach          = &nparams_v6_def_beach;
                np_biome          = &nparams_v6_def_biome;
                np_cave           = &nparams_v6_def_cave;
+               np_humidity       = &nparams_v6_def_humidity;
+               np_trees          = &nparams_v6_def_trees;
+               np_apple_trees    = &nparams_v6_def_apple_trees;
+
        }
        
        bool readParams(Settings *settings);
@@ -90,11 +97,13 @@ public:
        Noise *noise_terrain_higher;
        Noise *noise_steepness;
        Noise *noise_height_select;
-       Noise *noise_trees;
        Noise *noise_mud;
        Noise *noise_beach;
        Noise *noise_biome;
        NoiseParams *np_cave;
+       NoiseParams *np_humidity;
+       NoiseParams *np_trees;
+       NoiseParams *np_apple_trees;
        float freq_desert;
        float freq_beach;
        
@@ -126,8 +135,9 @@ public:
        bool block_is_underground(u64 seed, v3s16 blockpos);
        s16 find_ground_level_from_noise(u64 seed, v2s16 p2d, s16 precision);
        
+       float getHumidity(v2s16 p);
        float getTreeAmount(v2s16 p);
-       float getTreeAmount(int index);
+       bool getHaveAppleTree(v2s16 p);
        float getMudAmount(v2s16 p);
        float getMudAmount(int index);
        bool getHaveBeach(v2s16 p);

diff --git a/src/treegen.cpp b/src/treegen.cpp
index 5ddf1132d46810dccd3a7837fde3163a9e9fcc6d..9df528a21fd01191017f8a09a93b4536d76d355c 100644 (file)
--- a/src/treegen.cpp
+++ b/src/treegen.cpp
@@ -510,8 +510,15 @@ v3f transposeMatrix(irr::core::matrix4 M, v3f v)
 void make_jungletree(VoxelManipulator &vmanip, v3s16 p0,
                INodeDefManager *ndef, int seed)
 {
-       MapNode treenode(ndef->getId("mapgen_jungletree"));
-       MapNode leavesnode(ndef->getId("mapgen_leaves"));
+       content_t c_tree   = ndef->getId("mapgen_jungletree");
+       content_t c_leaves = ndef->getId("mapgen_jungleleaves");
+       if (c_tree == CONTENT_IGNORE)
+               c_tree = ndef->getId("mapgen_tree");
+       if (c_leaves == CONTENT_IGNORE)
+               c_leaves = ndef->getId("mapgen_leaves");
+
+       MapNode treenode(c_tree);
+       MapNode leavesnode(c_leaves);
 
        PseudoRandom pr(seed);
        for(s16 x=-1; x<=1; x++)