new mapgen pt1
darkrose
parent
91ca0b97c6
commit
6ba836f726
Binary file not shown.
|
Before Width: | Height: | Size: 204 B |
Binary file not shown.
|
Before Width: | Height: | Size: 317 B |
Binary file not shown.
|
Before Width: | Height: | Size: 139 B |
Binary file not shown.
|
Before Width: | Height: | Size: 192 B |
|
|
@ -196,7 +196,13 @@ set(common_SRCS
|
|||
servercommand.c
|
||||
log.cpp
|
||||
content_sao.cpp
|
||||
mapgen.cpp
|
||||
mapgen/mapgen.cpp
|
||||
mapgen/mapgen_trees.cpp
|
||||
mapgen/mapgen_plants.cpp
|
||||
mapgen/mapgen_dungeon.cpp
|
||||
mapgen/mapgen_util.cpp
|
||||
mapgen/mapgen_space.cpp
|
||||
mapgen/mapgen_thedeep.cpp
|
||||
nodemeta/content_nodemeta_circuits.cpp
|
||||
nodemeta/content_nodemeta_sign.cpp
|
||||
nodemeta/content_nodemeta_flag.cpp
|
||||
|
|
@ -439,10 +445,8 @@ else()
|
|||
set(OPT_FLAGS "${OPT_FLAGS} -march=${CPUTYPE}")
|
||||
endif()
|
||||
|
||||
|
||||
|
||||
set(CMAKE_CXX_FLAGS_RELEASE "${OPT_FLAGS} ${SAFETY_FLAGS} -Wall -DNDEBUG -pipe -fpermissive -Wno-write-strings")
|
||||
set(CMAKE_C_FLAGS_RELEASE "${OPT_FLAGS} ${SAFETY_FLAGS} -Wall -DNDEBUG -pipe -ansi -pedantic")
|
||||
set(CMAKE_C_FLAGS_RELEASE "${OPT_FLAGS} ${SAFETY_FLAGS} -Wall -DNDEBUG -pipe")
|
||||
set(CMAKE_CXX_FLAGS_DEBUG "${SAFETY_FLAGS} -Wall -O0 -g3 -ggdb -fpermissive -Wno-write-strings")
|
||||
set(CMAKE_C_FLAGS_DEBUG ${CMAKE_CXX_FLAGS_DEBUG})
|
||||
|
||||
|
|
|
|||
|
|
@ -5589,7 +5589,6 @@ void meshgen_trunklike(MeshMakeData *data, v3s16 p, MapNode &n, SelectedNode &se
|
|||
float top_scale = 1.0;
|
||||
int height = 0;
|
||||
int dir = 0;
|
||||
int cap = 0;
|
||||
|
||||
content_t thiscontent = n.getContent();
|
||||
|
||||
|
|
@ -5649,8 +5648,7 @@ void meshgen_trunklike(MeshMakeData *data, v3s16 p, MapNode &n, SelectedNode &se
|
|||
}
|
||||
|
||||
if (content_features(thiscontent).param_type == CPT_BLOCKDATA) {
|
||||
height = n.param1&0x0F;
|
||||
cap = n.param1&0x10;
|
||||
height = n.param1&0x1F;
|
||||
dir = (n.param1&0xE0)>>5;
|
||||
}
|
||||
|
||||
|
|
@ -5661,8 +5659,6 @@ void meshgen_trunklike(MeshMakeData *data, v3s16 p, MapNode &n, SelectedNode &se
|
|||
top_height = 16;
|
||||
if (bottom_height > 16)
|
||||
bottom_height = 16;
|
||||
if (cap)
|
||||
top_height = 16;
|
||||
if (dir == 1 || dir == 4) {
|
||||
bottom_scale = (0.0625*(16.0-((float)top_height)));
|
||||
top_scale = (0.0625*(16.0-((float)bottom_height)));
|
||||
|
|
|
|||
28
src/game.cpp
28
src/game.cpp
|
|
@ -1964,18 +1964,19 @@ void the_game(
|
|||
|
||||
{
|
||||
char temptext[300];
|
||||
snprintf(temptext, 300, "%s ("
|
||||
"R: range_all=%i"
|
||||
")"
|
||||
" drawtime=%.0f, dtime_jitter = % .1f %%"
|
||||
", v_range = %.1f, RTT = %.3f",
|
||||
program_name_and_version,
|
||||
draw_control.range_all,
|
||||
drawtime_avg,
|
||||
dtime_jitter1_max_fraction * 100.0,
|
||||
draw_control.wanted_range,
|
||||
client_rtt
|
||||
);
|
||||
snprintf(
|
||||
temptext,
|
||||
300,
|
||||
"%s (R: range_all=%i)"
|
||||
" drawtime=%.0f, dtime_jitter = % .1f %%"
|
||||
", v_range = %.1f, RTT = %.3f",
|
||||
program_name_and_version,
|
||||
draw_control.range_all,
|
||||
drawtime_avg,
|
||||
dtime_jitter1_max_fraction * 100.0,
|
||||
draw_control.wanted_range,
|
||||
client_rtt
|
||||
);
|
||||
|
||||
guitext->setText(narrow_to_wide(temptext).c_str());
|
||||
guitext->setVisible(true);
|
||||
|
|
@ -2285,6 +2286,7 @@ void the_game(
|
|||
}
|
||||
}
|
||||
MapNode snode;
|
||||
uint8_t biome = BIOME_UNKNOWN;
|
||||
v3s16 spos = v3s16(0,0,0);
|
||||
if (show_debug) {
|
||||
if (has_selected_node) {
|
||||
|
|
@ -2294,6 +2296,7 @@ void the_game(
|
|||
spos = floatToInt(pp,BS);
|
||||
}
|
||||
snode = client.getEnv().getMap().getNodeNoEx(spos,NULL);
|
||||
biome = client.getEnv().getMap().getBlockNoCreateNoEx(getNodeBlockPos(spos))->getBiome();
|
||||
}
|
||||
|
||||
LocalPlayer *p = client.getLocalPlayer();
|
||||
|
|
@ -2322,6 +2325,7 @@ void the_game(
|
|||
has_selected_node,
|
||||
spos,
|
||||
snode,
|
||||
biome,
|
||||
client.getEnv().getTime()
|
||||
);
|
||||
}
|
||||
|
|
|
|||
51
src/hud.cpp
51
src/hud.cpp
|
|
@ -393,6 +393,7 @@ void hud_draw(
|
|||
bool selected,
|
||||
v3s16 pos,
|
||||
MapNode node,
|
||||
uint8_t biome,
|
||||
u32 time
|
||||
)
|
||||
{
|
||||
|
|
@ -787,6 +788,9 @@ void hud_draw(
|
|||
case CPT_SPECIAL:
|
||||
txt += L"(CPT_SPECIAL)";
|
||||
break;
|
||||
case CPT_BLOCKDATA:
|
||||
txt += L"(CPT_BLOCKDATA)";
|
||||
break;
|
||||
default:
|
||||
txt += L"(UNKNOWN)";
|
||||
break;
|
||||
|
|
@ -822,6 +826,9 @@ void hud_draw(
|
|||
case CPT_SPECIAL:
|
||||
txt += L"(CPT_SPECIAL)";
|
||||
break;
|
||||
case CPT_BLOCKDATA:
|
||||
txt += L"(CPT_BLOCKDATA)";
|
||||
break;
|
||||
default:
|
||||
txt += L"(UNKNOWN)";
|
||||
break;
|
||||
|
|
@ -834,6 +841,50 @@ void hud_draw(
|
|||
if (selected)
|
||||
txt += L" (selected)";
|
||||
|
||||
txt += L"\nBiome: ";
|
||||
switch (biome) {
|
||||
case BIOME_WOODLANDS:
|
||||
txt += L"Woodlands";
|
||||
break;
|
||||
case BIOME_JUNGLE:
|
||||
txt += L"Jungle";
|
||||
break;
|
||||
case BIOME_OCEAN:
|
||||
txt += L"Ocean";
|
||||
break;
|
||||
case BIOME_DESERT:
|
||||
txt += L"Desert";
|
||||
break;
|
||||
case BIOME_PLAINS:
|
||||
txt += L"Plains";
|
||||
break;
|
||||
case BIOME_FOREST:
|
||||
txt += L"Forest";
|
||||
break;
|
||||
case BIOME_SNOWCAP:
|
||||
txt += L"Snowcaps";
|
||||
break;
|
||||
case BIOME_LAKE:
|
||||
txt += L"Lake";
|
||||
break;
|
||||
case BIOME_BEACH:
|
||||
txt += L"Beach";
|
||||
break;
|
||||
case BIOME_SPACE:
|
||||
txt += L"Space";
|
||||
break;
|
||||
case BIOME_THEDEEP:
|
||||
txt += L"The Deep";
|
||||
break;
|
||||
case BIOME_SKY:
|
||||
txt += L"Sky";
|
||||
break;
|
||||
case BIOME_UNKNOWN:
|
||||
default:
|
||||
txt += L"Unknown";
|
||||
break;
|
||||
}
|
||||
|
||||
v2u32 dim = font->getDimension(txt.c_str());
|
||||
v2s32 sdim(dim.X,dim.Y);
|
||||
v2s32 p(100,screensize.Y-200);
|
||||
|
|
|
|||
|
|
@ -86,6 +86,7 @@ void hud_draw(
|
|||
bool selected,
|
||||
v3s16 pos,
|
||||
MapNode node,
|
||||
uint8_t biome,
|
||||
u32 time
|
||||
);
|
||||
|
||||
|
|
|
|||
16
src/map.cpp
16
src/map.cpp
|
|
@ -1844,6 +1844,8 @@ MapBlock* ServerMap::finishBlockMake(mapgen::BlockMakeData *data,
|
|||
MapBlock *block = getBlockNoCreateNoEx(data->blockpos);
|
||||
assert(block);
|
||||
|
||||
block->setBiome(data->biome);
|
||||
|
||||
{
|
||||
v3s16 p0;
|
||||
for (p0.X=0; p0.X<MAP_BLOCKSIZE; p0.X++) {
|
||||
|
|
@ -1855,7 +1857,7 @@ MapBlock* ServerMap::finishBlockMake(mapgen::BlockMakeData *data,
|
|||
NodeMetadata *f = block->m_node_metadata.get(p0);
|
||||
Inventory *inv = f->getInventory();
|
||||
if (inv) {
|
||||
InventoryList *ilist = inv->getList("0");
|
||||
InventoryList *ilist = inv->getList("main");
|
||||
if (ilist) {
|
||||
if (myrand_range(0,2) == 0)
|
||||
ilist->addItem(new CraftItem(CONTENT_CRAFTITEM_GRAPE,10,0));
|
||||
|
|
@ -2354,18 +2356,6 @@ void ServerMap::loadMapMeta()
|
|||
char* type = config_get("world.map.type");
|
||||
if (!strcmp(type,"flat")) {
|
||||
m_type = MGT_FLAT;
|
||||
}else if (!strcmp(type,"flatter")) {
|
||||
m_type = MGT_FLATTER;
|
||||
}else if (!strcmp(type,"smoother")) {
|
||||
m_type = MGT_SMOOTHER;
|
||||
}else if (!strcmp(type,"hilly")) {
|
||||
m_type = MGT_HILLY;
|
||||
}else if (!strcmp(type,"mountains")) {
|
||||
m_type = MGT_MOUNTAINS;
|
||||
}else if (!strcmp(type,"crazy")) {
|
||||
m_type = MGT_CRAZY;
|
||||
}else if (!strcmp(type,"crazyhills")) {
|
||||
m_type = MGT_CRAZYHILLS;
|
||||
}else{
|
||||
config_set("world.map.type","default");
|
||||
}
|
||||
|
|
|
|||
16
src/map.h
16
src/map.h
|
|
@ -59,6 +59,22 @@ class ServerEnvironment;
|
|||
#define MAPTYPE_SERVER 1
|
||||
#define MAPTYPE_CLIENT 2
|
||||
|
||||
#define BIOME_UNKNOWN 0
|
||||
#define BIOME_WOODLANDS 1
|
||||
#define BIOME_JUNGLE 2
|
||||
#define BIOME_OCEAN 3
|
||||
#define BIOME_DESERT 4
|
||||
#define BIOME_PLAINS 5
|
||||
#define BIOME_FOREST 6
|
||||
#define BIOME_SNOWCAP 7
|
||||
#define BIOME_LAKE 8
|
||||
#define BIOME_BEACH 9
|
||||
#define BIOME_SPACE 10
|
||||
#define BIOME_THEDEEP 11
|
||||
#define BIOME_SKY 12
|
||||
|
||||
#define BIOME_COUNT 13
|
||||
|
||||
enum MapEditEventType{
|
||||
// Node added (changed from air or something else to something)
|
||||
MEET_ADDNODE,
|
||||
|
|
|
|||
|
|
@ -45,6 +45,7 @@ MapBlock::MapBlock(Map *parent, v3s16 pos, bool dummy):
|
|||
last_spawn(0),
|
||||
m_parent(parent),
|
||||
m_pos(pos),
|
||||
m_biome(BIOME_UNKNOWN),
|
||||
m_modified(MOD_STATE_WRITE_NEEDED),
|
||||
is_underground(false),
|
||||
m_lighting_expired(true),
|
||||
|
|
@ -370,6 +371,9 @@ void MapBlock::serialize(std::ostream &os, u8 version)
|
|||
flags |= 0x08;
|
||||
os.write((char*)&flags, 1);
|
||||
|
||||
if (version > 21)
|
||||
os.write((char*)&m_biome,1);
|
||||
|
||||
u32 nodecount = MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE;
|
||||
|
||||
u32 sl = MapNode::serializedLength(version);
|
||||
|
|
@ -424,6 +428,9 @@ void MapBlock::deSerialize(std::istream &is, u8 version)
|
|||
m_generated = (flags & 0x08) ? false : true;
|
||||
u32 sl = MapNode::serializedLength(version);
|
||||
|
||||
if (version > 21)
|
||||
is.read((char*)&m_biome,1);
|
||||
|
||||
// Uncompress data
|
||||
std::ostringstream os(std::ios_base::binary);
|
||||
decompress(is, os, version);
|
||||
|
|
|
|||
|
|
@ -275,6 +275,16 @@ public:
|
|||
return m_pos * MAP_BLOCKSIZE;
|
||||
}
|
||||
|
||||
uint8_t getBiome()
|
||||
{
|
||||
return m_biome;
|
||||
}
|
||||
|
||||
void setBiome(uint8_t biome)
|
||||
{
|
||||
m_biome = biome;
|
||||
}
|
||||
|
||||
core::aabbox3d<s16> getBox()
|
||||
{
|
||||
return core::aabbox3d<s16>(getPosRelative(),
|
||||
|
|
@ -548,6 +558,8 @@ private:
|
|||
// Position in blocks on parent
|
||||
v3s16 m_pos;
|
||||
|
||||
uint8_t m_biome;
|
||||
|
||||
/*
|
||||
If NULL, block is a dummy block.
|
||||
Dummy blocks are used for caching not-found-on-disk blocks.
|
||||
|
|
|
|||
2280
src/mapgen.cpp
2280
src/mapgen.cpp
File diff suppressed because it is too large
Load Diff
77
src/mapgen.h
77
src/mapgen.h
|
|
@ -31,18 +31,35 @@
|
|||
|
||||
class MapBlock;
|
||||
class ManualMapVoxelManipulator;
|
||||
class VoxelManipulator;
|
||||
struct NoiseParams;
|
||||
|
||||
enum MapGenType {
|
||||
MGT_FLAT = 0,
|
||||
MGT_FLATTER,
|
||||
MGT_SMOOTHER,
|
||||
MGT_DEFAULT,
|
||||
MGT_HILLY,
|
||||
MGT_MOUNTAINS,
|
||||
MGT_CRAZY,
|
||||
MGT_CRAZYHILLS
|
||||
MGT_DEFAULT
|
||||
};
|
||||
|
||||
#define SURBIOME_X_MINUS 0
|
||||
#define SURBIOME_X_PLUS 1
|
||||
#define SURBIOME_Z_MINUS 2
|
||||
#define SURBIOME_Z_PLUS 3
|
||||
#define SURBIOME_XZ_MINUS 4
|
||||
#define SURBIOME_XZ_PLUS 5
|
||||
#define SURBIOME_X_MINUS_Z 6
|
||||
#define SURBIOME_Z_MINUS_X 7
|
||||
|
||||
|
||||
#define VMANIP_FLAG_DUNGEON_INSIDE VOXELFLAG_CHECKED1
|
||||
#define VMANIP_FLAG_DUNGEON_PRESERVE VOXELFLAG_CHECKED2
|
||||
#define VMANIP_FLAG_DUNGEON_UNTOUCHABLE (VMANIP_FLAG_DUNGEON_INSIDE|VMANIP_FLAG_DUNGEON_PRESERVE)
|
||||
|
||||
/*
|
||||
Scaling the output of the noise function affects the overdrive of the
|
||||
contour function, which affects the shape of the output considerably.
|
||||
*/
|
||||
#define CAVE_NOISE_SCALE 12.0
|
||||
#define CAVE_NOISE_THRESHOLD (1.5/CAVE_NOISE_SCALE)
|
||||
|
||||
namespace mapgen
|
||||
{
|
||||
struct BlockMakeData
|
||||
|
|
@ -51,6 +68,7 @@ namespace mapgen
|
|||
ManualMapVoxelManipulator *vmanip;
|
||||
uint64_t seed;
|
||||
MapGenType type;
|
||||
uint8_t biome;
|
||||
v3s16 blockpos;
|
||||
UniqueQueue<v3s16> transforming_liquid;
|
||||
|
||||
|
|
@ -67,11 +85,48 @@ namespace mapgen
|
|||
// Main map generation routine
|
||||
void make_block(BlockMakeData *data);
|
||||
|
||||
/*
|
||||
These are used by FarMesh
|
||||
*/
|
||||
/* defined in mapgen_plants.cpp */
|
||||
void make_papyrus(VoxelManipulator &vmanip, v3s16 p0);
|
||||
void make_cactus(VoxelManipulator &vmanip, v3s16 p0);
|
||||
|
||||
/* defined in mapgen_trees.cpp */
|
||||
void make_tree(ManualMapVoxelManipulator &vmanip, v3s16 p0);
|
||||
void make_appletree(ManualMapVoxelManipulator &vmanip, v3s16 p0);
|
||||
void make_conifertree(ManualMapVoxelManipulator &vmanip, v3s16 p0);
|
||||
void make_largetree(ManualMapVoxelManipulator &vmanip, v3s16 p0);
|
||||
void make_jungletree(ManualMapVoxelManipulator &vmanip, v3s16 p0);
|
||||
|
||||
/* defined in mapgen_dungeon.cpp */
|
||||
void make_dungeon(BlockMakeData *data, uint32_t blockseed);
|
||||
|
||||
/* defined in mapgen_util.cpp */
|
||||
NoiseParams get_cave_noise1_params(uint64_t seed);
|
||||
NoiseParams get_cave_noise2_params(uint64_t seed);
|
||||
NoiseParams get_ground_noise1_params(uint64_t seed);
|
||||
NoiseParams get_ground_crumbleness_params(uint64_t seed);
|
||||
NoiseParams get_ground_wetness_params(uint64_t seed);
|
||||
float get_humidity(uint64_t seed, v2s16 p);
|
||||
int16_t get_ground_height(uint64_t seed, v2s16 p);
|
||||
uint32_t get_tree_density(BlockMakeData *data, v2s16 p);
|
||||
uint32_t get_grass_density(BlockMakeData *data, v2s16 p);
|
||||
|
||||
bool is_cave(uint64_t seed, v3s16 p);
|
||||
double debris_amount_2d(uint64_t seed, v2s16 p);
|
||||
double largestone_amount_2d(uint64_t seed, v2s16 p);
|
||||
s16 find_ground_level_from_noise(BlockMakeData *data, v2s16 p2d, s16 precision);
|
||||
double get_sector_average_ground_level(BlockMakeData *data, v2s16 sectorpos);
|
||||
double get_sector_maximum_ground_level(BlockMakeData *data, v2s16 sectorpos);
|
||||
double get_sector_minimum_ground_level(BlockMakeData *data, v2s16 sectorpos);
|
||||
bool block_is_underground(BlockMakeData *data, v3s16 blockpos);
|
||||
bool get_have_sand(uint64_t seed, v2s16 p2d);
|
||||
double tree_amount_2d(uint64_t seed, v2s16 p);
|
||||
float get_biomes(BlockMakeData *data, v3s16 pos, uint8_t biome[2]);
|
||||
void calc_biome(BlockMakeData *data);
|
||||
|
||||
/* defined in mapgen_space.cpp */
|
||||
void make_space(BlockMakeData *data);
|
||||
|
||||
/* defined in mapgen_thedeep.cpp */
|
||||
void make_thedeep(BlockMakeData *data);
|
||||
|
||||
}; // namespace mapgen
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,678 @@
|
|||
/************************************************************************
|
||||
* Minetest-c55
|
||||
* Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
|
||||
*
|
||||
* mapgen.cpp
|
||||
* voxelands - 3d voxel world sandbox game
|
||||
* Copyright (C) Lisa 'darkrose' Milne 2014 <lisa@ltmnet.com>
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 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 General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>
|
||||
*
|
||||
* License updated from GPLv2 or later to GPLv3 or later by Lisa Milne
|
||||
* for Voxelands.
|
||||
************************************************************************/
|
||||
|
||||
#include "mapgen.h"
|
||||
#include "voxel.h"
|
||||
#include "content_mapnode.h"
|
||||
#include "noise.h"
|
||||
#include "mapblock.h"
|
||||
#include "map.h"
|
||||
#include "mineral.h"
|
||||
#include "content_sao.h"
|
||||
|
||||
namespace mapgen
|
||||
{
|
||||
|
||||
void make_block(BlockMakeData *data)
|
||||
{
|
||||
if (data->no_op)
|
||||
return;
|
||||
calc_biome(data);
|
||||
|
||||
if (data->biome == BIOME_THEDEEP) {
|
||||
make_thedeep(data);
|
||||
return;
|
||||
}
|
||||
|
||||
if (data->biome == BIOME_SPACE) {
|
||||
make_space(data);
|
||||
return;
|
||||
}
|
||||
|
||||
v3s16 blockpos = data->blockpos;
|
||||
|
||||
ManualMapVoxelManipulator &vmanip = *(data->vmanip);
|
||||
// Area of center block
|
||||
v3s16 node_min = blockpos*MAP_BLOCKSIZE;
|
||||
v3s16 node_max = (blockpos+v3s16(1,1,1))*MAP_BLOCKSIZE-v3s16(1,1,1);
|
||||
// Full allocated area
|
||||
v3s16 full_node_min = (blockpos-1)*MAP_BLOCKSIZE;
|
||||
|
||||
v2s16 p2d_center(node_min.X+MAP_BLOCKSIZE/2, node_min.Z+MAP_BLOCKSIZE/2);
|
||||
|
||||
|
||||
/*
|
||||
Get average ground level from noise
|
||||
*/
|
||||
|
||||
s16 approx_groundlevel = (s16)get_sector_average_ground_level(data, v2s16(blockpos.X, blockpos.Z));
|
||||
|
||||
s16 approx_ground_depth = approx_groundlevel - (node_min.Y+MAP_BLOCKSIZE/2);
|
||||
|
||||
s16 minimum_groundlevel = (s16)get_sector_minimum_ground_level(data, v2s16(blockpos.X, blockpos.Z));
|
||||
// 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(data, v2s16(blockpos.X, blockpos.Z));
|
||||
// Maximum amount of ground above the bottom of the central block
|
||||
s16 maximum_ground_depth = maximum_groundlevel - node_min.Y;
|
||||
|
||||
/*
|
||||
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)(data->seed%0x100000000ULL) + full_node_min.Z*38134234
|
||||
+ full_node_min.Y*42123 + full_node_min.X*23;
|
||||
|
||||
/*
|
||||
Make some 3D noise
|
||||
*/
|
||||
|
||||
//NoiseBuffer noisebuf1;
|
||||
//NoiseBuffer noisebuf2;
|
||||
NoiseBuffer noisebuf_cave;
|
||||
NoiseBuffer noisebuf_ground_crumbleness;
|
||||
NoiseBuffer 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(data->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(data->seed));
|
||||
#endif
|
||||
|
||||
/*
|
||||
Ground noise
|
||||
*/
|
||||
|
||||
// Sample length
|
||||
v3f sl = v3f(4.0, 4.0, 4.0);
|
||||
|
||||
/*
|
||||
Ground property noise
|
||||
*/
|
||||
sl = v3f(2.5, 2.5, 2.5);
|
||||
noisebuf_ground_crumbleness.create(
|
||||
get_ground_crumbleness_params(data->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(data->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);
|
||||
}
|
||||
|
||||
|
||||
bool limestone = (noisebuf_ground_wetness.get(node_min.X+8,node_min.Y+8,node_min.Z+8) > 0.5);
|
||||
content_t base_content = CONTENT_STONE;
|
||||
if (limestone)
|
||||
base_content = CONTENT_LIMESTONE;
|
||||
|
||||
/*
|
||||
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));
|
||||
int16_t h = get_ground_height(data->seed,p2d);
|
||||
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
|
||||
&& y>h
|
||||
) {
|
||||
if (y <= WATER_LEVEL) {
|
||||
vmanip.m_data[i] = MapNode(CONTENT_WATERSOURCE);
|
||||
}else if (y>=1024) {
|
||||
vmanip.m_data[i] = MapNode(CONTENT_VACUUM);
|
||||
}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(base_content);
|
||||
}
|
||||
}
|
||||
|
||||
data->vmanip->m_area.add_y(em, i, 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
Add minerals
|
||||
*/
|
||||
|
||||
{
|
||||
PseudoRandom mineralrandom(blockseed);
|
||||
|
||||
/*
|
||||
Add mithril blocks
|
||||
*/
|
||||
for (s16 i=0; i<approx_ground_depth/4; i++) {
|
||||
if (mineralrandom.next()%50 == 0) {
|
||||
s16 x = mineralrandom.range(node_min.X+1, node_max.X-1);
|
||||
s16 y = mineralrandom.range(node_min.Y+1, node_max.Y-1);
|
||||
s16 z = mineralrandom.range(node_min.Z+1, node_max.Z-1);
|
||||
// TODO: at random, some should be gems
|
||||
u8 type = mineralrandom.next()%12;
|
||||
switch (type) {
|
||||
case 0:
|
||||
type = MINERAL_RUBY;
|
||||
break;
|
||||
case 1:
|
||||
type = MINERAL_TURQUOISE;
|
||||
break;
|
||||
case 2:
|
||||
type = MINERAL_AMETHYST;
|
||||
break;
|
||||
case 3:
|
||||
type = MINERAL_SAPPHIRE;
|
||||
break;
|
||||
case 4:
|
||||
type = MINERAL_SUNSTONE;
|
||||
break;
|
||||
default:
|
||||
type = MINERAL_MITHRIL;
|
||||
}
|
||||
for (u16 i=0; i<27; i++) {
|
||||
v3s16 p = v3s16(x,y,z) + g_27dirs[i];
|
||||
u32 vi = vmanip.m_area.index(p);
|
||||
if (vmanip.m_data[vi].getContent() == base_content && mineralrandom.next()%8 == 0)
|
||||
vmanip.m_data[vi] = MapNode(base_content,type);
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
/*
|
||||
Add others
|
||||
*/
|
||||
if (limestone) {
|
||||
/*
|
||||
Add tin/quartz (and rare coal)
|
||||
*/
|
||||
u16 a = mineralrandom.range(0,15);
|
||||
a = a*a*a;
|
||||
u16 amount = 20;
|
||||
u16 rareness = 40 / amount;
|
||||
if (rareness == 0)
|
||||
rareness = 1;
|
||||
if (mineralrandom.next()%rareness == 0) {
|
||||
u16 a = mineralrandom.next() % 16;
|
||||
u16 amnt = amount * a*a*a / 1000;
|
||||
for (s16 i=0; i<amnt; i++) {
|
||||
s16 x = mineralrandom.range(node_min.X+1, node_max.X-1);
|
||||
s16 y = mineralrandom.range(node_min.Y+1, node_max.Y-1);
|
||||
s16 z = mineralrandom.range(node_min.Z+1, node_max.Z-1);
|
||||
u8 type = mineralrandom.next()%12;
|
||||
if (type == 0) {
|
||||
type = MINERAL_COAL;
|
||||
}else if (type > 8) {
|
||||
type = MINERAL_QUARTZ;
|
||||
}else if (type > 4) {
|
||||
type = MINERAL_COPPER;
|
||||
}else{
|
||||
type = MINERAL_TIN;
|
||||
}
|
||||
for (u16 i=0; i<27; i++) {
|
||||
v3s16 p = v3s16(x,y,z) + g_27dirs[i];
|
||||
u32 vi = vmanip.m_area.index(p);
|
||||
if (vmanip.m_data[vi].getContent() == CONTENT_LIMESTONE && mineralrandom.next()%8 == 0)
|
||||
vmanip.m_data[vi] = MapNode(CONTENT_LIMESTONE, type);
|
||||
}
|
||||
}
|
||||
}
|
||||
}else{
|
||||
{
|
||||
u16 a = mineralrandom.range(0,15);
|
||||
a = a*a*a;
|
||||
u16 amount = 20 * a/1000;
|
||||
for (s16 i=0; i<amount; i++) {
|
||||
s16 x = mineralrandom.range(node_min.X+1, node_max.X-1);
|
||||
s16 y = mineralrandom.range(node_min.Y+1, node_max.Y-1);
|
||||
s16 z = mineralrandom.range(node_min.Z+1, node_max.Z-1);
|
||||
|
||||
u8 base_content = CONTENT_STONE;
|
||||
MapNode new_content(CONTENT_IGNORE);
|
||||
u32 sparseness = 6;
|
||||
|
||||
if (noisebuf_ground_crumbleness.get(x,y+5,z) < -0.1) {
|
||||
new_content = MapNode(CONTENT_STONE, MINERAL_COAL);
|
||||
}else if (noisebuf_ground_wetness.get(x,y+5,z) > 0.1) {
|
||||
new_content = MapNode(CONTENT_STONE, MINERAL_IRON);
|
||||
}else if (noisebuf_ground_crumbleness.get(x,y,z) > 0.4) {
|
||||
new_content = MapNode(CONTENT_STONE, MINERAL_SILVER);
|
||||
}else if (noisebuf_ground_crumbleness.get(x,y,z) > 0.3) {
|
||||
new_content = MapNode(CONTENT_STONE, MINERAL_QUARTZ);
|
||||
}else if (noisebuf_ground_crumbleness.get(x,y,z) > 0.2) {
|
||||
new_content = MapNode(CONTENT_STONE, MINERAL_COPPER);
|
||||
}else if (noisebuf_ground_crumbleness.get(x,y,z) > 0.1) {
|
||||
new_content = MapNode(CONTENT_STONE, MINERAL_TIN);
|
||||
}else if (noisebuf_ground_wetness.get(x,y+5,z) > 0.0) {
|
||||
new_content = MapNode(CONTENT_STONE, MINERAL_GOLD);
|
||||
}
|
||||
|
||||
if (new_content.getContent() != CONTENT_IGNORE) {
|
||||
for (u16 i=0; i<27; i++) {
|
||||
v3s16 p = v3s16(x,y,z) + g_27dirs[i];
|
||||
u32 vi = vmanip.m_area.index(p);
|
||||
if (vmanip.m_data[vi].getContent() == base_content && mineralrandom.next()%sparseness == 0)
|
||||
vmanip.m_data[vi] = new_content;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
/*
|
||||
Add coal
|
||||
*/
|
||||
u16 coal_amount = 30;
|
||||
u16 coal_rareness = 60 / coal_amount;
|
||||
if (coal_rareness == 0)
|
||||
coal_rareness = 1;
|
||||
if (mineralrandom.next()%coal_rareness == 0) {
|
||||
u16 a = mineralrandom.next() % 16;
|
||||
u16 amount = coal_amount * a*a*a / 1000;
|
||||
for (s16 i=0; i<amount; i++) {
|
||||
s16 x = mineralrandom.range(node_min.X+1, node_max.X-1);
|
||||
s16 y = mineralrandom.range(node_min.Y+1, node_max.Y-1);
|
||||
s16 z = mineralrandom.range(node_min.Z+1, node_max.Z-1);
|
||||
for (u16 i=0; i<27; i++) {
|
||||
v3s16 p = v3s16(x,y,z) + g_27dirs[i];
|
||||
u32 vi = vmanip.m_area.index(p);
|
||||
if (vmanip.m_data[vi].getContent() == CONTENT_STONE && mineralrandom.next()%8 == 0)
|
||||
vmanip.m_data[vi] = MapNode(CONTENT_STONE, MINERAL_COAL);
|
||||
}
|
||||
}
|
||||
}
|
||||
/*
|
||||
Add iron
|
||||
*/
|
||||
u16 iron_amount = 8;
|
||||
u16 iron_rareness = 60 / iron_amount;
|
||||
if (iron_rareness == 0)
|
||||
iron_rareness = 1;
|
||||
if (mineralrandom.next()%iron_rareness == 0) {
|
||||
u16 a = mineralrandom.next() % 16;
|
||||
u16 amount = iron_amount * a*a*a / 1000;
|
||||
for (s16 i=0; i<amount; i++) {
|
||||
s16 x = mineralrandom.range(node_min.X+1, node_max.X-1);
|
||||
s16 y = mineralrandom.range(node_min.Y+1, node_max.Y-1);
|
||||
s16 z = mineralrandom.range(node_min.Z+1, node_max.Z-1);
|
||||
for (u16 i=0; i<27; i++) {
|
||||
v3s16 p = v3s16(x,y,z) + g_27dirs[i];
|
||||
u32 vi = vmanip.m_area.index(p);
|
||||
if (vmanip.m_data[vi].getContent() == CONTENT_STONE && mineralrandom.next()%8 == 0)
|
||||
vmanip.m_data[vi] = MapNode(CONTENT_STONE, MINERAL_IRON);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
Add mud and sand and others underground (in place of stone)
|
||||
*/
|
||||
content_t liquid_type = CONTENT_LAVASOURCE;
|
||||
if (limestone || blockpos.Y > -1 || ((blockpos.X + blockpos.Z)/blockpos.Y+1)%16 == 0)
|
||||
liquid_type = CONTENT_WATERSOURCE;
|
||||
|
||||
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() == base_content) {
|
||||
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(CONTENT_MUD);
|
||||
}else{
|
||||
vmanip.m_data[i] = MapNode(CONTENT_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(CONTENT_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(liquid_type);
|
||||
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));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
data->vmanip->m_area.add_y(em, i, -1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Add dungeons */
|
||||
if (
|
||||
!limestone
|
||||
&& (data->biome == BIOME_WOODLANDS || data->biome == BIOME_JUNGLE || data->biome == BIOME_DESERT)
|
||||
&& ((noise3d(blockpos.X,blockpos.Y,blockpos.Z,data->seed)+1.0)/2.0) < 0.2
|
||||
&& node_min.Y < approx_groundlevel
|
||||
) {
|
||||
make_dungeon(data,blockseed);
|
||||
}
|
||||
|
||||
/*
|
||||
Add top and bottom side of water to transforming_liquid queue
|
||||
*/
|
||||
|
||||
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 water_found = false;
|
||||
// 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 (!water_found) {
|
||||
if (vmanip.m_data[i].getContent() == CONTENT_WATERSOURCE) {
|
||||
v3s16 p = v3s16(p2d.X, y, p2d.Y);
|
||||
data->transforming_liquid.push_back(p);
|
||||
water_found = true;
|
||||
}
|
||||
}else{
|
||||
// This can be done because water_found can only
|
||||
// turn to true and end up here after going through
|
||||
// a single block.
|
||||
if (vmanip.m_data[i+1].getContent() != CONTENT_WATERSOURCE) {
|
||||
v3s16 p = v3s16(p2d.X, y+1, p2d.Y);
|
||||
data->transforming_liquid.push_back(p);
|
||||
water_found = false;
|
||||
}
|
||||
}
|
||||
|
||||
data->vmanip->m_area.add_y(em, i, -1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
If close to ground level
|
||||
*/
|
||||
|
||||
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);
|
||||
{
|
||||
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() == CONTENT_WATERSOURCE)
|
||||
water_detected = true;
|
||||
if (vmanip.m_data[i].getContent() == CONTENT_AIR)
|
||||
air_detected = true;
|
||||
|
||||
if (
|
||||
(
|
||||
vmanip.m_data[i].getContent() == base_content
|
||||
|| vmanip.m_data[i].getContent() == CONTENT_MUD
|
||||
|| vmanip.m_data[i].getContent() == CONTENT_SAND
|
||||
|| vmanip.m_data[i].getContent() == CONTENT_GRAVEL
|
||||
) && (
|
||||
air_detected || water_detected
|
||||
)
|
||||
) {
|
||||
if (data->biome == BIOME_DESERT) {
|
||||
vmanip.m_data[i] = MapNode(CONTENT_DESERT_SAND);
|
||||
}else if (current_depth < 4) {
|
||||
if (data->biome == BIOME_BEACH || data->biome == BIOME_OCEAN) {
|
||||
vmanip.m_data[i] = MapNode(CONTENT_SAND);
|
||||
}else if (current_depth==0 && !water_detected && y >= WATER_LEVEL && air_detected) {
|
||||
if (data->biome == BIOME_SNOWCAP) {
|
||||
vmanip.m_data[i] = MapNode(CONTENT_MUD,0x04);
|
||||
}else if (data->biome == BIOME_JUNGLE) {
|
||||
if (noisebuf_ground_wetness.get(x,y,z) > 1.0) {
|
||||
vmanip.m_data[i] = MapNode(CONTENT_CLAY,0x08);
|
||||
}else{
|
||||
vmanip.m_data[i] = MapNode(CONTENT_MUD,0x08);
|
||||
}
|
||||
}else if (noisebuf_ground_wetness.get(x,y,z) > 1.0) {
|
||||
vmanip.m_data[i] = MapNode(CONTENT_CLAY,0x01);
|
||||
}else{
|
||||
vmanip.m_data[i] = MapNode(CONTENT_MUD,0x01);
|
||||
}
|
||||
}else{
|
||||
vmanip.m_data[i] = MapNode(CONTENT_MUD);
|
||||
}
|
||||
}else{
|
||||
if (vmanip.m_data[i].getContent() == CONTENT_MUD)
|
||||
vmanip.m_data[i] = MapNode(base_content);
|
||||
}
|
||||
|
||||
current_depth++;
|
||||
|
||||
if (current_depth >= 8)
|
||||
break;
|
||||
}else if (current_depth != 0) {
|
||||
break;
|
||||
}
|
||||
|
||||
data->vmanip->m_area.add_y(em, i, -1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* add trees */
|
||||
u32 tree_count = get_tree_density(data, p2d_center);
|
||||
if (tree_count) {
|
||||
PseudoRandom treerandom(blockseed);
|
||||
// Put trees in random places on part of division
|
||||
for (u32 i=0; i<tree_count; i++) {
|
||||
s16 x = treerandom.range(node_min.X, node_max.X);
|
||||
s16 z = treerandom.range(node_min.Z, node_max.Z);
|
||||
s16 y = find_ground_level_from_noise(data, v2s16(x,z), 4);
|
||||
// Don't make a tree under water level
|
||||
if (y < WATER_LEVEL)
|
||||
continue;
|
||||
// Make sure tree fits (only trees whose starting point is
|
||||
// at this block are added)
|
||||
if (y < node_min.Y || y > node_max.Y)
|
||||
continue;
|
||||
/*
|
||||
Find exact ground level
|
||||
*/
|
||||
v3s16 p(x,y+6,z);
|
||||
bool found = false;
|
||||
for (; p.Y >= y-6; p.Y--) {
|
||||
u32 i = data->vmanip->m_area.index(p);
|
||||
MapNode *n = &data->vmanip->m_data[i];
|
||||
if (n->getContent() != CONTENT_AIR && n->getContent() != CONTENT_WATERSOURCE && n->getContent() != CONTENT_IGNORE) {
|
||||
found = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
// If not found, handle next one
|
||||
if (found == false)
|
||||
continue;
|
||||
|
||||
{
|
||||
u32 i = data->vmanip->m_area.index(p);
|
||||
MapNode *n = &data->vmanip->m_data[i];
|
||||
|
||||
if (n->getContent() == CONTENT_MUD) {
|
||||
// Papyrus grows only on mud and in water
|
||||
if (y <= WATER_LEVEL) {
|
||||
p.Y++;
|
||||
make_papyrus(vmanip, p);
|
||||
// Trees grow only on mud and grass, on land
|
||||
}else if (data->biome == BIOME_LAKE) {
|
||||
make_appletree(vmanip, p);
|
||||
}else if (y > (WATER_LEVEL+2)) {
|
||||
p.Y++;
|
||||
if (data->biome == BIOME_JUNGLE) {
|
||||
make_jungletree(vmanip, p);
|
||||
// connifers
|
||||
}else if (data->biome == BIOME_SNOWCAP) {
|
||||
make_conifertree(vmanip, p);
|
||||
}else if (data->biome == BIOME_PLAINS) {
|
||||
make_tree(vmanip, p);
|
||||
// regular trees
|
||||
}else if (myrand_range(0,10) != 0) {
|
||||
make_tree(vmanip, p);
|
||||
}else{
|
||||
make_largetree(vmanip, p);
|
||||
}
|
||||
}
|
||||
// Cactii grow only on sand, on land
|
||||
}else if (n->getContent() == CONTENT_DESERT_SAND) {
|
||||
if (y > (WATER_LEVEL+2)) {
|
||||
p.Y++;
|
||||
make_cactus(vmanip, p);
|
||||
}
|
||||
// bushes on clay
|
||||
}else if (n->getContent() == CONTENT_CLAY) {
|
||||
if (y > WATER_LEVEL+5) {
|
||||
p.Y++;
|
||||
if (vmanip.m_area.contains(p)) {
|
||||
if (data->biome == BIOME_JUNGLE) {
|
||||
vmanip.m_data[vmanip.m_area.index(p)] = MapNode(CONTENT_BUSH_RASPBERRY);
|
||||
}else if (data->biome == BIOME_FOREST || data->biome == BIOME_LAKE || data->biome == BIOME_WOODLANDS) {
|
||||
vmanip.m_data[vmanip.m_area.index(p)] = MapNode(CONTENT_BUSH_BLUEBERRY);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* add grasses */
|
||||
u32 grass_count = get_grass_density(data, p2d_center);
|
||||
if (grass_count) {
|
||||
PseudoRandom grassrandom(blockseed);
|
||||
for (u32 i=0; i<4*tree_count; i++) {
|
||||
s16 x = grassrandom.range(node_min.X, node_max.X);
|
||||
s16 z = grassrandom.range(node_min.Z, node_max.Z);
|
||||
s16 y = get_ground_height(data->seed, v2s16(x,z));
|
||||
if (y < WATER_LEVEL)
|
||||
continue;
|
||||
if (y < node_min.Y || y > node_max.Y)
|
||||
continue;
|
||||
/*
|
||||
Find exact ground level
|
||||
*/
|
||||
v3s16 p(x,y+6,z);
|
||||
bool found = false;
|
||||
for (; p.Y >= y-6; p.Y--) {
|
||||
u32 i = data->vmanip->m_area.index(p);
|
||||
MapNode *n = &data->vmanip->m_data[i];
|
||||
if (content_features(*n).is_ground_content || n->getContent() == CONTENT_JUNGLETREE) {
|
||||
found = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
// If not found, handle next one
|
||||
if (found == false)
|
||||
continue;
|
||||
p.Y++;
|
||||
if (vmanip.m_area.contains(p) == false)
|
||||
continue;
|
||||
if (vmanip.m_data[vmanip.m_area.index(p)].getContent() != CONTENT_AIR)
|
||||
continue;
|
||||
if (vmanip.m_area.contains(p)) {
|
||||
if (data->biome != BIOME_JUNGLE) {
|
||||
vmanip.m_data[vmanip.m_area.index(p)] = CONTENT_WILDGRASS_LONG;
|
||||
}else if (y < 30 && myrand_range(0,20) == 0) {
|
||||
if (y > 20) {
|
||||
vmanip.m_data[vmanip.m_area.index(p)] = CONTENT_TEA;
|
||||
}else{
|
||||
vmanip.m_data[vmanip.m_area.index(p)] = CONTENT_COFFEE;
|
||||
}
|
||||
}else if (myrand_range(0,3) == 0) {
|
||||
vmanip.m_data[vmanip.m_area.index(p)] = CONTENT_JUNGLEFERN;
|
||||
}else{
|
||||
vmanip.m_data[vmanip.m_area.index(p)] = CONTENT_JUNGLEGRASS;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
BlockMakeData::BlockMakeData():
|
||||
no_op(false),
|
||||
vmanip(NULL),
|
||||
seed(0),
|
||||
type(MGT_DEFAULT),
|
||||
biome(BIOME_UNKNOWN)
|
||||
{
|
||||
}
|
||||
|
||||
BlockMakeData::~BlockMakeData()
|
||||
{
|
||||
delete vmanip;
|
||||
}
|
||||
|
||||
}; // namespace mapgen
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,588 @@
|
|||
/************************************************************************
|
||||
* Minetest-c55
|
||||
* Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
|
||||
*
|
||||
* mapgen.cpp
|
||||
* voxelands - 3d voxel world sandbox game
|
||||
* Copyright (C) Lisa 'darkrose' Milne 2014-2017 <lisa@ltmnet.com>
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 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 General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>
|
||||
*
|
||||
* License updated from GPLv2 or later to GPLv3 or later by Lisa Milne
|
||||
* for Voxelands.
|
||||
************************************************************************/
|
||||
|
||||
#include "mapgen.h"
|
||||
#include "voxel.h"
|
||||
#include "content_mapnode.h"
|
||||
#include "map.h"
|
||||
#include "noise.h"
|
||||
|
||||
namespace mapgen
|
||||
{
|
||||
|
||||
|
||||
static void make_room1(VoxelManipulator &vmanip, v3s16 roomsize, v3s16 roomplace)
|
||||
{
|
||||
// Make +-X walls
|
||||
for (s16 z=0; z<roomsize.Z; z++)
|
||||
for (s16 y=0; y<roomsize.Y; y++) {
|
||||
{
|
||||
v3s16 p = roomplace + v3s16(0,y,z);
|
||||
if (vmanip.m_area.contains(p) == false)
|
||||
continue;
|
||||
u32 vi = vmanip.m_area.index(p);
|
||||
if (vmanip.m_flags[vi] & VMANIP_FLAG_DUNGEON_UNTOUCHABLE)
|
||||
continue;
|
||||
vmanip.m_data[vi] = MapNode(CONTENT_COBBLE);
|
||||
}
|
||||
{
|
||||
v3s16 p = roomplace + v3s16(roomsize.X-1,y,z);
|
||||
if (vmanip.m_area.contains(p) == false)
|
||||
continue;
|
||||
u32 vi = vmanip.m_area.index(p);
|
||||
if (vmanip.m_flags[vi] & VMANIP_FLAG_DUNGEON_UNTOUCHABLE)
|
||||
continue;
|
||||
vmanip.m_data[vi] = MapNode(CONTENT_COBBLE);
|
||||
}
|
||||
}
|
||||
|
||||
// Make +-Z walls
|
||||
for (s16 x=0; x<roomsize.X; x++)
|
||||
for (s16 y=0; y<roomsize.Y; y++) {
|
||||
{
|
||||
v3s16 p = roomplace + v3s16(x,y,0);
|
||||
if (vmanip.m_area.contains(p) == false)
|
||||
continue;
|
||||
u32 vi = vmanip.m_area.index(p);
|
||||
if (vmanip.m_flags[vi] & VMANIP_FLAG_DUNGEON_UNTOUCHABLE)
|
||||
continue;
|
||||
vmanip.m_data[vi] = MapNode(CONTENT_COBBLE);
|
||||
}
|
||||
{
|
||||
v3s16 p = roomplace + v3s16(x,y,roomsize.Z-1);
|
||||
if (vmanip.m_area.contains(p) == false)
|
||||
continue;
|
||||
u32 vi = vmanip.m_area.index(p);
|
||||
if (vmanip.m_flags[vi] & VMANIP_FLAG_DUNGEON_UNTOUCHABLE)
|
||||
continue;
|
||||
vmanip.m_data[vi] = MapNode(CONTENT_COBBLE);
|
||||
}
|
||||
}
|
||||
|
||||
// Make +-Y walls (floor and ceiling)
|
||||
for (s16 z=0; z<roomsize.Z; z++)
|
||||
for (s16 x=0; x<roomsize.X; x++) {
|
||||
{
|
||||
v3s16 p = roomplace + v3s16(x,0,z);
|
||||
if (vmanip.m_area.contains(p) == false)
|
||||
continue;
|
||||
u32 vi = vmanip.m_area.index(p);
|
||||
if (vmanip.m_flags[vi] & VMANIP_FLAG_DUNGEON_UNTOUCHABLE)
|
||||
continue;
|
||||
vmanip.m_data[vi] = MapNode(CONTENT_COBBLE);
|
||||
}
|
||||
{
|
||||
v3s16 p = roomplace + v3s16(x,roomsize.Y-1,z);
|
||||
if (vmanip.m_area.contains(p) == false)
|
||||
continue;
|
||||
u32 vi = vmanip.m_area.index(p);
|
||||
if (vmanip.m_flags[vi] & VMANIP_FLAG_DUNGEON_UNTOUCHABLE)
|
||||
continue;
|
||||
vmanip.m_data[vi] = MapNode(CONTENT_COBBLE);
|
||||
}
|
||||
}
|
||||
|
||||
// Fill with air
|
||||
for (s16 z=1; z<roomsize.Z-1; z++)
|
||||
for (s16 y=1; y<roomsize.Y-1; y++)
|
||||
for (s16 x=1; x<roomsize.X-1; x++) {
|
||||
v3s16 p = roomplace + v3s16(x,y,z);
|
||||
if (vmanip.m_area.contains(p) == false)
|
||||
continue;
|
||||
u32 vi = vmanip.m_area.index(p);
|
||||
vmanip.m_flags[vi] |= VMANIP_FLAG_DUNGEON_UNTOUCHABLE;
|
||||
vmanip.m_data[vi] = MapNode(CONTENT_AIR);
|
||||
}
|
||||
|
||||
//if (myrand_range(0,4) == 0) {
|
||||
{
|
||||
v3s16 p = roomplace + v3s16(2,1,2);
|
||||
if (vmanip.m_area.contains(p) == false)
|
||||
return;
|
||||
u32 vi = vmanip.m_area.index(p);
|
||||
if (vmanip.m_data[vi].getContent() == CONTENT_AIR) {
|
||||
vmanip.m_flags[vi] |= VMANIP_FLAG_DUNGEON_UNTOUCHABLE;
|
||||
vmanip.m_data[vi] = MapNode(CONTENT_CHEST);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void make_fill(VoxelManipulator &vmanip, v3s16 place, v3s16 size,
|
||||
u8 avoid_flags, MapNode n, u8 or_flags)
|
||||
{
|
||||
for (s16 z=0; z<size.Z; z++)
|
||||
for (s16 y=0; y<size.Y; y++)
|
||||
for (s16 x=0; x<size.X; x++) {
|
||||
v3s16 p = place + v3s16(x,y,z);
|
||||
if (vmanip.m_area.contains(p) == false)
|
||||
continue;
|
||||
u32 vi = vmanip.m_area.index(p);
|
||||
if (vmanip.m_flags[vi] & avoid_flags)
|
||||
continue;
|
||||
if (
|
||||
vmanip.m_data[vi].getContent() != CONTENT_STONE
|
||||
&& vmanip.m_data[vi].getContent() != CONTENT_SAND
|
||||
&& vmanip.m_data[vi].getContent() != CONTENT_GRAVEL
|
||||
&& vmanip.m_data[vi].getContent() != CONTENT_COBBLE
|
||||
&& vmanip.m_data[vi].getContent() != CONTENT_IGNORE
|
||||
)
|
||||
continue;
|
||||
vmanip.m_flags[vi] |= or_flags;
|
||||
vmanip.m_data[vi] = n;
|
||||
}
|
||||
}
|
||||
|
||||
static void make_hole1(VoxelManipulator &vmanip, v3s16 place)
|
||||
{
|
||||
make_fill(vmanip, place, v3s16(1,2,1), 0, MapNode(CONTENT_AIR), VMANIP_FLAG_DUNGEON_INSIDE);
|
||||
}
|
||||
|
||||
static void make_door1(VoxelManipulator &vmanip, v3s16 doorplace, v3s16 doordir)
|
||||
{
|
||||
make_hole1(vmanip, doorplace);
|
||||
}
|
||||
|
||||
static v3s16 rand_ortho_dir(PseudoRandom &random)
|
||||
{
|
||||
if (random.next()%2==0) {
|
||||
return random.next()%2 ? v3s16(-1,0,0) : v3s16(1,0,0);
|
||||
}else{
|
||||
return random.next()%2 ? v3s16(0,0,-1) : v3s16(0,0,1);
|
||||
}
|
||||
}
|
||||
|
||||
static v3s16 turn_xz(v3s16 olddir, int t)
|
||||
{
|
||||
v3s16 dir;
|
||||
if (t == 0) {
|
||||
// Turn right
|
||||
dir.X = olddir.Z;
|
||||
dir.Z = -olddir.X;
|
||||
dir.Y = olddir.Y;
|
||||
}else{
|
||||
// Turn left
|
||||
dir.X = -olddir.Z;
|
||||
dir.Z = olddir.X;
|
||||
dir.Y = olddir.Y;
|
||||
}
|
||||
return dir;
|
||||
}
|
||||
|
||||
static v3s16 random_turn(PseudoRandom &random, v3s16 olddir)
|
||||
{
|
||||
int turn = random.range(0,2);
|
||||
v3s16 dir;
|
||||
if (turn == 0) {
|
||||
// Go straight
|
||||
dir = olddir;
|
||||
}else if (turn == 1) {
|
||||
// Turn right
|
||||
dir = turn_xz(olddir, 0);
|
||||
}else{
|
||||
// Turn left
|
||||
dir = turn_xz(olddir, 1);
|
||||
}
|
||||
return dir;
|
||||
}
|
||||
|
||||
static void make_corridor(VoxelManipulator &vmanip, v3s16 doorplace,
|
||||
v3s16 doordir, v3s16 &result_place, v3s16 &result_dir,
|
||||
PseudoRandom &random)
|
||||
{
|
||||
make_hole1(vmanip, doorplace);
|
||||
v3s16 p0 = doorplace;
|
||||
v3s16 dir = doordir;
|
||||
u32 length;
|
||||
if (random.next()%2) {
|
||||
length = random.range(1,13);
|
||||
}else{
|
||||
length = random.range(1,6);
|
||||
}
|
||||
length = random.range(1,13);
|
||||
u32 partlength = random.range(1,13);
|
||||
u32 partcount = 0;
|
||||
s16 make_stairs = 0;
|
||||
if (random.next()%2 == 0 && partlength >= 3)
|
||||
make_stairs = random.next()%2 ? 1 : -1;
|
||||
|
||||
for (u32 i=0; i<length; i++) {
|
||||
v3s16 p = p0 + dir;
|
||||
if (partcount != 0)
|
||||
p.Y += make_stairs;
|
||||
|
||||
if (vmanip.m_area.contains(p) == true && vmanip.m_area.contains(p+v3s16(0,1,0)) == true) {
|
||||
if (make_stairs) {
|
||||
make_fill(vmanip, p+v3s16(-1,-1,-1), v3s16(3,5,3), VMANIP_FLAG_DUNGEON_UNTOUCHABLE, MapNode(CONTENT_COBBLE), 0);
|
||||
make_fill(vmanip, p, v3s16(1,2,1), 0, MapNode(CONTENT_AIR), VMANIP_FLAG_DUNGEON_INSIDE);
|
||||
make_fill(vmanip, p-dir, v3s16(1,2,1), 0, MapNode(CONTENT_AIR), VMANIP_FLAG_DUNGEON_INSIDE);
|
||||
}else{
|
||||
make_fill(vmanip, p+v3s16(-1,-1,-1), v3s16(3,4,3), VMANIP_FLAG_DUNGEON_UNTOUCHABLE, MapNode(CONTENT_COBBLE), 0);
|
||||
make_hole1(vmanip, p);
|
||||
}
|
||||
|
||||
p0 = p;
|
||||
}else{
|
||||
// Can't go here, turn away
|
||||
dir = turn_xz(dir, random.range(0,1));
|
||||
make_stairs = -make_stairs;
|
||||
partcount = 0;
|
||||
partlength = random.range(1,length);
|
||||
continue;
|
||||
}
|
||||
|
||||
partcount++;
|
||||
if (partcount >= partlength) {
|
||||
partcount = 0;
|
||||
|
||||
dir = random_turn(random, dir);
|
||||
|
||||
partlength = random.range(1,length);
|
||||
|
||||
make_stairs = 0;
|
||||
if (random.next()%2 == 0 && partlength >= 3)
|
||||
make_stairs = random.next()%2 ? 1 : -1;
|
||||
}
|
||||
}
|
||||
result_place = p0;
|
||||
result_dir = dir;
|
||||
}
|
||||
|
||||
class RoomWalker
|
||||
{
|
||||
public:
|
||||
|
||||
RoomWalker(VoxelManipulator &vmanip_, v3s16 pos, PseudoRandom &random):
|
||||
vmanip(vmanip_),
|
||||
m_pos(pos),
|
||||
m_random(random)
|
||||
{
|
||||
randomizeDir();
|
||||
}
|
||||
|
||||
void randomizeDir()
|
||||
{
|
||||
m_dir = rand_ortho_dir(m_random);
|
||||
}
|
||||
|
||||
void setPos(v3s16 pos)
|
||||
{
|
||||
m_pos = pos;
|
||||
}
|
||||
|
||||
void setDir(v3s16 dir)
|
||||
{
|
||||
m_dir = dir;
|
||||
}
|
||||
|
||||
bool findPlaceForDoor(v3s16 &result_place, v3s16 &result_dir)
|
||||
{
|
||||
for (u32 i=0; i<100; i++) {
|
||||
v3s16 p = m_pos + m_dir;
|
||||
v3s16 p1 = p + v3s16(0,1,0);
|
||||
if (
|
||||
vmanip.m_area.contains(p) == false
|
||||
|| vmanip.m_area.contains(p1) == false
|
||||
|| i % 4 == 0
|
||||
) {
|
||||
randomizeDir();
|
||||
continue;
|
||||
}
|
||||
if (
|
||||
vmanip.getNodeNoExNoEmerge(p).getContent() == CONTENT_COBBLE
|
||||
&& vmanip.getNodeNoExNoEmerge(p1).getContent() == CONTENT_COBBLE
|
||||
) {
|
||||
// Found wall, this is a good place!
|
||||
result_place = p;
|
||||
result_dir = m_dir;
|
||||
// Randomize next direction
|
||||
randomizeDir();
|
||||
return true;
|
||||
}
|
||||
/*
|
||||
Determine where to move next
|
||||
*/
|
||||
// Jump one up if the actual space is there
|
||||
if (
|
||||
vmanip.getNodeNoExNoEmerge(p+v3s16(0,0,0)).getContent() == CONTENT_COBBLE
|
||||
&& vmanip.getNodeNoExNoEmerge(p+v3s16(0,1,0)).getContent() == CONTENT_AIR
|
||||
&& vmanip.getNodeNoExNoEmerge(p+v3s16(0,2,0)).getContent() == CONTENT_AIR
|
||||
)
|
||||
p += v3s16(0,1,0);
|
||||
// Jump one down if the actual space is there
|
||||
if (
|
||||
vmanip.getNodeNoExNoEmerge(p+v3s16(0,1,0)).getContent() == CONTENT_COBBLE
|
||||
&& vmanip.getNodeNoExNoEmerge(p+v3s16(0,0,0)).getContent() == CONTENT_AIR
|
||||
&& vmanip.getNodeNoExNoEmerge(p+v3s16(0,-1,0)).getContent() == CONTENT_AIR
|
||||
)
|
||||
p += v3s16(0,-1,0);
|
||||
// Check if walking is now possible
|
||||
if (
|
||||
vmanip.getNodeNoExNoEmerge(p).getContent() != CONTENT_AIR
|
||||
|| vmanip.getNodeNoExNoEmerge(p+v3s16(0,1,0)).getContent() != CONTENT_AIR
|
||||
) {
|
||||
// Cannot continue walking here
|
||||
randomizeDir();
|
||||
continue;
|
||||
}
|
||||
// Move there
|
||||
m_pos = p;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool findPlaceForRoomDoor(v3s16 roomsize, v3s16 &result_doorplace, v3s16 &result_doordir, v3s16 &result_roomplace)
|
||||
{
|
||||
for (s16 trycount=0; trycount<30; trycount++) {
|
||||
v3s16 doorplace;
|
||||
v3s16 doordir;
|
||||
bool r = findPlaceForDoor(doorplace, doordir);
|
||||
if (r == false)
|
||||
continue;
|
||||
v3s16 roomplace;
|
||||
// X east, Z north, Y up
|
||||
if (doordir == v3s16(1,0,0)) // X+
|
||||
roomplace = doorplace + v3s16(0,-1,m_random.range(-roomsize.Z+2,-2));
|
||||
if (doordir == v3s16(-1,0,0)) // X-
|
||||
roomplace = doorplace + v3s16(-roomsize.X+1,-1,m_random.range(-roomsize.Z+2,-2));
|
||||
if (doordir == v3s16(0,0,1)) // Z+
|
||||
roomplace = doorplace + v3s16(m_random.range(-roomsize.X+2,-2),-1,0);
|
||||
if (doordir == v3s16(0,0,-1)) // Z-
|
||||
roomplace = doorplace + v3s16(m_random.range(-roomsize.X+2,-2),-1,-roomsize.Z+1);
|
||||
|
||||
// Check fit
|
||||
bool fits = true;
|
||||
for (s16 z=1; z<roomsize.Z-1; z++)
|
||||
for (s16 y=1; y<roomsize.Y-1; y++)
|
||||
for (s16 x=1; x<roomsize.X-1; x++) {
|
||||
v3s16 p = roomplace + v3s16(x,y,z);
|
||||
if (vmanip.m_area.contains(p) == false) {
|
||||
fits = false;
|
||||
break;
|
||||
}
|
||||
if (vmanip.m_flags[vmanip.m_area.index(p)] & VMANIP_FLAG_DUNGEON_INSIDE) {
|
||||
fits = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
// Find new place
|
||||
if (fits == false)
|
||||
continue;
|
||||
result_doorplace = doorplace;
|
||||
result_doordir = doordir;
|
||||
result_roomplace = roomplace;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
private:
|
||||
VoxelManipulator &vmanip;
|
||||
v3s16 m_pos;
|
||||
v3s16 m_dir;
|
||||
PseudoRandom &m_random;
|
||||
};
|
||||
|
||||
void make_dungeon1(VoxelManipulator &vmanip, PseudoRandom &random)
|
||||
{
|
||||
v3s16 areasize = vmanip.m_area.getExtent();
|
||||
v3s16 roomsize;
|
||||
v3s16 roomplace;
|
||||
|
||||
/*
|
||||
Find place for first room
|
||||
*/
|
||||
bool fits = false;
|
||||
for (u32 i=0; i<100; i++) {
|
||||
roomsize = v3s16(random.range(4,8),random.range(4,6),random.range(4,8));
|
||||
roomplace = vmanip.m_area.MinEdge + v3s16(
|
||||
random.range(0,areasize.X-roomsize.X-1),
|
||||
random.range(0,areasize.Y-roomsize.Y-1),
|
||||
random.range(0,areasize.Z-roomsize.Z-1)
|
||||
);
|
||||
/*
|
||||
Check that we're not putting the room to an unknown place,
|
||||
otherwise it might end up floating in the air
|
||||
*/
|
||||
fits = true;
|
||||
for (s16 z=1; z<roomsize.Z-1; z++)
|
||||
for (s16 y=1; y<roomsize.Y-1; y++)
|
||||
for (s16 x=1; x<roomsize.X-1; x++) {
|
||||
v3s16 p = roomplace + v3s16(x,y,z);
|
||||
u32 vi = vmanip.m_area.index(p);
|
||||
if (vmanip.m_flags[vi] & VMANIP_FLAG_DUNGEON_INSIDE) {
|
||||
fits = false;
|
||||
break;
|
||||
}
|
||||
if (vmanip.m_data[vi].getContent() == CONTENT_IGNORE) {
|
||||
fits = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (fits)
|
||||
break;
|
||||
}
|
||||
// No place found
|
||||
if (fits == false)
|
||||
return;
|
||||
|
||||
/*
|
||||
Stores the center position of the last room made, so that
|
||||
a new corridor can be started from the last room instead of
|
||||
the new room, if chosen so.
|
||||
*/
|
||||
v3s16 last_room_center = roomplace+v3s16(roomsize.X/2,1,roomsize.Z/2);
|
||||
|
||||
u32 room_count = random.range(2,7);
|
||||
for (u32 i=0; i<room_count; i++) {
|
||||
|
||||
v3s16 room_center = roomplace + v3s16(roomsize.X/2,1,roomsize.Z/2);
|
||||
|
||||
// dungeons should only be made in stone, so if room_center isn't stone
|
||||
// stop making a dungeon
|
||||
if (vmanip.m_data[vmanip.m_area.index(room_center)].getContent() != CONTENT_STONE)
|
||||
break;
|
||||
|
||||
// Make a room to the determined place
|
||||
make_room1(vmanip, roomsize, roomplace);
|
||||
|
||||
// Place torch at room center (for testing)
|
||||
//vmanip.m_data[vmanip.m_area.index(room_center)] = MapNode(CONTENT_TORCH);
|
||||
|
||||
// Quit if last room
|
||||
if (i == room_count-1)
|
||||
break;
|
||||
|
||||
// Determine walker start position
|
||||
|
||||
bool start_in_last_room = (random.range(0,2)!=0);
|
||||
//bool start_in_last_room = true;
|
||||
|
||||
v3s16 walker_start_place;
|
||||
|
||||
if (start_in_last_room) {
|
||||
walker_start_place = last_room_center;
|
||||
}else{
|
||||
walker_start_place = room_center;
|
||||
// Store center of current room as the last one
|
||||
last_room_center = room_center;
|
||||
}
|
||||
|
||||
// Create walker and find a place for a door
|
||||
RoomWalker walker(vmanip, walker_start_place, random);
|
||||
v3s16 doorplace;
|
||||
v3s16 doordir;
|
||||
bool r = walker.findPlaceForDoor(doorplace, doordir);
|
||||
if (r == false)
|
||||
return;
|
||||
|
||||
if (random.range(0,1)==0) {
|
||||
// Make the door
|
||||
make_door1(vmanip, doorplace, doordir);
|
||||
}else{
|
||||
// Don't actually make a door
|
||||
doorplace -= doordir;
|
||||
}
|
||||
|
||||
// Make a random corridor starting from the door
|
||||
v3s16 corridor_end;
|
||||
v3s16 corridor_end_dir;
|
||||
make_corridor(vmanip, doorplace, doordir, corridor_end, corridor_end_dir, random);
|
||||
|
||||
// Find a place for a random sized room
|
||||
roomsize = v3s16(random.range(4,8),random.range(4,6),random.range(4,8));
|
||||
walker.setPos(corridor_end);
|
||||
walker.setDir(corridor_end_dir);
|
||||
r = walker.findPlaceForRoomDoor(roomsize, doorplace, doordir, roomplace);
|
||||
if (r == false)
|
||||
return;
|
||||
|
||||
if (random.range(0,1)==0) {
|
||||
// Make the door
|
||||
make_door1(vmanip, doorplace, doordir);
|
||||
}else{
|
||||
// Don't actually make a door
|
||||
roomplace -= doordir;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void make_dungeon(BlockMakeData *data, uint32_t blockseed)
|
||||
{
|
||||
v3s16 full_node_min = (data->blockpos-1)*MAP_BLOCKSIZE;
|
||||
v3s16 full_node_max = (data->blockpos+2)*MAP_BLOCKSIZE-v3s16(1,1,1);
|
||||
ManualMapVoxelManipulator &vmanip = *(data->vmanip);
|
||||
|
||||
// Dungeon generator doesn't modify places which have this set
|
||||
data->vmanip->clearFlag(VMANIP_FLAG_DUNGEON_INSIDE | VMANIP_FLAG_DUNGEON_PRESERVE);
|
||||
|
||||
// Set all air and water to be untouchable to make dungeons open
|
||||
// to caves and open air
|
||||
for (s16 x=full_node_min.X; x<=full_node_max.X; x++)
|
||||
for (s16 z=full_node_min.Z; z<=full_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, full_node_max.Y, p2d.Y));
|
||||
for (s16 y=full_node_max.Y; y>=full_node_min.Y; y--) {
|
||||
if (vmanip.m_data[i].getContent() == CONTENT_AIR) {
|
||||
vmanip.m_flags[i] |= VMANIP_FLAG_DUNGEON_PRESERVE;
|
||||
}else if (vmanip.m_data[i].getContent() == CONTENT_WATERSOURCE) {
|
||||
vmanip.m_flags[i] |= VMANIP_FLAG_DUNGEON_PRESERVE;
|
||||
}
|
||||
data->vmanip->m_area.add_y(em, i, -1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
PseudoRandom random(blockseed+2);
|
||||
|
||||
// Add it
|
||||
make_dungeon1(vmanip, random);
|
||||
|
||||
// Convert some cobble to mossy cobble
|
||||
for (s16 x=full_node_min.X; x<=full_node_max.X; x++)
|
||||
for (s16 z=full_node_min.Z; z<=full_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, full_node_max.Y, p2d.Y));
|
||||
for (s16 y=full_node_max.Y; y>=full_node_min.Y; y--) {
|
||||
// (noisebuf not used because it doesn't contain the
|
||||
// full area)
|
||||
double wetness = noise3d_param(get_ground_wetness_params(data->seed), x,y,z);
|
||||
double d = noise3d_perlin((float)x/2.5, (float)y/2.5,(float)z/2.5, blockseed, 2, 1.4);
|
||||
if (vmanip.m_data[i].getContent() == CONTENT_COBBLE && d < wetness/3.0)
|
||||
vmanip.m_data[i].setContent(CONTENT_MOSSYCOBBLE);
|
||||
data->vmanip->m_area.add_y(em, i, -1);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,62 @@
|
|||
/************************************************************************
|
||||
* Minetest-c55
|
||||
* Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
|
||||
*
|
||||
* mapgen.cpp
|
||||
* voxelands - 3d voxel world sandbox game
|
||||
* Copyright (C) Lisa 'darkrose' Milne 2014-2017 <lisa@ltmnet.com>
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 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 General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>
|
||||
*
|
||||
* License updated from GPLv2 or later to GPLv3 or later by Lisa Milne
|
||||
* for Voxelands.
|
||||
************************************************************************/
|
||||
|
||||
#include "mapgen.h"
|
||||
#include "voxel.h"
|
||||
#include "content_mapnode.h"
|
||||
#include "map.h"
|
||||
|
||||
namespace mapgen
|
||||
{
|
||||
|
||||
void make_papyrus(VoxelManipulator &vmanip, v3s16 p0)
|
||||
{
|
||||
MapNode papyrusnode(CONTENT_PAPYRUS);
|
||||
|
||||
s16 trunk_h = myrand_range(2, 3);
|
||||
v3s16 p1 = p0;
|
||||
for (s16 ii=0; ii<trunk_h; ii++) {
|
||||
if (vmanip.m_area.contains(p1))
|
||||
vmanip.m_data[vmanip.m_area.index(p1)] = papyrusnode;
|
||||
p1.Y++;
|
||||
}
|
||||
}
|
||||
|
||||
void make_cactus(VoxelManipulator &vmanip, v3s16 p0)
|
||||
{
|
||||
MapNode cactusnode(CONTENT_CACTUS);
|
||||
|
||||
s16 trunk_h = 3;
|
||||
if (myrand()%5000 == 0)
|
||||
trunk_h = 4;
|
||||
v3s16 p1 = p0;
|
||||
for (s16 ii=0; ii<trunk_h; ii++) {
|
||||
if (vmanip.m_area.contains(p1))
|
||||
vmanip.m_data[vmanip.m_area.index(p1)] = cactusnode;
|
||||
p1.Y++;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,180 @@
|
|||
/************************************************************************
|
||||
* Minetest-c55
|
||||
* Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
|
||||
*
|
||||
* mapgen.cpp
|
||||
* voxelands - 3d voxel world sandbox game
|
||||
* Copyright (C) Lisa 'darkrose' Milne 2014-2017 <lisa@ltmnet.com>
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 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 General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>
|
||||
*
|
||||
* License updated from GPLv2 or later to GPLv3 or later by Lisa Milne
|
||||
* for Voxelands.
|
||||
************************************************************************/
|
||||
|
||||
#include "mapgen.h"
|
||||
#include "voxel.h"
|
||||
#include "content_mapnode.h"
|
||||
#include "noise.h"
|
||||
#include "mapblock.h"
|
||||
#include "map.h"
|
||||
#include "mineral.h"
|
||||
|
||||
namespace mapgen
|
||||
{
|
||||
|
||||
void make_space(BlockMakeData *data)
|
||||
{
|
||||
v3s16 blockpos = data->blockpos;
|
||||
|
||||
ManualMapVoxelManipulator &vmanip = *(data->vmanip);
|
||||
// Area of center block
|
||||
v3s16 node_min = blockpos*MAP_BLOCKSIZE;
|
||||
v3s16 node_max = (blockpos+v3s16(1,1,1))*MAP_BLOCKSIZE-v3s16(1,1,1);
|
||||
// Full allocated area
|
||||
v3s16 full_node_min = (blockpos-1)*MAP_BLOCKSIZE;
|
||||
// Area of a block
|
||||
double block_area_nodes = MAP_BLOCKSIZE*MAP_BLOCKSIZE;
|
||||
|
||||
v2s16 p2d_center(node_min.X+MAP_BLOCKSIZE/2, node_min.Z+MAP_BLOCKSIZE/2);
|
||||
u32 blockseed = (u32)(data->seed%0x100000000ULL) + full_node_min.Z*38134234 + full_node_min.Y*42123 + full_node_min.X*23;
|
||||
|
||||
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++) {
|
||||
vmanip.m_data[i] = MapNode(CONTENT_VACUUM);
|
||||
data->vmanip->m_area.add_y(em, i, 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
u32 debris_amount = block_area_nodes*debris_amount_2d(blockseed,p2d_center);
|
||||
|
||||
if (debris_amount < 10)
|
||||
return;
|
||||
|
||||
NoiseBuffer noisebuf_mineral;
|
||||
{
|
||||
v3f minpos_f(node_min.X, node_min.Y, node_min.Z);
|
||||
v3f maxpos_f(node_max.X, node_max.Y, node_max.Z);
|
||||
|
||||
|
||||
// Sample length
|
||||
v3f sl(2.5, 2.5, 2.5);
|
||||
noisebuf_mineral.create(
|
||||
get_ground_wetness_params(data->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
|
||||
);
|
||||
}
|
||||
|
||||
{
|
||||
PseudoRandom debrisrandom(blockseed);
|
||||
u32 count = debris_amount/6;
|
||||
for (u32 i=0; i<count; i++) {
|
||||
s16 x = debrisrandom.range(node_min.X, node_max.X);
|
||||
s16 y = debrisrandom.range(node_min.Y, node_max.Y);
|
||||
s16 z = debrisrandom.range(node_min.Z, node_max.Z);
|
||||
|
||||
MapNode new_content(CONTENT_VACUUM);
|
||||
|
||||
float mineral_noise = noisebuf_mineral.get(x,y,z);
|
||||
|
||||
if (mineral_noise < -0.1) {
|
||||
new_content = MapNode(CONTENT_SPACEROCK, MINERAL_IRON);
|
||||
}else if (mineral_noise > 0.4) {
|
||||
new_content = MapNode(CONTENT_SPACEROCK, MINERAL_SILVER);
|
||||
}else if (mineral_noise > 0.3) {
|
||||
new_content = MapNode(CONTENT_SPACEROCK, MINERAL_QUARTZ);
|
||||
}else if (mineral_noise > 0.2) {
|
||||
new_content = MapNode(CONTENT_SPACEROCK, MINERAL_COPPER);
|
||||
}else if (mineral_noise > 0.1) {
|
||||
new_content = MapNode(CONTENT_SPACEROCK, MINERAL_TIN);
|
||||
}else if (mineral_noise > 0.0) {
|
||||
new_content = MapNode(CONTENT_SPACEROCK, MINERAL_GOLD);
|
||||
}
|
||||
|
||||
u32 vi = vmanip.m_area.index(v3s16(x,y,z));
|
||||
if (vmanip.m_data[vi].getContent() == CONTENT_VACUUM)
|
||||
vmanip.m_data[vi] = new_content;
|
||||
}
|
||||
}
|
||||
|
||||
if (debris_amount < 13)
|
||||
return;
|
||||
|
||||
{
|
||||
v3s16 pos = node_min+(MAP_BLOCKSIZE/2);
|
||||
u16 comet_size = debris_amount-11;
|
||||
if (comet_size > 5)
|
||||
comet_size = 5;
|
||||
s16 comet_min = -comet_size;
|
||||
s16 comet_max = comet_size;
|
||||
MapNode new_content(CONTENT_SPACEROCK);
|
||||
|
||||
float mineral_noise = noisebuf_mineral.get(pos.X,pos.Y,pos.Z);
|
||||
|
||||
if (mineral_noise < -0.5) {
|
||||
new_content = MapNode(CONTENT_LAVASOURCE);
|
||||
}else if (mineral_noise < -0.3) {
|
||||
new_content = MapNode(CONTENT_ICE);
|
||||
}else if (mineral_noise < -0.1) {
|
||||
new_content = MapNode(CONTENT_STEEL);
|
||||
}else if (mineral_noise > 0.4) {
|
||||
new_content = MapNode(CONTENT_SILVER);
|
||||
}else if (mineral_noise > 0.3) {
|
||||
new_content = MapNode(CONTENT_MITHRIL_BLOCK);
|
||||
}else if (mineral_noise > 0.2) {
|
||||
new_content = MapNode(CONTENT_COPPER);
|
||||
}else if (mineral_noise > 0.1) {
|
||||
new_content = MapNode(CONTENT_TIN);
|
||||
}else if (mineral_noise > 0.0) {
|
||||
new_content = MapNode(CONTENT_GOLD);
|
||||
}
|
||||
|
||||
for (s16 x=comet_min; x<=comet_max; x++) {
|
||||
for (s16 y=comet_min; y<=comet_max; y++) {
|
||||
for (s16 z=comet_min; z<=comet_max; z++) {
|
||||
int edge = 0;
|
||||
if (x == comet_min || x == comet_max)
|
||||
edge++;
|
||||
if (y == comet_min || y == comet_max)
|
||||
edge++;
|
||||
if (z == comet_min || z == comet_max)
|
||||
edge++;
|
||||
|
||||
if (edge > 1)
|
||||
continue;
|
||||
u32 vi = vmanip.m_area.index(pos+v3s16(x,y,z));
|
||||
if (vmanip.m_data[vi].getContent() != CONTENT_VACUUM)
|
||||
continue;
|
||||
if (edge) {
|
||||
vmanip.m_data[vi] = MapNode(CONTENT_SPACEROCK);
|
||||
continue;
|
||||
}
|
||||
vmanip.m_data[vi] = new_content;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,64 @@
|
|||
/************************************************************************
|
||||
* Minetest-c55
|
||||
* Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
|
||||
*
|
||||
* mapgen.cpp
|
||||
* voxelands - 3d voxel world sandbox game
|
||||
* Copyright (C) Lisa 'darkrose' Milne 2014-2017 <lisa@ltmnet.com>
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 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 General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>
|
||||
*
|
||||
* License updated from GPLv2 or later to GPLv3 or later by Lisa Milne
|
||||
* for Voxelands.
|
||||
************************************************************************/
|
||||
|
||||
#include "mapgen.h"
|
||||
#include "voxel.h"
|
||||
#include "content_mapnode.h"
|
||||
#include "noise.h"
|
||||
#include "mapblock.h"
|
||||
#include "map.h"
|
||||
#include "mineral.h"
|
||||
|
||||
namespace mapgen
|
||||
{
|
||||
|
||||
void make_thedeep(BlockMakeData *data)
|
||||
{
|
||||
v3s16 blockpos = data->blockpos;
|
||||
|
||||
ManualMapVoxelManipulator &vmanip = *(data->vmanip);
|
||||
// Area of center block
|
||||
v3s16 node_min = blockpos*MAP_BLOCKSIZE;
|
||||
v3s16 node_max = (blockpos+v3s16(1,1,1))*MAP_BLOCKSIZE-v3s16(1,1,1);
|
||||
|
||||
v2s16 p2d_center(node_min.X+MAP_BLOCKSIZE/2, node_min.Z+MAP_BLOCKSIZE/2);
|
||||
|
||||
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++) {
|
||||
vmanip.m_data[i] = MapNode(CONTENT_STONE);
|
||||
data->vmanip->m_area.add_y(em, i, 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,434 @@
|
|||
/************************************************************************
|
||||
* Minetest-c55
|
||||
* Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
|
||||
*
|
||||
* mapgen.cpp
|
||||
* voxelands - 3d voxel world sandbox game
|
||||
* Copyright (C) Lisa 'darkrose' Milne 2014-2017 <lisa@ltmnet.com>
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 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 General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>
|
||||
*
|
||||
* License updated from GPLv2 or later to GPLv3 or later by Lisa Milne
|
||||
* for Voxelands.
|
||||
************************************************************************/
|
||||
|
||||
#include "mapgen.h"
|
||||
#include "voxel.h"
|
||||
#include "content_mapnode.h"
|
||||
#include "map.h"
|
||||
|
||||
namespace mapgen
|
||||
{
|
||||
|
||||
void make_tree(ManualMapVoxelManipulator &vmanip, v3s16 p0)
|
||||
{
|
||||
MapNode treenode(CONTENT_TREE);
|
||||
MapNode leavesnode(CONTENT_LEAVES);
|
||||
uint8_t b = 0xE0;
|
||||
|
||||
s16 trunk_h = myrand_range(5,6);
|
||||
v3s16 p1 = p0;
|
||||
for (s16 ii=0; ii<trunk_h; ii++) {
|
||||
treenode.param1 = b|ii;
|
||||
if (vmanip.m_area.contains(p1))
|
||||
vmanip.m_data[vmanip.m_area.index(p1)] = treenode;
|
||||
b = 0;
|
||||
p1.Y++;
|
||||
}
|
||||
|
||||
// p1 is now the last piece of the trunk
|
||||
p1.Y -= 1;
|
||||
|
||||
VoxelArea leaves_a(v3s16(-3,-1,-3), v3s16(3,2,3));
|
||||
Buffer<u8> leaves_d(leaves_a.getVolume());
|
||||
for (s32 i=0; i<leaves_a.getVolume(); i++) {
|
||||
leaves_d[i] = 0;
|
||||
}
|
||||
|
||||
// Force leaves at near the end of the trunk
|
||||
s16 rad = 3;
|
||||
for (s16 y=-1; y<=1; y++) {
|
||||
for (s16 z=-rad; z<=rad; z++) {
|
||||
for (s16 x=-rad; x<=rad; x++) {
|
||||
if (rad < 3 || (z > -rad && z < rad) || (x > -rad && x < rad))
|
||||
leaves_d[leaves_a.index(v3s16(x,y,z))] = 1;
|
||||
}
|
||||
}
|
||||
rad--;
|
||||
}
|
||||
|
||||
// Add leaves randomly
|
||||
for (u32 iii=0; iii<7; iii++) {
|
||||
s16 d = 1;
|
||||
|
||||
v3s16 p(
|
||||
myrand_range(leaves_a.MinEdge.X, leaves_a.MaxEdge.X-d),
|
||||
myrand_range(leaves_a.MinEdge.Y, leaves_a.MaxEdge.Y-d),
|
||||
myrand_range(leaves_a.MinEdge.Z, leaves_a.MaxEdge.Z-d)
|
||||
);
|
||||
|
||||
for (s16 z=0; z<=d; z++) {
|
||||
for (s16 y=0; y<=d; y++) {
|
||||
for (s16 x=0; x<=d; x++) {
|
||||
leaves_d[leaves_a.index(p+v3s16(x,y,z))] = 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Blit leaves to vmanip
|
||||
for (s16 z=leaves_a.MinEdge.Z; z<=leaves_a.MaxEdge.Z; z++) {
|
||||
for (s16 y=leaves_a.MinEdge.Y; y<=leaves_a.MaxEdge.Y; y++) {
|
||||
for (s16 x=leaves_a.MinEdge.X; x<=leaves_a.MaxEdge.X; x++) {
|
||||
v3s16 p(x,y,z);
|
||||
p += p1;
|
||||
if (vmanip.m_area.contains(p) == false)
|
||||
continue;
|
||||
u32 vi = vmanip.m_area.index(p);
|
||||
if (vmanip.m_data[vi].getContent() != CONTENT_AIR
|
||||
&& vmanip.m_data[vi].getContent() != CONTENT_IGNORE)
|
||||
continue;
|
||||
u32 i = leaves_a.index(x,y,z);
|
||||
if (leaves_d[i] == 1)
|
||||
vmanip.m_data[vi] = leavesnode;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void make_appletree(ManualMapVoxelManipulator &vmanip, v3s16 p0)
|
||||
{
|
||||
MapNode treenode(CONTENT_APPLE_TREE);
|
||||
MapNode leavesnode(CONTENT_APPLE_LEAVES);
|
||||
MapNode applenode(CONTENT_APPLE);
|
||||
uint8_t b = 0xE0;
|
||||
|
||||
s16 trunk_h = myrand_range(4, 5);
|
||||
v3s16 p1 = p0;
|
||||
for (s16 ii=0; ii<trunk_h; ii++) {
|
||||
treenode.param1 = b|ii;
|
||||
if(vmanip.m_area.contains(p1))
|
||||
vmanip.m_data[vmanip.m_area.index(p1)] = treenode;
|
||||
b = 0;
|
||||
p1.Y++;
|
||||
}
|
||||
|
||||
// p1 is now the last piece of the trunk
|
||||
p1.Y -= 1;
|
||||
|
||||
VoxelArea leaves_a(v3s16(-2,-1,-2), v3s16(2,2,2));
|
||||
Buffer<u8> leaves_d(leaves_a.getVolume());
|
||||
for(s32 i=0; i<leaves_a.getVolume(); i++)
|
||||
leaves_d[i] = 0;
|
||||
|
||||
// Force leaves at near the end of the trunk
|
||||
{
|
||||
s16 d = 1;
|
||||
for(s16 z=-d; z<=d; z++)
|
||||
for(s16 y=-d; y<=d; y++)
|
||||
for(s16 x=-d; x<=d; x++)
|
||||
{
|
||||
leaves_d[leaves_a.index(v3s16(x,y,z))] = 1;
|
||||
}
|
||||
}
|
||||
|
||||
// Add leaves randomly
|
||||
for(u32 iii=0; iii<7; iii++)
|
||||
{
|
||||
s16 d = 1;
|
||||
|
||||
v3s16 p(
|
||||
myrand_range(leaves_a.MinEdge.X, leaves_a.MaxEdge.X-d),
|
||||
myrand_range(leaves_a.MinEdge.Y, leaves_a.MaxEdge.Y-d),
|
||||
myrand_range(leaves_a.MinEdge.Z, leaves_a.MaxEdge.Z-d)
|
||||
);
|
||||
|
||||
for(s16 z=0; z<=d; z++)
|
||||
for(s16 y=0; y<=d; y++)
|
||||
for(s16 x=0; x<=d; x++)
|
||||
{
|
||||
leaves_d[leaves_a.index(p+v3s16(x,y,z))] = 1;
|
||||
}
|
||||
}
|
||||
|
||||
// not all apple trees have apples
|
||||
bool have_fruit = (myrand_range(0,4) == 0);
|
||||
|
||||
// Blit leaves to vmanip
|
||||
for(s16 z=leaves_a.MinEdge.Z; z<=leaves_a.MaxEdge.Z; z++)
|
||||
for(s16 y=leaves_a.MinEdge.Y; y<=leaves_a.MaxEdge.Y; y++)
|
||||
for(s16 x=leaves_a.MinEdge.X; x<=leaves_a.MaxEdge.X; x++)
|
||||
{
|
||||
v3s16 p(x,y,z);
|
||||
p += p1;
|
||||
if (vmanip.m_area.contains(p) == false)
|
||||
continue;
|
||||
u32 vi = vmanip.m_area.index(p);
|
||||
if (vmanip.m_data[vi].getContent() != CONTENT_AIR && vmanip.m_data[vi].getContent() != CONTENT_IGNORE)
|
||||
continue;
|
||||
u32 i = leaves_a.index(x,y,z);
|
||||
if (leaves_d[i] == 1) {
|
||||
bool is_apple = myrand_range(0,99) < 10;
|
||||
if (have_fruit && is_apple) {
|
||||
vmanip.m_data[vi] = applenode;
|
||||
}else{
|
||||
vmanip.m_data[vi] = leavesnode;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void make_conifertree(ManualMapVoxelManipulator &vmanip, v3s16 p0)
|
||||
{
|
||||
MapNode treenode(CONTENT_CONIFER_TREE);
|
||||
MapNode leavesnode(CONTENT_CONIFER_LEAVES);
|
||||
uint8_t b = 0xE0;
|
||||
|
||||
s16 trunk_h = myrand_range(8, 11);
|
||||
v3s16 p1 = p0;
|
||||
for (s16 ii=0; ii<trunk_h; ii++) {
|
||||
treenode.param1 = b|ii;
|
||||
if(vmanip.m_area.contains(p1))
|
||||
vmanip.m_data[vmanip.m_area.index(p1)] = treenode;
|
||||
b = 0;
|
||||
p1.Y++;
|
||||
}
|
||||
|
||||
// p1 is now the last piece of the trunk
|
||||
if (vmanip.m_area.contains(p1+v3s16(0,1,0)))
|
||||
vmanip.m_data[vmanip.m_area.index(p1+v3s16(0,1,0))] = leavesnode;
|
||||
for(s16 z=-1; z<=1; z++)
|
||||
for(s16 y=-2; y<=0; y++)
|
||||
for(s16 x=-1; x<=1; x++)
|
||||
{
|
||||
if (!x && !z)
|
||||
continue;
|
||||
if (vmanip.m_area.contains(p1+v3s16(x,y,z)))
|
||||
vmanip.m_data[vmanip.m_area.index(p1+v3s16(x,y,z))] = leavesnode;
|
||||
}
|
||||
for(s16 z=-2; z<=2; z++)
|
||||
for(s16 y=-5; y<-2; y++)
|
||||
for(s16 x=-2; x<=2; x++)
|
||||
{
|
||||
if (!x && !z)
|
||||
continue;
|
||||
if (vmanip.m_area.contains(p1+v3s16(x,y,z)))
|
||||
vmanip.m_data[vmanip.m_area.index(p1+v3s16(x,y,z))] = leavesnode;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
void make_largetree(ManualMapVoxelManipulator &vmanip, v3s16 p0)
|
||||
{
|
||||
MapNode treenode(CONTENT_TREE);
|
||||
MapNode leavesnode(CONTENT_LEAVES);
|
||||
uint8_t b = 0xE0;
|
||||
|
||||
s16 trunk_h = myrand_range(10, 12);
|
||||
v3s16 p1 = p0;
|
||||
for (s16 ii=0; ii<trunk_h; ii++) {
|
||||
treenode.param1 = b|ii;
|
||||
if(vmanip.m_area.contains(p1))
|
||||
vmanip.m_data[vmanip.m_area.index(p1)] = treenode;
|
||||
b = 0;
|
||||
p1.Y++;
|
||||
}
|
||||
|
||||
// p1 is now the last piece of the trunk
|
||||
p1.Y -= 1;
|
||||
|
||||
VoxelArea leaves_a(v3s16(-3,-3,-3), v3s16(3,3,3));
|
||||
Buffer<u8> leaves_d(leaves_a.getVolume());
|
||||
for(s32 i=0; i<leaves_a.getVolume(); i++)
|
||||
leaves_d[i] = 0;
|
||||
|
||||
for (s16 k=0; k<5; k++) {
|
||||
if (k == 1) {
|
||||
p1.Y -= 3;
|
||||
b = k<<5;
|
||||
for (s16 ki=0; ki<4; ki++) {
|
||||
p1.X++;
|
||||
treenode.param1 = b|((trunk_h-3)+ki);
|
||||
vmanip.m_data[vmanip.m_area.index(p1)] = treenode;
|
||||
}
|
||||
p1.X--;
|
||||
}else if (k == 2) {
|
||||
p1.X -= 3;
|
||||
b = k<<5;
|
||||
for (s16 ki=0; ki<4; ki++) {
|
||||
p1.X--;
|
||||
treenode.param1 = b|((trunk_h-3)+ki);
|
||||
vmanip.m_data[vmanip.m_area.index(p1)] = treenode;
|
||||
}
|
||||
p1.X++;
|
||||
}else if (k == 3) {
|
||||
p1.X += 3;
|
||||
b = k<<5;
|
||||
for (s16 ki=0; ki<4; ki++) {
|
||||
p1.Z++;
|
||||
treenode.param1 = b|((trunk_h-3)+ki);
|
||||
vmanip.m_data[vmanip.m_area.index(p1)] = treenode;
|
||||
}
|
||||
p1.Z--;
|
||||
}else if (k == 4) {
|
||||
p1.Z -= 3;
|
||||
b = k<<5;
|
||||
for (s16 ki=0; ki<4; ki++) {
|
||||
p1.Z--;
|
||||
treenode.param1 = b|((trunk_h-3)+ki);
|
||||
vmanip.m_data[vmanip.m_area.index(p1)] = treenode;
|
||||
}
|
||||
p1.Z++;
|
||||
}else{
|
||||
treenode.param1 = trunk_h;
|
||||
vmanip.m_data[vmanip.m_area.index(p1)] = treenode;
|
||||
}
|
||||
// Force leaves at near the end of the trunk
|
||||
{
|
||||
s16 d = 1;
|
||||
for(s16 z=-d; z<=d; z++)
|
||||
for(s16 y=-d; y<=d; y++)
|
||||
for(s16 x=-d; x<=d; x++)
|
||||
{
|
||||
leaves_d[leaves_a.index(v3s16(x,y,z))] = 1;
|
||||
}
|
||||
}
|
||||
|
||||
if (k) {
|
||||
// Add leaves randomly
|
||||
for (u32 iii=0; iii<10; iii++) {
|
||||
s16 d = 1;
|
||||
|
||||
v3s16 p(
|
||||
myrand_range(leaves_a.MinEdge.X, leaves_a.MaxEdge.X-d),
|
||||
myrand_range(leaves_a.MinEdge.Y, leaves_a.MaxEdge.Y-d),
|
||||
myrand_range(leaves_a.MinEdge.Z, leaves_a.MaxEdge.Z-d)
|
||||
);
|
||||
|
||||
for(s16 z=0; z<=d; z++)
|
||||
for(s16 y=0; y<=d; y++)
|
||||
for(s16 x=0; x<=d; x++)
|
||||
{
|
||||
leaves_d[leaves_a.index(p+v3s16(x,y,z))] = 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Blit leaves to vmanip
|
||||
for(s16 z=leaves_a.MinEdge.Z; z<=leaves_a.MaxEdge.Z; z++)
|
||||
for(s16 y=leaves_a.MinEdge.Y; y<=leaves_a.MaxEdge.Y; y++)
|
||||
for(s16 x=leaves_a.MinEdge.X; x<=leaves_a.MaxEdge.X; x++)
|
||||
{
|
||||
v3s16 p(x,y,z);
|
||||
p += p1;
|
||||
if(vmanip.m_area.contains(p) == false)
|
||||
continue;
|
||||
u32 vi = vmanip.m_area.index(p);
|
||||
if(vmanip.m_data[vi].getContent() != CONTENT_AIR
|
||||
&& vmanip.m_data[vi].getContent() != CONTENT_IGNORE)
|
||||
continue;
|
||||
u32 i = leaves_a.index(x,y,z);
|
||||
if(leaves_d[i] == 1)
|
||||
vmanip.m_data[vi] = leavesnode;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void make_jungletree(ManualMapVoxelManipulator &vmanip, v3s16 p0)
|
||||
{
|
||||
MapNode treenode(CONTENT_JUNGLETREE);
|
||||
MapNode leavesnode(CONTENT_JUNGLELEAVES);
|
||||
|
||||
for(s16 x=-1; x<=1; x++)
|
||||
for(s16 z=-1; z<=1; z++)
|
||||
{
|
||||
if(myrand_range(0, 2) == 0)
|
||||
continue;
|
||||
v3s16 p1 = p0 + v3s16(x,0,z);
|
||||
v3s16 p2 = p0 + v3s16(x,-1,z);
|
||||
if(vmanip.m_area.contains(p2)
|
||||
&& vmanip.m_data[vmanip.m_area.index(p2)] == CONTENT_AIR)
|
||||
vmanip.m_data[vmanip.m_area.index(p2)] = treenode;
|
||||
else if(vmanip.m_area.contains(p1))
|
||||
vmanip.m_data[vmanip.m_area.index(p1)] = treenode;
|
||||
}
|
||||
|
||||
s16 trunk_h = myrand_range(8, 12);
|
||||
v3s16 p1 = p0;
|
||||
for(s16 ii=0; ii<trunk_h; ii++)
|
||||
{
|
||||
if(vmanip.m_area.contains(p1))
|
||||
vmanip.m_data[vmanip.m_area.index(p1)] = treenode;
|
||||
p1.Y++;
|
||||
}
|
||||
|
||||
// p1 is now the last piece of the trunk
|
||||
p1.Y -= 1;
|
||||
|
||||
VoxelArea leaves_a(v3s16(-3,-2,-3), v3s16(3,2,3));
|
||||
//SharedPtr<u8> leaves_d(new u8[leaves_a.getVolume()]);
|
||||
Buffer<u8> leaves_d(leaves_a.getVolume());
|
||||
for(s32 i=0; i<leaves_a.getVolume(); i++)
|
||||
leaves_d[i] = 0;
|
||||
|
||||
// Force leaves at near the end of the trunk
|
||||
{
|
||||
s16 d = 1;
|
||||
for(s16 z=-d; z<=d; z++)
|
||||
for(s16 y=-d; y<=d; y++)
|
||||
for(s16 x=-d; x<=d; x++)
|
||||
{
|
||||
leaves_d[leaves_a.index(v3s16(x,y,z))] = 1;
|
||||
}
|
||||
}
|
||||
|
||||
// Add leaves randomly
|
||||
for(u32 iii=0; iii<30; iii++)
|
||||
{
|
||||
s16 d = 1;
|
||||
|
||||
v3s16 p(
|
||||
myrand_range(leaves_a.MinEdge.X, leaves_a.MaxEdge.X-d),
|
||||
myrand_range(leaves_a.MinEdge.Y, leaves_a.MaxEdge.Y-d),
|
||||
myrand_range(leaves_a.MinEdge.Z, leaves_a.MaxEdge.Z-d)
|
||||
);
|
||||
|
||||
for(s16 z=0; z<=d; z++)
|
||||
for(s16 y=0; y<=d; y++)
|
||||
for(s16 x=0; x<=d; x++)
|
||||
{
|
||||
leaves_d[leaves_a.index(p+v3s16(x,y,z))] = 1;
|
||||
}
|
||||
}
|
||||
|
||||
// Blit leaves to vmanip
|
||||
for(s16 z=leaves_a.MinEdge.Z; z<=leaves_a.MaxEdge.Z; z++)
|
||||
for(s16 y=leaves_a.MinEdge.Y; y<=leaves_a.MaxEdge.Y; y++)
|
||||
for(s16 x=leaves_a.MinEdge.X; x<=leaves_a.MaxEdge.X; x++)
|
||||
{
|
||||
v3s16 p(x,y,z);
|
||||
p += p1;
|
||||
if(vmanip.m_area.contains(p) == false)
|
||||
continue;
|
||||
u32 vi = vmanip.m_area.index(p);
|
||||
if(vmanip.m_data[vi].getContent() != CONTENT_AIR
|
||||
&& vmanip.m_data[vi].getContent() != CONTENT_IGNORE)
|
||||
continue;
|
||||
u32 i = leaves_a.index(x,y,z);
|
||||
if(leaves_d[i] == 1)
|
||||
vmanip.m_data[vi] = leavesnode;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,364 @@
|
|||
/************************************************************************
|
||||
* Minetest-c55
|
||||
* Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
|
||||
*
|
||||
* mapgen.cpp
|
||||
* voxelands - 3d voxel world sandbox game
|
||||
* Copyright (C) Lisa 'darkrose' Milne 2014-2017 <lisa@ltmnet.com>
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 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 General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>
|
||||
*
|
||||
* License updated from GPLv2 or later to GPLv3 or later by Lisa Milne
|
||||
* for Voxelands.
|
||||
************************************************************************/
|
||||
|
||||
#include "mapgen.h"
|
||||
#include "voxel.h"
|
||||
#include "content_mapnode.h"
|
||||
#include "map.h"
|
||||
#include "mapblock.h"
|
||||
#include "noise.h"
|
||||
|
||||
namespace mapgen
|
||||
{
|
||||
|
||||
/*
|
||||
Noise functions. Make sure seed is mangled differently in each one.
|
||||
*/
|
||||
|
||||
NoiseParams get_cave_noise1_params(uint64_t seed)
|
||||
{
|
||||
return NoiseParams(NOISE_PERLIN_CONTOUR, seed+52534, 4, 0.5,
|
||||
50, CAVE_NOISE_SCALE);
|
||||
}
|
||||
|
||||
NoiseParams get_cave_noise2_params(uint64_t seed)
|
||||
{
|
||||
return NoiseParams(NOISE_PERLIN_CONTOUR_FLIP_YZ, seed+10325, 4, 0.5,
|
||||
50, CAVE_NOISE_SCALE);
|
||||
}
|
||||
|
||||
NoiseParams get_ground_noise1_params(uint64_t seed)
|
||||
{
|
||||
return NoiseParams(NOISE_PERLIN, seed+983240, 4,
|
||||
0.55, 80.0, 40.0);
|
||||
}
|
||||
|
||||
NoiseParams get_ground_crumbleness_params(uint64_t seed)
|
||||
{
|
||||
return NoiseParams(NOISE_PERLIN, seed+34413, 3,
|
||||
1.3, 20.0, 1.0);
|
||||
}
|
||||
|
||||
NoiseParams get_ground_wetness_params(uint64_t seed)
|
||||
{
|
||||
return NoiseParams(NOISE_PERLIN, seed+32474, 4,
|
||||
1.1, 40.0, 1.0);
|
||||
}
|
||||
|
||||
float get_humidity(uint64_t seed, v2s16 p)
|
||||
{
|
||||
double noise = noise2d_perlin((float)p.X/500.0, (float)p.Y/500.0, seed+72384, 4, 0.5);
|
||||
noise = (noise + 1.0)/2.0;
|
||||
if (noise < 0.0)
|
||||
return 0.0;
|
||||
if (noise > 1.0)
|
||||
return 1.0;
|
||||
return noise;
|
||||
}
|
||||
|
||||
int16_t get_ground_height(uint64_t seed, v2s16 p)
|
||||
{
|
||||
double e = noise2d_perlin((float)p.X/200.0, (float)p.Y/200.0, seed, 4, 0.5);
|
||||
|
||||
if (e > 0.0)
|
||||
e = pow(e,1.9);
|
||||
|
||||
return (WATER_LEVEL+1)+(25.0*e);
|
||||
}
|
||||
|
||||
bool is_cave(uint64_t seed, v3s16 p)
|
||||
{
|
||||
double d1 = noise3d_param(get_cave_noise1_params(seed), p.X,p.Y,p.Z);
|
||||
double d2 = noise3d_param(get_cave_noise2_params(seed), p.X,p.Y,p.Z);
|
||||
return d1*d2 > CAVE_NOISE_THRESHOLD;
|
||||
}
|
||||
// Amount of trees per area in nodes
|
||||
uint32_t get_tree_density(BlockMakeData *data, v2s16 p)
|
||||
{
|
||||
double noise = noise2d_perlin(
|
||||
0.5+(float)p.X/125,
|
||||
0.5+(float)p.Y/125,
|
||||
data->seed+2,
|
||||
4,
|
||||
0.66
|
||||
);
|
||||
double zeroval = -0.39;
|
||||
if (noise < zeroval)
|
||||
return 0;
|
||||
|
||||
double density = 0.04 * (noise-zeroval) / (1.0-zeroval);
|
||||
|
||||
uint32_t r = density*(double)(MAP_BLOCKSIZE*MAP_BLOCKSIZE);
|
||||
|
||||
if (data->biome == BIOME_JUNGLE || data->biome == BIOME_FOREST) {
|
||||
if (r < 1) {
|
||||
r = 20;
|
||||
}else{
|
||||
r *= 5;
|
||||
}
|
||||
}else if (data->biome == BIOME_LAKE || data->biome == BIOME_SNOWCAP || data->biome == BIOME_WOODLANDS) {
|
||||
if (r < 1)
|
||||
r = 5;
|
||||
}else if (data->biome == BIOME_PLAINS) {
|
||||
if (r)
|
||||
r /= 5;
|
||||
}
|
||||
|
||||
return r;
|
||||
}
|
||||
// Amount of grasses per area in nodes
|
||||
uint32_t get_grass_density(BlockMakeData *data, v2s16 p)
|
||||
{
|
||||
double zeroval = -0.39;
|
||||
double density = 0.0;
|
||||
double noise = 0.0;
|
||||
uint32_t r = 0;
|
||||
|
||||
if (data->biome == BIOME_DESERT || data->biome == BIOME_SNOWCAP || data->biome == BIOME_OCEAN)
|
||||
return 0;
|
||||
|
||||
noise = noise2d_perlin(
|
||||
0.5+(float)p.X/125,
|
||||
0.5+(float)p.Y/125,
|
||||
data->seed+2,
|
||||
4,
|
||||
0.66
|
||||
);
|
||||
|
||||
if (noise >= zeroval) {
|
||||
density = 0.04 * (noise-zeroval) / (1.0-zeroval);
|
||||
r = density*(double)(MAP_BLOCKSIZE*MAP_BLOCKSIZE);
|
||||
}
|
||||
|
||||
if (data->biome == BIOME_JUNGLE || data->biome == BIOME_PLAINS) {
|
||||
if (r < 1) {
|
||||
r = 50;
|
||||
}else{
|
||||
r *= 15;
|
||||
}
|
||||
}else if (data->biome == BIOME_LAKE || data->biome == BIOME_WOODLANDS) {
|
||||
if (r < 1)
|
||||
r = 5;
|
||||
}
|
||||
|
||||
return r;
|
||||
}
|
||||
|
||||
// used in space
|
||||
double debris_amount_2d(uint64_t seed, v2s16 p)
|
||||
{
|
||||
double noise = noise2d_perlin(
|
||||
0.5+(float)p.X/125,
|
||||
0.5+(float)p.Y/125,
|
||||
seed+2,
|
||||
4,
|
||||
0.7
|
||||
);
|
||||
double zeroval = -0.41;
|
||||
if (noise < zeroval)
|
||||
return 0;
|
||||
|
||||
return 0.037 * (noise-zeroval) / (1.0-zeroval);
|
||||
}
|
||||
|
||||
double largestone_amount_2d(uint64_t seed, v2s16 p)
|
||||
{
|
||||
double noise = noise2d_perlin(
|
||||
0.5+(float)p.X/250, 0.5+(float)p.Y/250,
|
||||
seed+14143242, 5, 0.66);
|
||||
double zeroval = 0.3;
|
||||
if(noise < zeroval)
|
||||
return 0;
|
||||
else
|
||||
return 0.005 * (noise-zeroval) / (1.0-zeroval);
|
||||
}
|
||||
|
||||
/*
|
||||
Incrementally find ground level from 3d noise
|
||||
*/
|
||||
s16 find_ground_level_from_noise(BlockMakeData *data, v2s16 p2d, s16 precision)
|
||||
{
|
||||
return get_ground_height(data->seed,p2d);
|
||||
}
|
||||
|
||||
double get_sector_average_ground_level(BlockMakeData *data, v2s16 sectorpos)
|
||||
{
|
||||
v2s16 node_min = sectorpos*MAP_BLOCKSIZE;
|
||||
v2s16 node_max = (sectorpos+v2s16(1,1))*MAP_BLOCKSIZE-v2s16(1,1);
|
||||
double a = 0;
|
||||
a += get_ground_height(data->seed, v2s16(node_min.X, node_min.Y));
|
||||
a += get_ground_height(data->seed, v2s16(node_min.X, node_max.Y));
|
||||
a += get_ground_height(data->seed, v2s16(node_max.X, node_max.Y));
|
||||
a += get_ground_height(data->seed, v2s16(node_max.X, node_min.Y));
|
||||
a += get_ground_height(data->seed, v2s16(node_min.X+MAP_BLOCKSIZE/2, node_min.Y+MAP_BLOCKSIZE/2));
|
||||
a /= 5.0;
|
||||
return a;
|
||||
}
|
||||
|
||||
double get_sector_maximum_ground_level(BlockMakeData *data, v2s16 sectorpos)
|
||||
{
|
||||
v2s16 node_min = sectorpos*MAP_BLOCKSIZE;
|
||||
v2s16 node_max = (sectorpos+v2s16(1,1))*MAP_BLOCKSIZE-v2s16(1,1);
|
||||
double a = -31000;
|
||||
// Corners
|
||||
a = MYMAX(a, get_ground_height(data->seed, v2s16(node_min.X, node_min.Y)));
|
||||
a = MYMAX(a, get_ground_height(data->seed, v2s16(node_min.X, node_max.Y)));
|
||||
a = MYMAX(a, get_ground_height(data->seed, v2s16(node_max.X, node_max.Y)));
|
||||
a = MYMAX(a, get_ground_height(data->seed, v2s16(node_min.X, node_min.Y)));
|
||||
// Center
|
||||
a = MYMAX(a, get_ground_height(data->seed, v2s16(node_min.X+MAP_BLOCKSIZE/2, node_min.Y+MAP_BLOCKSIZE/2)));
|
||||
// Side middle points
|
||||
a = MYMAX(a, get_ground_height(data->seed, v2s16(node_min.X+MAP_BLOCKSIZE/2, node_min.Y)));
|
||||
a = MYMAX(a, get_ground_height(data->seed, v2s16(node_min.X+MAP_BLOCKSIZE/2, node_max.Y)));
|
||||
a = MYMAX(a, get_ground_height(data->seed, v2s16(node_min.X, node_min.Y+MAP_BLOCKSIZE/2)));
|
||||
a = MYMAX(a, get_ground_height(data->seed, v2s16(node_max.X, node_min.Y+MAP_BLOCKSIZE/2)));
|
||||
return a;
|
||||
}
|
||||
|
||||
double get_sector_minimum_ground_level(BlockMakeData *data, v2s16 sectorpos)
|
||||
{
|
||||
v2s16 node_min = sectorpos*MAP_BLOCKSIZE;
|
||||
v2s16 node_max = (sectorpos+v2s16(1,1))*MAP_BLOCKSIZE-v2s16(1,1);
|
||||
double a = 31000;
|
||||
// Corners
|
||||
a = MYMIN(a, get_ground_height(data->seed, v2s16(node_min.X, node_min.Y)));
|
||||
a = MYMIN(a, get_ground_height(data->seed, v2s16(node_min.X, node_max.Y)));
|
||||
a = MYMIN(a, get_ground_height(data->seed, v2s16(node_max.X, node_max.Y)));
|
||||
a = MYMIN(a, get_ground_height(data->seed, v2s16(node_min.X, node_min.Y)));
|
||||
// Center
|
||||
a = MYMIN(a, get_ground_height(data->seed, v2s16(node_min.X+MAP_BLOCKSIZE/2, node_min.Y+MAP_BLOCKSIZE/2)));
|
||||
// Side middle points
|
||||
a = MYMIN(a, get_ground_height(data->seed, v2s16(node_min.X+MAP_BLOCKSIZE/2, node_min.Y)));
|
||||
a = MYMIN(a, get_ground_height(data->seed, v2s16(node_min.X+MAP_BLOCKSIZE/2, node_max.Y)));
|
||||
a = MYMIN(a, get_ground_height(data->seed, v2s16(node_min.X, node_min.Y+MAP_BLOCKSIZE/2)));
|
||||
a = MYMIN(a, get_ground_height(data->seed, v2s16(node_max.X, node_min.Y+MAP_BLOCKSIZE/2)));
|
||||
return a;
|
||||
}
|
||||
|
||||
bool block_is_underground(BlockMakeData *data, v3s16 blockpos)
|
||||
{
|
||||
s16 minimum_groundlevel = (s16)get_sector_minimum_ground_level(data, v2s16(blockpos.X, blockpos.Z));
|
||||
|
||||
if(blockpos.Y*MAP_BLOCKSIZE + MAP_BLOCKSIZE <= minimum_groundlevel)
|
||||
return true;
|
||||
else
|
||||
return false;
|
||||
}
|
||||
|
||||
bool get_have_sand(uint64_t seed, v2s16 p2d)
|
||||
{
|
||||
// Determine whether to have sand here
|
||||
double sandnoise = noise2d_perlin(
|
||||
0.5+(float)p2d.X/500, 0.5+(float)p2d.Y/500,
|
||||
seed+59420, 3, 0.50);
|
||||
|
||||
return (sandnoise > -0.15);
|
||||
}
|
||||
|
||||
void calc_biome(BlockMakeData *data)
|
||||
{
|
||||
v3s16 node_min = data->blockpos*MAP_BLOCKSIZE;
|
||||
v3s16 node_max = (data->blockpos+v3s16(1,1,1))*MAP_BLOCKSIZE-v3s16(1,1,1);
|
||||
v2s16 p2d_center(node_min.X+MAP_BLOCKSIZE/2, node_min.Z+MAP_BLOCKSIZE/2);
|
||||
v2s16 p2d(data->blockpos.X, data->blockpos.Z);
|
||||
int16_t average_ground_height;
|
||||
float surface_humidity = 0;
|
||||
|
||||
if (node_min.Y >= 1024) {
|
||||
data->biome = BIOME_SPACE;
|
||||
return;
|
||||
}else if (node_min.Y >= 256) {
|
||||
data->biome = BIOME_SKY;
|
||||
return;
|
||||
}else if (node_max.Y <= -128) {
|
||||
data->biome = BIOME_THEDEEP;
|
||||
return;
|
||||
}
|
||||
|
||||
average_ground_height = (int16_t)get_sector_average_ground_level(data,p2d);
|
||||
|
||||
if (average_ground_height <= -10) {
|
||||
data->biome = BIOME_OCEAN;
|
||||
return;
|
||||
}
|
||||
if (average_ground_height >= 40) {
|
||||
data->biome = BIOME_SNOWCAP;
|
||||
return;
|
||||
}
|
||||
|
||||
surface_humidity = get_humidity(data->seed, p2d_center);
|
||||
|
||||
if (average_ground_height <= 2) {
|
||||
if (surface_humidity < 0.5) {
|
||||
data->biome = BIOME_BEACH;
|
||||
return;
|
||||
}
|
||||
data->biome = BIOME_LAKE;
|
||||
return;
|
||||
}
|
||||
|
||||
if (average_ground_height > 30) {
|
||||
if (surface_humidity < 0.25) {
|
||||
data->biome = BIOME_WOODLANDS;
|
||||
return;
|
||||
}
|
||||
if (surface_humidity < 0.5) {
|
||||
data->biome = BIOME_FOREST;
|
||||
return;
|
||||
}
|
||||
data->biome = BIOME_JUNGLE;
|
||||
return;
|
||||
}
|
||||
|
||||
if (average_ground_height > 10) {
|
||||
if (surface_humidity < 0.25) {
|
||||
data->biome = BIOME_DESERT;
|
||||
return;
|
||||
}
|
||||
if (surface_humidity < 0.5) {
|
||||
data->biome = BIOME_WOODLANDS;
|
||||
return;
|
||||
}
|
||||
if (surface_humidity < 0.75) {
|
||||
data->biome = BIOME_FOREST;
|
||||
return;
|
||||
}
|
||||
data->biome = BIOME_JUNGLE;
|
||||
return;
|
||||
}
|
||||
|
||||
if (surface_humidity < 0.25) {
|
||||
data->biome = BIOME_PLAINS;
|
||||
return;
|
||||
}
|
||||
if (surface_humidity < 0.75) {
|
||||
data->biome = BIOME_WOODLANDS;
|
||||
return;
|
||||
}
|
||||
|
||||
data->biome = BIOME_FOREST;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -37,8 +37,6 @@ void plantgrowth_tree(ServerEnvironment *env, v3s16 p0)
|
|||
v3s16 p1 = p0;
|
||||
for (s16 ii=0; ii<trunk_h; ii++) {
|
||||
treenode.param1 = b|ii;
|
||||
if (ii == trunk_h-1)
|
||||
treenode.param1 |= 0x10;
|
||||
map->addNodeWithEvent(p1,treenode);
|
||||
b = 0;
|
||||
p1.Y++;
|
||||
|
|
@ -112,8 +110,6 @@ void plantgrowth_appletree(ServerEnvironment *env, v3s16 p0)
|
|||
v3s16 p1 = p0;
|
||||
for (s16 ii=0; ii<trunk_h; ii++) {
|
||||
treenode.param1 = b|ii;
|
||||
if (ii == trunk_h-1)
|
||||
treenode.param1 |= 0x10;
|
||||
map->addNodeWithEvent(p1,treenode);
|
||||
b = 0;
|
||||
p1.Y++;
|
||||
|
|
@ -190,8 +186,6 @@ void plantgrowth_conifertree(ServerEnvironment *env, v3s16 p0)
|
|||
v3s16 p1 = p0;
|
||||
for (s16 ii=0; ii<trunk_h; ii++) {
|
||||
treenode.param1 = b|ii;
|
||||
if (ii == trunk_h-1)
|
||||
treenode.param1 |= 0x10;
|
||||
map->addNodeWithEvent(p1,treenode);
|
||||
b = 0;
|
||||
p1.Y++;
|
||||
|
|
@ -239,8 +233,6 @@ void plantgrowth_largetree(ServerEnvironment *env, v3s16 p0)
|
|||
v3s16 p1 = p0;
|
||||
for (s16 ii=0; ii<trunk_h; ii++) {
|
||||
treenode.param1 = b|ii;
|
||||
if (ii == trunk_h-1)
|
||||
treenode.param1 |= 0x10;
|
||||
map->addNodeWithEvent(p1,treenode);
|
||||
b = 0;
|
||||
p1.Y++;
|
||||
|
|
@ -262,8 +254,6 @@ void plantgrowth_largetree(ServerEnvironment *env, v3s16 p0)
|
|||
for (s16 ki=0; ki<4; ki++) {
|
||||
p1.X++;
|
||||
treenode.param1 = b|((trunk_h-3)+ki);
|
||||
if (ki == 3)
|
||||
treenode.param1 |= 0x10;
|
||||
map->addNodeWithEvent(p1,treenode);
|
||||
}
|
||||
p1.X--;
|
||||
|
|
@ -273,8 +263,6 @@ void plantgrowth_largetree(ServerEnvironment *env, v3s16 p0)
|
|||
for (s16 ki=0; ki<4; ki++) {
|
||||
p1.X--;
|
||||
treenode.param1 = b|((trunk_h-3)+ki);
|
||||
if (ki == 3)
|
||||
treenode.param1 |= 0x10;
|
||||
map->addNodeWithEvent(p1,treenode);
|
||||
}
|
||||
p1.X++;
|
||||
|
|
@ -284,8 +272,6 @@ void plantgrowth_largetree(ServerEnvironment *env, v3s16 p0)
|
|||
for (s16 ki=0; ki<4; ki++) {
|
||||
p1.Z++;
|
||||
treenode.param1 = b|((trunk_h-3)+ki);
|
||||
if (ki == 3)
|
||||
treenode.param1 |= 0x10;
|
||||
map->addNodeWithEvent(p1,treenode);
|
||||
}
|
||||
p1.Z--;
|
||||
|
|
@ -295,13 +281,11 @@ void plantgrowth_largetree(ServerEnvironment *env, v3s16 p0)
|
|||
for (s16 ki=0; ki<4; ki++) {
|
||||
p1.Z--;
|
||||
treenode.param1 = b|((trunk_h-3)+ki);
|
||||
if (ki == 3)
|
||||
treenode.param1 |= 0x10;
|
||||
map->addNodeWithEvent(p1,treenode);
|
||||
}
|
||||
p1.Z++;
|
||||
}else{
|
||||
treenode.param1 = 0x10|trunk_h;
|
||||
treenode.param1 = trunk_h;
|
||||
map->addNodeWithEvent(p1,treenode);
|
||||
}
|
||||
// Force leaves at near the end of the trunk
|
||||
|
|
|
|||
|
|
@ -63,11 +63,12 @@
|
|||
19: new content type handling
|
||||
20: many existing content types translated to extended ones
|
||||
21: u8 param0 replaced with content_t content
|
||||
22: added biome id
|
||||
*/
|
||||
// This represents an uninitialized or invalid format
|
||||
#define SER_FMT_VER_INVALID 255
|
||||
// Highest supported serialization version
|
||||
#define SER_FMT_VER_HIGHEST 21
|
||||
#define SER_FMT_VER_HIGHEST 22
|
||||
// Lowest supported serialization version
|
||||
#define SER_FMT_VER_LOWEST 20
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue