commit
133e6562e5
|
@ -14,14 +14,14 @@ minetest.register_globalstep(function(dtime)
|
|||
for index, timer in ipairs(minetest.timers) do
|
||||
timer.time = timer.time - dtime
|
||||
if timer.time <= 0 then
|
||||
timer.func(timer.param)
|
||||
timer.func(unpack(timer.args))
|
||||
table.remove(minetest.timers,index)
|
||||
end
|
||||
end
|
||||
end)
|
||||
|
||||
function minetest.after(time, func, param)
|
||||
table.insert(minetest.timers_to_add, {time=time, func=func, param=param})
|
||||
function minetest.after(time, func, ...)
|
||||
table.insert(minetest.timers_to_add, {time=time, func=func, args=arg})
|
||||
end
|
||||
|
||||
function minetest.check_player_privs(name, privs)
|
||||
|
|
|
@ -8,9 +8,7 @@ varying vec3 vPosition;
|
|||
|
||||
void main(void)
|
||||
{
|
||||
vec4 pos = gl_Vertex;
|
||||
pos.y -= 2.0;
|
||||
gl_Position = mWorldViewProj * pos;
|
||||
gl_Position = mWorldViewProj * gl_Vertex;
|
||||
|
||||
vPosition = (mWorldViewProj * gl_Vertex).xyz;
|
||||
|
||||
|
|
|
@ -0,0 +1,130 @@
|
|||
#-------------------------------------------------------------------
|
||||
# This file is stolen from part of the CMake build system for OGRE (Object-oriented Graphics Rendering Engine) http://www.ogre3d.org/
|
||||
#
|
||||
# The contents of this file are placed in the public domain. Feel
|
||||
# free to make use of it in any way you like.
|
||||
#-------------------------------------------------------------------
|
||||
|
||||
# - Try to find OpenGLES and EGL
|
||||
# Once done this will define
|
||||
#
|
||||
# OPENGLES2_FOUND - system has OpenGLES
|
||||
# OPENGLES2_INCLUDE_DIR - the GL include directory
|
||||
# OPENGLES2_LIBRARIES - Link these to use OpenGLES
|
||||
#
|
||||
# EGL_FOUND - system has EGL
|
||||
# EGL_INCLUDE_DIR - the EGL include directory
|
||||
# EGL_LIBRARIES - Link these to use EGL
|
||||
|
||||
# win32, apple, android NOT TESED
|
||||
# linux tested and works
|
||||
|
||||
IF (WIN32)
|
||||
IF (CYGWIN)
|
||||
|
||||
FIND_PATH(OPENGLES2_INCLUDE_DIR GLES2/gl2.h )
|
||||
|
||||
FIND_LIBRARY(OPENGLES2_gl_LIBRARY libGLESv2 )
|
||||
|
||||
ELSE (CYGWIN)
|
||||
|
||||
IF(BORLAND)
|
||||
SET (OPENGLES2_gl_LIBRARY import32 CACHE STRING "OpenGL ES 2.x library for win32")
|
||||
ELSE(BORLAND)
|
||||
# todo
|
||||
# SET (OPENGLES_gl_LIBRARY ${SOURCE_DIR}/Dependencies/lib/release/libGLESv2.lib CACHE STRING "OpenGL ES 2.x library for win32"
|
||||
ENDIF(BORLAND)
|
||||
|
||||
ENDIF (CYGWIN)
|
||||
|
||||
ELSE (WIN32)
|
||||
|
||||
IF (APPLE)
|
||||
|
||||
create_search_paths(/Developer/Platforms)
|
||||
findpkg_framework(OpenGLES2)
|
||||
set(OPENGLES2_gl_LIBRARY "-framework OpenGLES")
|
||||
|
||||
ELSE(APPLE)
|
||||
|
||||
FIND_PATH(OPENGLES2_INCLUDE_DIR GLES2/gl2.h
|
||||
/usr/openwin/share/include
|
||||
/opt/graphics/OpenGL/include /usr/X11R6/include
|
||||
/usr/include
|
||||
)
|
||||
|
||||
FIND_LIBRARY(OPENGLES2_gl_LIBRARY
|
||||
NAMES GLESv2
|
||||
PATHS /opt/graphics/OpenGL/lib
|
||||
/usr/openwin/lib
|
||||
/usr/shlib /usr/X11R6/lib
|
||||
/usr/lib
|
||||
)
|
||||
|
||||
IF (NOT BUILD_ANDROID)
|
||||
FIND_PATH(EGL_INCLUDE_DIR EGL/egl.h
|
||||
/usr/openwin/share/include
|
||||
/opt/graphics/OpenGL/include /usr/X11R6/include
|
||||
/usr/include
|
||||
)
|
||||
|
||||
FIND_LIBRARY(EGL_egl_LIBRARY
|
||||
NAMES EGL
|
||||
PATHS /opt/graphics/OpenGL/lib
|
||||
/usr/openwin/lib
|
||||
/usr/shlib /usr/X11R6/lib
|
||||
/usr/lib
|
||||
)
|
||||
|
||||
# On Unix OpenGL most certainly always requires X11.
|
||||
# Feel free to tighten up these conditions if you don't
|
||||
# think this is always true.
|
||||
# It's not true on OSX.
|
||||
|
||||
IF (OPENGLES2_gl_LIBRARY)
|
||||
IF(NOT X11_FOUND)
|
||||
INCLUDE(FindX11)
|
||||
ENDIF(NOT X11_FOUND)
|
||||
IF (X11_FOUND)
|
||||
IF (NOT APPLE)
|
||||
SET (OPENGLES2_LIBRARIES ${X11_LIBRARIES})
|
||||
ENDIF (NOT APPLE)
|
||||
ENDIF (X11_FOUND)
|
||||
ENDIF (OPENGLES2_gl_LIBRARY)
|
||||
ENDIF ()
|
||||
|
||||
ENDIF(APPLE)
|
||||
ENDIF (WIN32)
|
||||
|
||||
#SET( OPENGLES2_LIBRARIES ${OPENGLES2_gl_LIBRARY} ${OPENGLES2_LIBRARIES})
|
||||
|
||||
IF (BUILD_ANDROID)
|
||||
IF(OPENGLES2_gl_LIBRARY)
|
||||
SET( OPENGLES2_LIBRARIES ${OPENGLES2_gl_LIBRARY} ${OPENGLES2_LIBRARIES})
|
||||
SET( EGL_LIBRARIES)
|
||||
SET( OPENGLES2_FOUND "YES" )
|
||||
ENDIF(OPENGLES2_gl_LIBRARY)
|
||||
ELSE ()
|
||||
|
||||
SET( OPENGLES2_LIBRARIES ${OPENGLES2_gl_LIBRARY} ${OPENGLES2_LIBRARIES})
|
||||
|
||||
IF(OPENGLES2_gl_LIBRARY AND EGL_egl_LIBRARY)
|
||||
SET( OPENGLES2_LIBRARIES ${OPENGLES2_gl_LIBRARY} ${OPENGLES2_LIBRARIES})
|
||||
SET( EGL_LIBRARIES ${EGL_egl_LIBRARY} ${EGL_LIBRARIES})
|
||||
SET( OPENGLES2_FOUND "YES" )
|
||||
ENDIF(OPENGLES2_gl_LIBRARY AND EGL_egl_LIBRARY)
|
||||
|
||||
ENDIF ()
|
||||
|
||||
MARK_AS_ADVANCED(
|
||||
OPENGLES2_INCLUDE_DIR
|
||||
OPENGLES2_gl_LIBRARY
|
||||
EGL_INCLUDE_DIR
|
||||
EGL_egl_LIBRARY
|
||||
)
|
||||
|
||||
IF(OPENGLES2_FOUND)
|
||||
MESSAGE(STATUS "Found system opengles2 library ${OPENGLES2_LIBRARIES}")
|
||||
ELSE ()
|
||||
SET(OPENGLES2_LIBRARIES "")
|
||||
ENDIF ()
|
|
@ -977,9 +977,9 @@ minetest.sound_play(spec, parameters) -> handle
|
|||
minetest.sound_stop(handle)
|
||||
|
||||
Timing:
|
||||
minetest.after(time, func, param)
|
||||
minetest.after(time, func, ...)
|
||||
^ Call function after time seconds
|
||||
^ param is optional; to pass multiple parameters, pass a table.
|
||||
^ Optional: Variable number of arguments that are passed to func
|
||||
|
||||
Server:
|
||||
minetest.request_shutdown() -> request for server shutdown
|
||||
|
@ -1228,6 +1228,8 @@ Player-only: (no-op for other objects)
|
|||
- get_look_dir(): get camera direction as a unit vector
|
||||
- get_look_pitch(): pitch in radians
|
||||
- get_look_yaw(): yaw in radians (wraps around pretty randomly as of now)
|
||||
- set_look_pitch(radians): sets look pitch
|
||||
- set_look_yaw(radians): sets look yaw
|
||||
- set_inventory_formspec(formspec)
|
||||
^ Redefine player's inventory form
|
||||
^ Should usually be called in on_joinplayer
|
||||
|
|
|
@ -69,10 +69,19 @@ local function generate_ore(name, wherein, minp, maxp, seed, chunks_per_volume,
|
|||
end
|
||||
|
||||
minetest.register_on_generated(function(minp, maxp, seed)
|
||||
generate_ore("default:stone_with_coal", "default:stone", minp, maxp, seed, 1/8/8/8, 5, -31000, 64)
|
||||
generate_ore("default:stone_with_iron", "default:stone", minp, maxp, seed+1, 1/16/16/16, 5, -5, 7)
|
||||
generate_ore("default:stone_with_iron", "default:stone", minp, maxp, seed+2, 1/12/12/12, 5, -16, -5)
|
||||
generate_ore("default:stone_with_iron", "default:stone", minp, maxp, seed+3, 1/9/9/9, 5, -31000, -17)
|
||||
generate_ore("default:stone_with_coal", "default:stone", minp, maxp, seed, 1/8/8/8, 5, -31000, 64 )
|
||||
generate_ore("default:stone_with_iron", "default:stone", minp, maxp, seed+1, 1/16/16/16, 5, -5, 7 )
|
||||
generate_ore("default:stone_with_iron", "default:stone", minp, maxp, seed+2, 1/12/12/12, 5, -16, -5 )
|
||||
generate_ore("default:stone_with_iron", "default:stone", minp, maxp, seed+3, 1/9/9/9, 5, -31000, -17 )
|
||||
|
||||
if minetest.setting_getbool("underground_springs") then
|
||||
generate_ore("default:water_source", "default:stone", minp, maxp, seed+4, 1/24/24/24, 12, -100, -11, 128)
|
||||
generate_ore("default:water_source", "default:stone", minp, maxp, seed+5, 1/28/28/28, 8, -10000, -101, 128)
|
||||
generate_ore("default:lava_source", "default:stone", minp, maxp, seed+6, 1/38/38/38, 6, -500, -101, 128)
|
||||
generate_ore("default:lava_source", "default:stone", minp, maxp, seed+7, 1/30/30/30, 16, -5000, -501, 128)
|
||||
generate_ore("default:lava_source", "default:stone", minp, maxp, seed+8, 1/24/24/24, 20, -31000, -5001, 128)
|
||||
end
|
||||
|
||||
-- Generate clay
|
||||
if maxp.y >= 2 and minp.y <= 0 then
|
||||
-- Assume X and Z lengths are equal
|
||||
|
@ -110,11 +119,5 @@ minetest.register_on_generated(function(minp, maxp, seed)
|
|||
end
|
||||
end
|
||||
end
|
||||
if minetest.setting_get("liquid_finite") then
|
||||
generate_ore("default:water_source", "default:stone", minp, maxp, seed+42, 1/24/24/24, 4, -100, -10, 128)
|
||||
generate_ore("default:water_source", "default:stone", minp, maxp, seed+42, 1/28/28/28, 3, -10000, -101, 128)
|
||||
generate_ore("default:lava_source", "default:stone", minp, maxp, seed+43, 1/38/38/38, 2, -500, -100, 128)
|
||||
generate_ore("default:lava_source", "default:stone", minp, maxp, seed+43, 1/30/30/30, 4, -31000, -501, 128)
|
||||
end
|
||||
end)
|
||||
|
||||
|
|
|
@ -80,6 +80,7 @@
|
|||
# when set to higher number than 0
|
||||
#fsaa = 0
|
||||
#vsync = false
|
||||
#fov = 72
|
||||
# Address to connect to (#blank = start local server)
|
||||
#address =
|
||||
# Enable random user input, for testing
|
||||
|
@ -95,9 +96,11 @@
|
|||
# Update liquids every .. recommend for finite: 0.2
|
||||
#liquid_update = 1.0
|
||||
# When finite liquid: relax flowing blocks to source if level near max and N nearby source blocks, more realistic, but not true constant. values: 0,1,2,3,4 : 0 - disable, 1 - most aggresive
|
||||
#liquid_relax = 1
|
||||
# optimization: faster cave flood (and not true constant)
|
||||
#liquid_relax = 2
|
||||
# Optimization: faster cave flood (and not true constant)
|
||||
#liquid_fast_flood = 1
|
||||
# Underground water and lava springs, its infnity sources if liquid_finite enabled
|
||||
#underground_springs = 1
|
||||
# Enable nice leaves; disable for speed
|
||||
#new_style_leaves = true
|
||||
# Enable smooth lighting with simple ambient occlusion;
|
||||
|
@ -125,6 +128,8 @@
|
|||
#farmesh_distance = 40
|
||||
# Enable/disable clouds
|
||||
#enable_clouds = true
|
||||
#cloud_height = 120
|
||||
#enable_3d_clouds = true
|
||||
# Use a cloud animation for the main menu background
|
||||
#menu_clouds = true
|
||||
# Path for screenshots
|
||||
|
@ -306,29 +311,38 @@
|
|||
# Mapgen stuff
|
||||
#
|
||||
|
||||
# Name of map generator to be used. Currently only v6 is supported.
|
||||
# Name of map generator to be used. Currently v6 and indev are supported.
|
||||
#mg_name = v6
|
||||
# Water level of map.
|
||||
#water_level = 1
|
||||
# Size of chunks to be generated.
|
||||
#chunksize = 5
|
||||
# Map generation attributes. Currently supported: trees, caves, flat, v6_biome_blend
|
||||
# Map generation attributes. Currently supported: trees, caves, flat, v6_biome_blend, v6_jungles, dungeons
|
||||
#mg_flags = trees, caves, v6_biome_blend
|
||||
# How large deserts and beaches are
|
||||
#mgv6_freq_desert = 0.45
|
||||
#mgv6_freq_beach = 0.15
|
||||
# Perlin noise attributes for different map generation parameters
|
||||
# Offset, scale, spread factor, seed offset, number of octaves, persistence
|
||||
#mgv6_np_terrain_base = -4, 20, (250.0, 250, 250), 82341, 5, 0.6
|
||||
#mgv6_np_terrain_base = -4, 20, (250, 250, 250), 82341, 5, 0.6
|
||||
#mgv6_np_terrain_higher = 20, 16, (500, 500, 500), 85039, 5, 0.6
|
||||
#mgv6_np_steepness = 0.85, 0.5, (125, 125, 125), -932, 5, 0.7
|
||||
#mgv6_np_height_select = 0.5, 1, (250, 250, 250), 4213, 5, 0.69
|
||||
#mgv6_np_trees = 0, 1, (125, 125, 125), 2, 4, 0.66
|
||||
#mgv6_np_mud = 4, 2, (200, 200, 200), 91013, 3, 0.55
|
||||
#mgv6_np_beach = 0, 1, (250, 250, 250), 59420, 3, 0.50
|
||||
#mgv6_np_biome = 0, 1, (250, 250, 250), 9130, 3, 0.50
|
||||
#mgv6_np_cave = 6, 6, (250, 250, 250), 34329, 3, 0.50
|
||||
#mgv6_np_humidity = 0.5, 0.5, (500, 500, 500), 72384, 4, 0.66
|
||||
#mgv6_np_trees = 0, 1, (125, 125, 125), 2, 4, 0.66
|
||||
#mgv6_np_apple_trees = 0, 1, (100, 100, 100), 342902, 3, 0.45
|
||||
|
||||
#mgv7_np_terrain = 10, 12, (350, 350, 350), 82341, 5, 0.6
|
||||
#mgv7_np_bgroup = 0.5, 0.3125, (350, 350, 350), 5923, 2, 0.6
|
||||
#mgv7_np_heat = 25, 50, (500, 500, 500), 35293, 1, 0
|
||||
#mgv7_np_humidity = 50, 31.25, (750, 750, 750), 12094, 2, 0.6
|
||||
|
||||
# Offset, scale, spread factor, seed offset, number of octaves, persistence, farscale
|
||||
#mgindev_np_terrain_base = -4, 20, (250.0, 250, 250), 82341, 5, 0.6, 10
|
||||
#mgindev_np_terrain_higher = 20, 16, (500, 500, 500), 85039, 5, 0.6, 10
|
||||
#mgindev_np_steepness = 0.85, 0.5, (125, 125, 125), -932, 5, 0.7, 10
|
||||
#mgindev_np_mud = 4, 2, (200, 200, 200), 91013, 3, 0.55, 1
|
||||
|
|
|
@ -172,6 +172,7 @@ endif()
|
|||
find_package(Jthread REQUIRED)
|
||||
find_package(Sqlite3 REQUIRED)
|
||||
find_package(Json REQUIRED)
|
||||
find_package(OpenGLES2)
|
||||
|
||||
if(USE_FREETYPE)
|
||||
find_package(Freetype REQUIRED)
|
||||
|
@ -225,6 +226,7 @@ set(common_SRCS
|
|||
emerge.cpp
|
||||
mapgen.cpp
|
||||
mapgen_v6.cpp
|
||||
mapgen_indev.cpp
|
||||
treegen.cpp
|
||||
dungeongen.cpp
|
||||
content_nodemeta.cpp
|
||||
|
@ -385,6 +387,7 @@ if(BUILD_CLIENT)
|
|||
${SQLITE3_LIBRARY}
|
||||
${LUA_LIBRARY}
|
||||
${JSON_LIBRARY}
|
||||
${OPENGLES2_LIBRARIES}
|
||||
${PLATFORM_LIBS}
|
||||
${CLIENT_PLATFORM_LIBS}
|
||||
)
|
||||
|
|
|
@ -94,11 +94,22 @@ public:
|
|||
class MakeTreesFromSaplingsABM : public ActiveBlockModifier
|
||||
{
|
||||
private:
|
||||
content_t c_junglesapling;
|
||||
content_t c_dirt;
|
||||
content_t c_dirt_with_grass;
|
||||
|
||||
public:
|
||||
MakeTreesFromSaplingsABM(ServerEnvironment *env, INodeDefManager *nodemgr) {
|
||||
c_junglesapling = nodemgr->getId("junglesapling");
|
||||
c_dirt = nodemgr->getId("mapgen_dirt");
|
||||
c_dirt_with_grass = nodemgr->getId("mapgen_dirt_with_grass");
|
||||
}
|
||||
|
||||
virtual std::set<std::string> getTriggerContents()
|
||||
{
|
||||
std::set<std::string> s;
|
||||
s.insert("sapling");
|
||||
s.insert("junglesapling");
|
||||
return s;
|
||||
}
|
||||
virtual float getTriggerInterval()
|
||||
|
@ -111,16 +122,30 @@ public:
|
|||
INodeDefManager *ndef = env->getGameDef()->ndef();
|
||||
ServerMap *map = &env->getServerMap();
|
||||
|
||||
actionstream<<"A sapling grows into a tree at "
|
||||
<<PP(p)<<std::endl;
|
||||
MapNode n_below = map->getNodeNoEx(p - v3s16(0, 1, 0));
|
||||
if (n_below.getContent() != c_dirt &&
|
||||
n_below.getContent() != c_dirt_with_grass)
|
||||
return;
|
||||
|
||||
bool is_jungle_tree = n.getContent() == c_junglesapling;
|
||||
|
||||
actionstream <<"A " << (is_jungle_tree ? "jungle " : "")
|
||||
<< "sapling grows into a tree at "
|
||||
<< PP(p) << std::endl;
|
||||
|
||||
std::map<v3s16, MapBlock*> modified_blocks;
|
||||
v3s16 tree_p = p;
|
||||
ManualMapVoxelManipulator vmanip(map);
|
||||
v3s16 tree_blockp = getNodeBlockPos(tree_p);
|
||||
vmanip.initialEmerge(tree_blockp - v3s16(1,1,1), tree_blockp + v3s16(1,1,1));
|
||||
bool is_apple_tree = myrand()%4 == 0;
|
||||
treegen::make_tree(vmanip, tree_p, is_apple_tree, ndef, myrand());
|
||||
|
||||
if (is_jungle_tree) {
|
||||
treegen::make_jungletree(vmanip, tree_p, ndef, myrand());
|
||||
} else {
|
||||
bool is_apple_tree = myrand() % 4 == 0;
|
||||
treegen::make_tree(vmanip, tree_p, is_apple_tree, ndef, myrand());
|
||||
}
|
||||
|
||||
vmanip.blitBackAll(&modified_blocks);
|
||||
|
||||
// update lighting
|
||||
|
@ -177,7 +202,7 @@ void add_legacy_abms(ServerEnvironment *env, INodeDefManager *nodedef)
|
|||
{
|
||||
env->addActiveBlockModifier(new GrowGrassABM());
|
||||
env->addActiveBlockModifier(new RemoveGrassABM());
|
||||
env->addActiveBlockModifier(new MakeTreesFromSaplingsABM());
|
||||
env->addActiveBlockModifier(new MakeTreesFromSaplingsABM(env, nodedef));
|
||||
if (g_settings->getBool("liquid_finite"))
|
||||
env->addActiveBlockModifier(new LiquidFlowABM(env, nodedef));
|
||||
}
|
||||
|
|
|
@ -160,18 +160,145 @@ void mapblock_mesh_generate_special(MeshMakeData *data,
|
|||
Add water sources to mesh if using new style
|
||||
*/
|
||||
TileSpec tile_liquid = f.special_tiles[0];
|
||||
TileSpec tile_liquid_bfculled = getNodeTile(n, p, v3s16(0,0,0), data);
|
||||
AtlasPointer &pa_liquid = tile_liquid.texture;
|
||||
|
||||
bool top_is_air = false;
|
||||
MapNode n = data->m_vmanip.getNodeNoEx(blockpos_nodes + v3s16(x,y+1,z));
|
||||
if(n.getContent() == CONTENT_AIR)
|
||||
top_is_air = true;
|
||||
|
||||
if(top_is_air == false)
|
||||
continue;
|
||||
bool top_is_same_liquid = false;
|
||||
MapNode ntop = data->m_vmanip.getNodeNoEx(blockpos_nodes + v3s16(x,y+1,z));
|
||||
content_t c_flowing = nodedef->getId(f.liquid_alternative_flowing);
|
||||
content_t c_source = nodedef->getId(f.liquid_alternative_source);
|
||||
if(ntop.getContent() == c_flowing || ntop.getContent() == c_source)
|
||||
top_is_same_liquid = true;
|
||||
|
||||
u16 l = getInteriorLight(n, 0, data);
|
||||
video::SColor c = MapBlock_LightColor(f.alpha, l, decode_light(f.light_source));
|
||||
|
||||
/*
|
||||
Generate sides
|
||||
*/
|
||||
v3s16 side_dirs[4] = {
|
||||
v3s16(1,0,0),
|
||||
v3s16(-1,0,0),
|
||||
v3s16(0,0,1),
|
||||
v3s16(0,0,-1),
|
||||
};
|
||||
for(u32 i=0; i<4; i++)
|
||||
{
|
||||
v3s16 dir = side_dirs[i];
|
||||
|
||||
MapNode neighbor = data->m_vmanip.getNodeNoEx(blockpos_nodes + p + dir);
|
||||
content_t neighbor_content = neighbor.getContent();
|
||||
const ContentFeatures &n_feat = nodedef->get(neighbor_content);
|
||||
MapNode n_top = data->m_vmanip.getNodeNoEx(blockpos_nodes + p + dir+ v3s16(0,1,0));
|
||||
content_t n_top_c = n_top.getContent();
|
||||
|
||||
if(neighbor_content == CONTENT_IGNORE)
|
||||
continue;
|
||||
|
||||
/*
|
||||
If our topside is liquid and neighbor's topside
|
||||
is liquid, don't draw side face
|
||||
*/
|
||||
if(top_is_same_liquid && (n_top_c == c_flowing ||
|
||||
n_top_c == c_source || n_top_c == CONTENT_IGNORE))
|
||||
continue;
|
||||
|
||||
// Don't draw face if neighbor is blocking the view
|
||||
if(n_feat.solidness == 2)
|
||||
continue;
|
||||
|
||||
bool neighbor_is_same_liquid = (neighbor_content == c_source
|
||||
|| neighbor_content == c_flowing);
|
||||
|
||||
// Don't draw any faces if neighbor same is liquid and top is
|
||||
// same liquid
|
||||
if(neighbor_is_same_liquid && !top_is_same_liquid)
|
||||
continue;
|
||||
|
||||
// Use backface culled material if neighbor doesn't have a
|
||||
// solidness of 0
|
||||
const TileSpec *current_tile = &tile_liquid;
|
||||
if(n_feat.solidness != 0 || n_feat.visual_solidness != 0)
|
||||
current_tile = &tile_liquid_bfculled;
|
||||
|
||||
video::S3DVertex vertices[4] =
|
||||
{
|
||||
video::S3DVertex(-BS/2,0,BS/2,0,0,0, c,
|
||||
pa_liquid.x0(), pa_liquid.y1()),
|
||||
video::S3DVertex(BS/2,0,BS/2,0,0,0, c,
|
||||
pa_liquid.x1(), pa_liquid.y1()),
|
||||
video::S3DVertex(BS/2,0,BS/2, 0,0,0, c,
|
||||
pa_liquid.x1(), pa_liquid.y0()),
|
||||
video::S3DVertex(-BS/2,0,BS/2, 0,0,0, c,
|
||||
pa_liquid.x0(), pa_liquid.y0()),
|
||||
};
|
||||
|
||||
/*
|
||||
If our topside is liquid, set upper border of face
|
||||
at upper border of node
|
||||
*/
|
||||
if(top_is_same_liquid)
|
||||
{
|
||||
vertices[2].Pos.Y = 0.5*BS;
|
||||
vertices[3].Pos.Y = 0.5*BS;
|
||||
}
|
||||
/*
|
||||
Otherwise upper position of face is liquid level
|
||||
*/
|
||||
else
|
||||
{
|
||||
vertices[2].Pos.Y = (node_liquid_level-0.5)*BS;
|
||||
vertices[3].Pos.Y = (node_liquid_level-0.5)*BS;
|
||||
}
|
||||
/*
|
||||
If neighbor is liquid, lower border of face is liquid level
|
||||
*/
|
||||
if(neighbor_is_same_liquid)
|
||||
{
|
||||
vertices[0].Pos.Y = (node_liquid_level-0.5)*BS;
|
||||
vertices[1].Pos.Y = (node_liquid_level-0.5)*BS;
|
||||
}
|
||||
/*
|
||||
If neighbor is not liquid, lower border of face is
|
||||
lower border of node
|
||||
*/
|
||||
else
|
||||
{
|
||||
vertices[0].Pos.Y = -0.5*BS;
|
||||
vertices[1].Pos.Y = -0.5*BS;
|
||||
}
|
||||
|
||||
for(s32 j=0; j<4; j++)
|
||||
{
|
||||
if(dir == v3s16(0,0,1))
|
||||
vertices[j].Pos.rotateXZBy(0);
|
||||
if(dir == v3s16(0,0,-1))
|
||||
vertices[j].Pos.rotateXZBy(180);
|
||||
if(dir == v3s16(-1,0,0))
|
||||
vertices[j].Pos.rotateXZBy(90);
|
||||
if(dir == v3s16(1,0,-0))
|
||||
vertices[j].Pos.rotateXZBy(-90);
|
||||
|
||||
// Do this to not cause glitches when two liquids are
|
||||
// side-by-side
|
||||
/*if(neighbor_is_same_liquid == false){
|
||||
vertices[j].Pos.X *= 0.98;
|
||||
vertices[j].Pos.Z *= 0.98;
|
||||
}*/
|
||||
|
||||
vertices[j].Pos += intToFloat(p, BS);
|
||||
}
|
||||
|
||||
u16 indices[] = {0,1,2,2,3,0};
|
||||
// Add to mesh collector
|
||||
collector.append(*current_tile, vertices, 4, indices, 6);
|
||||
}
|
||||
|
||||
/*
|
||||
Generate top
|
||||
*/
|
||||
if(top_is_same_liquid)
|
||||
continue;
|
||||
|
||||
video::S3DVertex vertices[4] =
|
||||
{
|
||||
|
@ -185,7 +312,7 @@ void mapblock_mesh_generate_special(MeshMakeData *data,
|
|||
pa_liquid.x0(), pa_liquid.y0()),
|
||||
};
|
||||
|
||||
v3f offset(p.X, p.Y + (-0.5+node_liquid_level)*BS, p.Z);
|
||||
v3f offset(p.X*BS, p.Y*BS + (-0.5+node_liquid_level)*BS, p.Z*BS);
|
||||
for(s32 i=0; i<4; i++)
|
||||
{
|
||||
vertices[i].Pos += offset;
|
||||
|
@ -324,7 +451,7 @@ void mapblock_mesh_generate_special(MeshMakeData *data,
|
|||
}
|
||||
}
|
||||
if(air_count >= 2)
|
||||
cornerlevel = -0.5*BS+0.1;
|
||||
cornerlevel = -0.5*BS+0.2;
|
||||
else if(valid_count > 0)
|
||||
cornerlevel /= valid_count;
|
||||
corner_levels[i] = cornerlevel;
|
||||
|
|
|
@ -1230,6 +1230,20 @@ void PlayerSAO::moveTo(v3f pos, bool continuous)
|
|||
m_moved = true;
|
||||
}
|
||||
|
||||
void PlayerSAO::setYaw(float yaw)
|
||||
{
|
||||
m_player->setYaw(yaw);
|
||||
// Force change on client
|
||||
m_moved = true;
|
||||
}
|
||||
|
||||
void PlayerSAO::setPitch(float pitch)
|
||||
{
|
||||
m_player->setPitch(pitch);
|
||||
// Force change on client
|
||||
m_moved = true;
|
||||
}
|
||||
|
||||
int PlayerSAO::punch(v3f dir,
|
||||
const ToolCapabilities *toolcap,
|
||||
ServerActiveObject *puncher,
|
||||
|
|
|
@ -147,6 +147,8 @@ public:
|
|||
void setBasePosition(const v3f &position);
|
||||
void setPos(v3f pos);
|
||||
void moveTo(v3f pos, bool continuous);
|
||||
void setYaw(float);
|
||||
void setPitch(float);
|
||||
|
||||
/*
|
||||
Interaction interface
|
||||
|
|
|
@ -203,34 +203,43 @@ void set_default_settings(Settings *settings)
|
|||
settings->setDefault("movement_liquid_fluidity_smooth", "0.5");
|
||||
settings->setDefault("movement_liquid_sink", "10");
|
||||
settings->setDefault("movement_gravity", "9.81");
|
||||
|
||||
|
||||
//liquid stuff
|
||||
settings->setDefault("liquid_finite", "false");
|
||||
settings->setDefault("liquid_update", "1.0");
|
||||
settings->setDefault("liquid_relax", "1");
|
||||
settings->setDefault("liquid_relax", "2");
|
||||
settings->setDefault("liquid_fast_flood", "1");
|
||||
settings->setDefault("underground_springs", "1");
|
||||
|
||||
//mapgen stuff
|
||||
settings->setDefault("mg_name", "v6");
|
||||
settings->setDefault("water_level", "1");
|
||||
settings->setDefault("water_level", "1");
|
||||
settings->setDefault("chunksize", "5");
|
||||
settings->setDefault("mg_flags", "trees, caves, v6_biome_blend");
|
||||
settings->setDefault("mgv6_freq_desert", "0.45");
|
||||
settings->setDefault("mgv6_freq_beach", "0.15");
|
||||
|
||||
settings->setDefault("mgv6_np_terrain_base", "-4, 20, (250.0, 250, 250), 82341, 5, 0.6");
|
||||
settings->setDefault("mgv6_np_terrain_base", "-4, 20, (250, 250, 250), 82341, 5, 0.6");
|
||||
settings->setDefault("mgv6_np_terrain_higher", "20, 16, (500, 500, 500), 85039, 5, 0.6");
|
||||
settings->setDefault("mgv6_np_steepness", "0.85, 0.5, (125, 125, 125), -932, 5, 0.7");
|
||||
settings->setDefault("mgv6_np_height_select", "0.5, 1, (250, 250, 250), 4213, 5, 0.69");
|
||||
settings->setDefault("mgv6_np_trees", "0, 1, (125, 125, 125), 2, 4, 0.66");
|
||||
settings->setDefault("mgv6_np_mud", "4, 2, (200, 200, 200), 91013, 3, 0.55");
|
||||
settings->setDefault("mgv6_np_beach", "0, 1, (250, 250, 250), 59420, 3, 0.50");
|
||||
settings->setDefault("mgv6_np_biome", "0, 1, (250, 250, 250), 9130, 3, 0.50");
|
||||
settings->setDefault("mgv6_np_cave", "6, 6, (250, 250, 250), 34329, 3, 0.50");
|
||||
settings->setDefault("mgv6_np_humidity", "0.5, 0.5, (500, 500, 500), 72384, 4, 0.66");
|
||||
settings->setDefault("mgv6_np_trees", "0, 1, (125, 125, 125), 2, 4, 0.66");
|
||||
settings->setDefault("mgv6_np_apple_trees", "0, 1, (100, 100, 100), 342902, 3, 0.45");
|
||||
|
||||
settings->setDefault("mgv7_np_terrain", "10, 12, (350, 350, 350), 82341, 5, 0.6");
|
||||
settings->setDefault("mgv7_np_bgroup", "0.5, 0.3125, (350, 350, 350), 5923, 2, 0.6");
|
||||
settings->setDefault("mgv7_np_heat", "25, 50, (500, 500, 500), 35293, 1, 0");
|
||||
settings->setDefault("mgv7_np_humidity", "50, 31.25, (750, 750, 750), 12094, 2, 0.6");
|
||||
|
||||
settings->setDefault("mgindev_np_terrain_base", "-4, 20, (250.0, 250, 250), 82341, 5, 0.6, 10");
|
||||
settings->setDefault("mgindev_np_terrain_higher", "20, 16, (500, 500, 500), 85039, 5, 0.6, 10");
|
||||
settings->setDefault("mgindev_np_steepness", "0.85, 0.5, (125, 125, 125), -932, 5, 0.7, 10");
|
||||
settings->setDefault("mgindev_np_mud", "4, 2, (200, 200, 200), 91013, 3, 0.55, 1");
|
||||
|
||||
}
|
||||
|
||||
|
|
|
@ -39,6 +39,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
|
|||
#include "biome.h"
|
||||
#include "emerge.h"
|
||||
#include "mapgen_v6.h"
|
||||
#include "mapgen_indev.h"
|
||||
|
||||
|
||||
/////////////////////////////// Emerge Manager ////////////////////////////////
|
||||
|
@ -46,6 +47,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
|
|||
EmergeManager::EmergeManager(IGameDef *gamedef, BiomeDefManager *bdef) {
|
||||
//register built-in mapgens
|
||||
registerMapgen("v6", new MapgenFactoryV6());
|
||||
registerMapgen("indev", new MapgenFactoryIndev());
|
||||
|
||||
this->biomedef = bdef ? bdef : new BiomeDefManager(gamedef);
|
||||
this->params = NULL;
|
||||
|
|
32
src/main.cpp
32
src/main.cpp
|
@ -1350,6 +1350,14 @@ int main(int argc, char *argv[])
|
|||
driverType = video::EDT_DIRECT3D9;
|
||||
else if(driverstring == "opengl")
|
||||
driverType = video::EDT_OPENGL;
|
||||
#ifdef _IRR_COMPILE_WITH_OGLES1_
|
||||
else if(driverstring == "ogles1")
|
||||
driverType = video::EDT_OGLES1;
|
||||
#endif
|
||||
#ifdef _IRR_COMPILE_WITH_OGLES2_
|
||||
else if(driverstring == "ogles2")
|
||||
driverType = video::EDT_OGLES2;
|
||||
#endif
|
||||
else
|
||||
{
|
||||
errorstream<<"WARNING: Invalid video_driver specified; defaulting "
|
||||
|
@ -1589,7 +1597,7 @@ int main(int argc, char *argv[])
|
|||
if(skip_main_menu == false)
|
||||
{
|
||||
video::IVideoDriver* driver = device->getVideoDriver();
|
||||
|
||||
float fps_max = g_settings->getFloat("fps_max");
|
||||
infostream<<"Waiting for other menus"<<std::endl;
|
||||
while(device->run() && kill == false)
|
||||
{
|
||||
|
@ -1682,8 +1690,28 @@ int main(int argc, char *argv[])
|
|||
|
||||
// On some computers framerate doesn't seem to be
|
||||
// automatically limited
|
||||
if (!cloud_menu_background)
|
||||
if (cloud_menu_background) {
|
||||
// Time of frame without fps limit
|
||||
float busytime;
|
||||
u32 busytime_u32;
|
||||
// not using getRealTime is necessary for wine
|
||||
u32 time = device->getTimer()->getTime();
|
||||
if(time > lasttime)
|
||||
busytime_u32 = time - lasttime;
|
||||
else
|
||||
busytime_u32 = 0;
|
||||
busytime = busytime_u32 / 1000.0;
|
||||
|
||||
// FPS limiter
|
||||
u32 frametime_min = 1000./fps_max;
|
||||
|
||||
if(busytime_u32 < frametime_min) {
|
||||
u32 sleeptime = frametime_min - busytime_u32;
|
||||
device->sleep(sleeptime);
|
||||
}
|
||||
} else {
|
||||
sleep_ms(25);
|
||||
}
|
||||
}
|
||||
|
||||
infostream<<"Dropping main menu"<<std::endl;
|
||||
|
|
134
src/map.cpp
134
src/map.cpp
|
@ -35,6 +35,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
|
|||
#include "rollback_interface.h"
|
||||
#include "emerge.h"
|
||||
#include "mapgen_v6.h"
|
||||
#include "mapgen_indev.h"
|
||||
|
||||
#define PP(x) "("<<(x).X<<","<<(x).Y<<","<<(x).Z<<")"
|
||||
|
||||
|
@ -1323,7 +1324,7 @@ bool Map::addNodeWithEvent(v3s16 p, MapNode n)
|
|||
i = modified_blocks.begin();
|
||||
i != modified_blocks.end(); ++i)
|
||||
{
|
||||
event.modified_blocks.erase(i->first);
|
||||
event.modified_blocks.insert(i->first);
|
||||
}
|
||||
}
|
||||
catch(InvalidPositionException &e){
|
||||
|
@ -1351,7 +1352,7 @@ bool Map::removeNodeWithEvent(v3s16 p)
|
|||
i = modified_blocks.begin();
|
||||
i != modified_blocks.end(); ++i)
|
||||
{
|
||||
event.modified_blocks.erase(i->first);
|
||||
event.modified_blocks.insert(i->first);
|
||||
}
|
||||
}
|
||||
catch(InvalidPositionException &e){
|
||||
|
@ -1639,19 +1640,16 @@ void Map::transformLiquidsFinite(std::map<v3s16, MapBlock*> & modified_blocks)
|
|||
bool fast_flood = g_settings->getS16("liquid_fast_flood");
|
||||
int water_level = g_settings->getS16("water_level");
|
||||
|
||||
/*if(initial_size != 0)
|
||||
infostream<<"transformLiquids(): initial_size="<<initial_size<<std::endl;*/
|
||||
|
||||
// list of nodes that due to viscosity have not reached their max level height
|
||||
UniqueQueue<v3s16> must_reflow, must_reflow_second;
|
||||
|
||||
// List of MapBlocks that will require a lighting update (due to lava)
|
||||
std::map<v3s16, MapBlock*> lighting_modified_blocks;
|
||||
|
||||
while(m_transforming_liquid.size() > 0)
|
||||
while (m_transforming_liquid.size() > 0)
|
||||
{
|
||||
// This should be done here so that it is done when continue is used
|
||||
if(loopcount >= initial_size || loopcount >= 1000)
|
||||
if (loopcount >= initial_size || loopcount >= 1000)
|
||||
break;
|
||||
loopcount++;
|
||||
/*
|
||||
|
@ -1659,9 +1657,12 @@ void Map::transformLiquidsFinite(std::map<v3s16, MapBlock*> & modified_blocks)
|
|||
*/
|
||||
v3s16 p0 = m_transforming_liquid.pop_front();
|
||||
u16 total_level = 0;
|
||||
NodeNeighbor neighbors[7]; // surrounding flowing liquid nodes
|
||||
s8 liquid_levels[7] = {-1, -1, -1, -1, -1, -1, -1}; // current level of every block
|
||||
s8 liquid_levels_want[7] = {-1, -1, -1, -1, -1, -1, -1}; // target levels
|
||||
// surrounding flowing liquid nodes
|
||||
NodeNeighbor neighbors[7];
|
||||
// current level of every block
|
||||
s8 liquid_levels[7] = {-1, -1, -1, -1, -1, -1, -1};
|
||||
// target levels
|
||||
s8 liquid_levels_want[7] = {-1, -1, -1, -1, -1, -1, -1};
|
||||
s8 can_liquid_same_level = 0;
|
||||
content_t liquid_kind = CONTENT_IGNORE;
|
||||
content_t liquid_kind_flowing = CONTENT_IGNORE;
|
||||
|
@ -1696,9 +1697,11 @@ void Map::transformLiquidsFinite(std::map<v3s16, MapBlock*> & modified_blocks)
|
|||
}
|
||||
break;
|
||||
case LIQUID_SOURCE:
|
||||
// if this node is not (yet) of a liquid type, choose the first liquid type we encounter
|
||||
// if this node is not (yet) of a liquid type,
|
||||
// choose the first liquid type we encounter
|
||||
if (liquid_kind_flowing == CONTENT_IGNORE)
|
||||
liquid_kind_flowing = nodemgr->getId(nodemgr->get(nb.n).liquid_alternative_flowing);
|
||||
liquid_kind_flowing = nodemgr->getId(
|
||||
nodemgr->get(nb.n).liquid_alternative_flowing);
|
||||
if (liquid_kind == CONTENT_IGNORE)
|
||||
liquid_kind = nb.n.getContent();
|
||||
if (nb.n.getContent() == liquid_kind) {
|
||||
|
@ -1708,37 +1711,55 @@ void Map::transformLiquidsFinite(std::map<v3s16, MapBlock*> & modified_blocks)
|
|||
}
|
||||
break;
|
||||
case LIQUID_FLOWING:
|
||||
// if this node is not (yet) of a liquid type, choose the first liquid type we encounter
|
||||
// if this node is not (yet) of a liquid type,
|
||||
// choose the first liquid type we encounter
|
||||
if (liquid_kind_flowing == CONTENT_IGNORE)
|
||||
liquid_kind_flowing = nb.n.getContent();
|
||||
if (liquid_kind == CONTENT_IGNORE)
|
||||
liquid_kind = nodemgr->getId(nodemgr->get(nb.n).liquid_alternative_source);
|
||||
liquid_kind = nodemgr->getId(
|
||||
nodemgr->get(nb.n).liquid_alternative_source);
|
||||
if (nb.n.getContent() == liquid_kind_flowing) {
|
||||
liquid_levels[i] = (nb.n.param2 & LIQUID_LEVEL_MASK);
|
||||
nb.l = 1;
|
||||
}
|
||||
break;
|
||||
}
|
||||
if (nb.l && nb.t == NEIGHBOR_SAME_LEVEL) ++can_liquid_same_level;
|
||||
if (liquid_levels[i] > 0) total_level += liquid_levels[i];
|
||||
|
||||
if (nb.l && nb.t == NEIGHBOR_SAME_LEVEL)
|
||||
++can_liquid_same_level;
|
||||
if (liquid_levels[i] > 0)
|
||||
total_level += liquid_levels[i];
|
||||
|
||||
/*
|
||||
infostream << "get node i=" <<(int)i<<" " << PP(npos) << " c="<<nb.n.getContent() <<" p0="<< (int)nb.n.param0 <<" p1="<< (int)nb.n.param1 <<" p2="<< (int)nb.n.param2 << " lt="<<nodemgr->get(nb.n.getContent()).liquid_type
|
||||
infostream << "get node i=" <<(int)i<<" " << PP(npos) << " c="
|
||||
<< nb.n.getContent() <<" p0="<< (int)nb.n.param0 <<" p1="
|
||||
<< (int)nb.n.param1 <<" p2="<< (int)nb.n.param2 << " lt="
|
||||
<< nodemgr->get(nb.n.getContent()).liquid_type
|
||||
//<< " lk=" << liquid_kind << " lkf=" << liquid_kind_flowing
|
||||
<< " l="<< nb.l << " inf="<< nb.i << " nlevel=" << (int)liquid_levels[i] << " tlevel=" << (int)total_level << " cansame="<<(int)can_liquid_same_level<<std::endl;
|
||||
<< " l="<< nb.l << " inf="<< nb.i << " nlevel=" << (int)liquid_levels[i]
|
||||
<< " tlevel=" << (int)total_level << " cansame="
|
||||
<< (int)can_liquid_same_level << std::endl;
|
||||
*/
|
||||
}
|
||||
|
||||
if (liquid_kind == CONTENT_IGNORE || !neighbors[D_SELF].l || total_level <= 0)
|
||||
if (liquid_kind == CONTENT_IGNORE ||
|
||||
!neighbors[D_SELF].l ||
|
||||
total_level <= 0)
|
||||
continue;
|
||||
|
||||
// fill bottom block
|
||||
if (neighbors[D_BOTTOM].l) {
|
||||
liquid_levels_want[D_BOTTOM] = total_level > LIQUID_LEVEL_SOURCE ? LIQUID_LEVEL_SOURCE : total_level;
|
||||
liquid_levels_want[D_BOTTOM] = total_level > LIQUID_LEVEL_SOURCE ?
|
||||
LIQUID_LEVEL_SOURCE : total_level;
|
||||
total_level -= liquid_levels_want[D_BOTTOM];
|
||||
}
|
||||
|
||||
if (relax && p0.Y <= water_level && liquid_levels[D_TOP] == 0 && total_level >= LIQUID_LEVEL_SOURCE * can_liquid_same_level - can_liquid_same_level + 2 && can_liquid_same_level >= relax + 1) { //relax up
|
||||
//relax up
|
||||
if (relax && p0.Y <= water_level && liquid_levels[D_TOP] == 0 &&
|
||||
liquid_levels[D_BOTTOM] == LIQUID_LEVEL_SOURCE &&
|
||||
total_level >= LIQUID_LEVEL_SOURCE * can_liquid_same_level-
|
||||
(can_liquid_same_level - relax) &&
|
||||
can_liquid_same_level >= relax + 1) {
|
||||
total_level = LIQUID_LEVEL_SOURCE * can_liquid_same_level;
|
||||
}
|
||||
|
||||
|
@ -1749,7 +1770,11 @@ void Map::transformLiquidsFinite(std::map<v3s16, MapBlock*> & modified_blocks)
|
|||
: total_level / can_liquid_same_level;
|
||||
total_level -= want_level * can_liquid_same_level;
|
||||
|
||||
if (relax && p0.Y > water_level && liquid_levels[D_TOP] == 0 && liquid_levels[D_BOTTOM] == LIQUID_LEVEL_SOURCE && want_level == 0 && total_level <= can_liquid_same_level - 2 && can_liquid_same_level >= relax + 1) { //relax down
|
||||
//relax down
|
||||
if (relax && p0.Y == water_level + 1 && liquid_levels[D_TOP] == 0 &&
|
||||
liquid_levels[D_BOTTOM] == LIQUID_LEVEL_SOURCE && want_level == 0 &&
|
||||
total_level <= (can_liquid_same_level - relax) &&
|
||||
can_liquid_same_level >= relax + 1) {
|
||||
total_level = 0;
|
||||
}
|
||||
|
||||
|
@ -1767,7 +1792,8 @@ void Map::transformLiquidsFinite(std::map<v3s16, MapBlock*> & modified_blocks)
|
|||
|
||||
for (u16 ii = 0; ii < 7; ++ii) {
|
||||
if (total_level < 1) break;
|
||||
if (liquid_levels_want[ii] >= 0 && liquid_levels_want[ii] < LIQUID_LEVEL_SOURCE) {
|
||||
if (liquid_levels_want[ii] >= 0 &&
|
||||
liquid_levels_want[ii] < LIQUID_LEVEL_SOURCE) {
|
||||
++liquid_levels_want[ii];
|
||||
--total_level;
|
||||
}
|
||||
|
@ -1775,7 +1801,8 @@ void Map::transformLiquidsFinite(std::map<v3s16, MapBlock*> & modified_blocks)
|
|||
|
||||
// fill top block if can
|
||||
if (neighbors[D_TOP].l) {
|
||||
liquid_levels_want[D_TOP] = total_level > LIQUID_LEVEL_SOURCE ? LIQUID_LEVEL_SOURCE : total_level ;
|
||||
liquid_levels_want[D_TOP] = total_level > LIQUID_LEVEL_SOURCE ?
|
||||
LIQUID_LEVEL_SOURCE : total_level;
|
||||
total_level -= liquid_levels_want[D_TOP];
|
||||
}
|
||||
|
||||
|
@ -1790,7 +1817,15 @@ void Map::transformLiquidsFinite(std::map<v3s16, MapBlock*> & modified_blocks)
|
|||
&& liquid_levels[D_TOP] >= LIQUID_LEVEL_SOURCE))))
|
||||
liquid_levels_want[ii] = LIQUID_LEVEL_SOURCE;
|
||||
|
||||
//if (total_level > 0 /*|| flowed != volume*/) infostream <<" AFTER level=" << (int)total_level /*<< " flowed="<<flowed<< " volume=" <<volume*/<< " wantsame="<<(int)want_level<< " top="<< (int)liquid_levels_want[D_TOP]<< " topwas="<< (int)liquid_levels[D_TOP]<< " bot="<< (int)liquid_levels_want[D_BOTTOM]<<std::endl;
|
||||
/*
|
||||
if (total_level > 0) //|| flowed != volume)
|
||||
infostream <<" AFTER level=" << (int)total_level
|
||||
//<< " flowed="<<flowed<< " volume=" << volume
|
||||
<< " wantsame="<<(int)want_level<< " top="
|
||||
<< (int)liquid_levels_want[D_TOP]<< " topwas="
|
||||
<< (int)liquid_levels[D_TOP]<< " bot="
|
||||
<< (int)liquid_levels_want[D_BOTTOM]<<std::endl;
|
||||
*/
|
||||
|
||||
u8 changed = 0;
|
||||
for (u16 i = 0; i < 7; i++) {
|
||||
|
@ -1814,8 +1849,10 @@ void Map::transformLiquidsFinite(std::map<v3s16, MapBlock*> & modified_blocks)
|
|||
new_node_level = liquid_levels[i] - 1;
|
||||
else if (level_inc > 0)
|
||||
new_node_level = liquid_levels[i] + 1;
|
||||
} else
|
||||
} else {
|
||||
new_node_level = liquid_levels_want[i];
|
||||
}
|
||||
|
||||
if (new_node_level >= LIQUID_LEVEL_SOURCE)
|
||||
new_node_content = liquid_kind;
|
||||
else if (new_node_level > 0)
|
||||
|
@ -1824,25 +1861,30 @@ void Map::transformLiquidsFinite(std::map<v3s16, MapBlock*> & modified_blocks)
|
|||
new_node_content = CONTENT_AIR;
|
||||
|
||||
// last level must flow down on stairs
|
||||
if (liquid_levels_want[i] != liquid_levels[i] && liquid_levels[D_TOP] <= 0 && !neighbors[D_BOTTOM].l && new_node_level >= 1 && new_node_level <= 2) //maybe == 1 //
|
||||
if (liquid_levels_want[i] != liquid_levels[i] &&
|
||||
liquid_levels[D_TOP] <= 0 && !neighbors[D_BOTTOM].l &&
|
||||
new_node_level >= 1 && new_node_level <= 2) {
|
||||
for (u16 ii = D_SELF + 1; ii < D_TOP; ++ii) { // only same level
|
||||
if (!neighbors[ii].l)
|
||||
continue;
|
||||
must_reflow_second.push_back(p0 + dirs[ii]);
|
||||
if (neighbors[ii].l)
|
||||
must_reflow_second.push_back(p0 + dirs[ii]);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
check if anything has changed. if not, just continue with the next node.
|
||||
check if anything has changed.
|
||||
if not, just continue with the next node.
|
||||
*/
|
||||
if (
|
||||
new_node_content == n0.getContent()
|
||||
&& (nodemgr->get(n0.getContent()).liquid_type != LIQUID_FLOWING ||
|
||||
((n0.param2 & LIQUID_LEVEL_MASK) == (u8)new_node_level
|
||||
// &&((n0.param2 & LIQUID_FLOW_DOWN_MASK) == LIQUID_FLOW_DOWN_MASK)== flowing_down
|
||||
//&& ((n0.param2 & LIQUID_FLOW_DOWN_MASK) ==
|
||||
//LIQUID_FLOW_DOWN_MASK) == flowing_down
|
||||
))
|
||||
&&
|
||||
(nodemgr->get(n0.getContent()).liquid_type != LIQUID_SOURCE ||
|
||||
(((n0.param2 & LIQUID_INFINITY_MASK) == LIQUID_INFINITY_MASK) == neighbors[i].i
|
||||
(((n0.param2 & LIQUID_INFINITY_MASK) ==
|
||||
LIQUID_INFINITY_MASK) == neighbors[i].i
|
||||
))
|
||||
) {
|
||||
continue;
|
||||
|
@ -1859,7 +1901,12 @@ void Map::transformLiquidsFinite(std::map<v3s16, MapBlock*> & modified_blocks)
|
|||
//n0.param2 = ~(LIQUID_LEVEL_MASK | LIQUID_FLOW_DOWN_MASK);
|
||||
n0.param2 = (neighbors[i].i ? LIQUID_INFINITY_MASK : 0x00);
|
||||
}
|
||||
//infostream << "set node i=" <<(int)i<<" "<< PP(p0)<< " nc="<<new_node_content<< " p2="<<(int)n0.param2<< " nl="<<(int)new_node_level<<std::endl;
|
||||
/*
|
||||
infostream << "set node i=" <<(int)i<<" "<< PP(p0)<< " nc="
|
||||
<<new_node_content<< " p2="<<(int)n0.param2<< " nl="
|
||||
<<(int)new_node_level<<std::endl;
|
||||
*/
|
||||
|
||||
n0.setContent(new_node_content);
|
||||
// Find out whether there is a suspect for this action
|
||||
std::string suspect;
|
||||
|
@ -1869,7 +1916,8 @@ void Map::transformLiquidsFinite(std::map<v3s16, MapBlock*> & modified_blocks)
|
|||
|
||||
if(!suspect.empty()){
|
||||
// Blame suspect
|
||||
RollbackScopeActor rollback_scope(m_gamedef->rollback(), suspect, true);
|
||||
RollbackScopeActor rollback_scope(m_gamedef->rollback(),
|
||||
suspect, true);
|
||||
// Get old node for rollback
|
||||
RollbackNode rollback_oldnode(this, p0, m_gamedef);
|
||||
// Set node
|
||||
|
@ -1894,13 +1942,18 @@ void Map::transformLiquidsFinite(std::map<v3s16, MapBlock*> & modified_blocks)
|
|||
}
|
||||
must_reflow.push_back(neighbors[i].p);
|
||||
}
|
||||
/* //for better relax
|
||||
if (changed) for (u16 ii = D_SELF + 1; ii < D_TOP; ++ii) { // only same level
|
||||
/* //for better relax only same level
|
||||
if (changed) for (u16 ii = D_SELF + 1; ii < D_TOP; ++ii) {
|
||||
if (!neighbors[ii].l) continue;
|
||||
must_reflow.push_back(p0 + dirs[ii]);
|
||||
}*/
|
||||
}
|
||||
//if (loopcount) infostream<<"Map::transformLiquids(): loopcount="<<loopcount<<" reflow="<<must_reflow.size()<<" queue="<< m_transforming_liquid.size()<<std::endl;
|
||||
/*
|
||||
if (loopcount)
|
||||
infostream<<"Map::transformLiquids(): loopcount="<<loopcount
|
||||
<<" reflow="<<must_reflow.size()
|
||||
<<" queue="<< m_transforming_liquid.size()<<std::endl;
|
||||
*/
|
||||
while (must_reflow.size() > 0)
|
||||
m_transforming_liquid.push_back(must_reflow.pop_front());
|
||||
while (must_reflow_second.size() > 0)
|
||||
|
@ -1911,7 +1964,8 @@ void Map::transformLiquidsFinite(std::map<v3s16, MapBlock*> & modified_blocks)
|
|||
void Map::transformLiquids(std::map<v3s16, MapBlock*> & modified_blocks)
|
||||
{
|
||||
|
||||
if (g_settings->getBool("liquid_finite")) return Map::transformLiquidsFinite(modified_blocks);
|
||||
if (g_settings->getBool("liquid_finite"))
|
||||
return Map::transformLiquidsFinite(modified_blocks);
|
||||
|
||||
INodeDefManager *nodemgr = m_gamedef->ndef();
|
||||
|
||||
|
@ -3004,7 +3058,7 @@ MapBlock * ServerMap::emergeBlock(v3s16 p, bool create_blank)
|
|||
i = modified_blocks.begin();
|
||||
i != modified_blocks.end(); ++i)
|
||||
{
|
||||
event.modified_blocks.erase(i->first);
|
||||
event.modified_blocks.insert(i->first);
|
||||
}
|
||||
|
||||
// Queue event
|
||||
|
|
130
src/mapgen.cpp
130
src/mapgen.cpp
|
@ -39,7 +39,7 @@ FlagDesc flagdesc_mapgen[] = {
|
|||
{"trees", MG_TREES},
|
||||
{"caves", MG_CAVES},
|
||||
{"dungeons", MG_DUNGEONS},
|
||||
{"v6_forests", MGV6_FORESTS},
|
||||
{"v6_jungles", MGV6_JUNGLES},
|
||||
{"v6_biome_blend", MGV6_BIOME_BLEND},
|
||||
{"flat", MG_FLAT},
|
||||
{NULL, 0}
|
||||
|
@ -51,21 +51,19 @@ FlagDesc flagdesc_mapgen[] = {
|
|||
|
||||
void Mapgen::updateLiquid(UniqueQueue<v3s16> *trans_liquid, v3s16 nmin, v3s16 nmax) {
|
||||
bool isliquid, wasliquid;
|
||||
u32 i;
|
||||
v3s16 em = vm->m_area.getExtent();
|
||||
|
||||
for (s16 z = nmin.Z; z <= nmax.Z; z++) {
|
||||
for (s16 x = nmin.X; x <= nmax.X; x++) {
|
||||
v2s16 p2d(x, z);
|
||||
wasliquid = true;
|
||||
v3s16 em = vm->m_area.getExtent();
|
||||
i = vm->m_area.index(v3s16(p2d.X, nmax.Y, p2d.Y));
|
||||
|
||||
|
||||
u32 i = vm->m_area.index(x, nmax.Y, z);
|
||||
for (s16 y = nmax.Y; y >= nmin.Y; y--) {
|
||||
isliquid = ndef->get(vm->m_data[i]).isLiquid();
|
||||
|
||||
// there was a change between liquid and nonliquid, add to queue
|
||||
if (isliquid != wasliquid)
|
||||
trans_liquid->push_back(v3s16(p2d.X, y, p2d.Y));
|
||||
trans_liquid->push_back(v3s16(x, y, z));
|
||||
|
||||
wasliquid = isliquid;
|
||||
vm->m_area.add_y(em, i, -1);
|
||||
|
@ -75,7 +73,108 @@ void Mapgen::updateLiquid(UniqueQueue<v3s16> *trans_liquid, v3s16 nmin, v3s16 nm
|
|||
}
|
||||
|
||||
|
||||
void Mapgen::setLighting(v3s16 nmin, v3s16 nmax, u8 light) {
|
||||
ScopeProfiler sp(g_profiler, "EmergeThread: mapgen lighting update", SPT_AVG);
|
||||
VoxelArea a(nmin - v3s16(1,0,1) * MAP_BLOCKSIZE,
|
||||
nmax + v3s16(1,0,1) * MAP_BLOCKSIZE);
|
||||
|
||||
for (int z = a.MinEdge.Z; z <= a.MaxEdge.Z; z++) {
|
||||
for (int y = a.MinEdge.Y; y <= a.MaxEdge.Y; y++) {
|
||||
u32 i = vm->m_area.index(a.MinEdge.X, y, z);
|
||||
for (int x = a.MinEdge.X; x <= a.MaxEdge.X; x++, i++)
|
||||
vm->m_data[i].param1 = light;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void Mapgen::lightSpread(VoxelArea &a, v3s16 p, u8 light) {
|
||||
if (light <= 1 || !a.contains(p))
|
||||
return;
|
||||
|
||||
u32 vi = vm->m_area.index(p);
|
||||
MapNode &nn = vm->m_data[vi];
|
||||
|
||||
light--;
|
||||
// should probably compare masked, but doesn't seem to make a difference
|
||||
if (light <= nn.param1 || !ndef->get(nn).light_propagates)
|
||||
return;
|
||||
|
||||
nn.param1 = light;
|
||||
|
||||
lightSpread(a, p + v3s16(0, 0, 1), light);
|
||||
lightSpread(a, p + v3s16(0, 1, 0), light);
|
||||
lightSpread(a, p + v3s16(1, 0, 0), light);
|
||||
lightSpread(a, p - v3s16(0, 0, 1), light);
|
||||
lightSpread(a, p - v3s16(0, 1, 0), light);
|
||||
lightSpread(a, p - v3s16(1, 0, 0), light);
|
||||
}
|
||||
|
||||
|
||||
void Mapgen::updateLighting(v3s16 nmin, v3s16 nmax) {
|
||||
VoxelArea a(nmin - v3s16(1,0,1) * MAP_BLOCKSIZE,
|
||||
nmax + v3s16(1,0,1) * MAP_BLOCKSIZE);
|
||||
bool block_is_underground = (water_level >= nmax.Y);
|
||||
|
||||
ScopeProfiler sp(g_profiler, "EmergeThread: mapgen lighting update", SPT_AVG);
|
||||
//TimeTaker t("updateLighting");
|
||||
|
||||
// first, send vertical rays of sunshine downward
|
||||
v3s16 em = vm->m_area.getExtent();
|
||||
for (int z = a.MinEdge.Z; z <= a.MaxEdge.Z; z++) {
|
||||
for (int x = a.MinEdge.X; x <= a.MaxEdge.X; x++) {
|
||||
// see if we can get a light value from the overtop
|
||||
u32 i = vm->m_area.index(x, a.MaxEdge.Y + 1, z);
|
||||
if (vm->m_data[i].getContent() == CONTENT_IGNORE) {
|
||||
if (block_is_underground)
|
||||
continue;
|
||||
} else if ((vm->m_data[i].param1 & 0x0F) != LIGHT_SUN) {
|
||||
continue;
|
||||
}
|
||||
vm->m_area.add_y(em, i, -1);
|
||||
|
||||
for (int y = a.MaxEdge.Y; y >= a.MinEdge.Y; y--) {
|
||||
MapNode &n = vm->m_data[i];
|
||||
if (!ndef->get(n).sunlight_propagates)
|
||||
break;
|
||||
n.param1 = LIGHT_SUN;
|
||||
vm->m_area.add_y(em, i, -1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// now spread the sunlight and light up any sources
|
||||
for (int z = a.MinEdge.Z; z <= a.MaxEdge.Z; z++) {
|
||||
for (int y = a.MinEdge.Y; y <= a.MaxEdge.Y; y++) {
|
||||
u32 i = vm->m_area.index(a.MinEdge.X, y, z);
|
||||
for (int x = a.MinEdge.X; x <= a.MaxEdge.X; x++, i++) {
|
||||
MapNode &n = vm->m_data[i];
|
||||
if (n.getContent() == CONTENT_IGNORE ||
|
||||
!ndef->get(n).light_propagates)
|
||||
continue;
|
||||
|
||||
u8 light_produced = ndef->get(n).light_source & 0x0F;
|
||||
if (light_produced)
|
||||
n.param1 = light_produced;
|
||||
|
||||
u8 light = n.param1 & 0x0F;
|
||||
if (light) {
|
||||
lightSpread(a, v3s16(x, y, z + 1), light);
|
||||
lightSpread(a, v3s16(x, y + 1, z ), light);
|
||||
lightSpread(a, v3s16(x + 1, y, z ), light);
|
||||
lightSpread(a, v3s16(x, y, z - 1), light);
|
||||
lightSpread(a, v3s16(x, y - 1, z ), light);
|
||||
lightSpread(a, v3s16(x - 1, y, z ), light);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//printf("updateLighting: %dms\n", t.stop());
|
||||
}
|
||||
|
||||
|
||||
void Mapgen::updateLightingOld(v3s16 nmin, v3s16 nmax) {
|
||||
enum LightBank banks[2] = {LIGHTBANK_DAY, LIGHTBANK_NIGHT};
|
||||
|
||||
VoxelArea a(nmin - v3s16(1,0,1) * MAP_BLOCKSIZE,
|
||||
|
@ -84,14 +183,16 @@ void Mapgen::updateLighting(v3s16 nmin, v3s16 nmax) {
|
|||
bool sunlight = !block_is_underground;
|
||||
|
||||
ScopeProfiler sp(g_profiler, "EmergeThread: mapgen lighting update", SPT_AVG);
|
||||
|
||||
for (int i = 0; i < 2; i++) {
|
||||
enum LightBank bank = banks[i];
|
||||
std::set<v3s16> light_sources;
|
||||
std::map<v3s16, u8> unlight_from;
|
||||
std::set<v3s16> light_sources;
|
||||
std::map<v3s16, u8> unlight_from;
|
||||
|
||||
voxalgo::clearLightAndCollectSources(*vm, a, bank, ndef,
|
||||
light_sources, unlight_from);
|
||||
voxalgo::propagateSunlight(*vm, a, sunlight, light_sources, ndef);
|
||||
|
||||
vm->unspreadLight(bank, unlight_from, light_sources, ndef);
|
||||
vm->spreadLight(bank, light_sources, ndef);
|
||||
}
|
||||
|
@ -108,16 +209,19 @@ bool MapgenV6Params::readParams(Settings *settings) {
|
|||
np_terrain_higher = settings->getNoiseParams("mgv6_np_terrain_higher");
|
||||
np_steepness = settings->getNoiseParams("mgv6_np_steepness");
|
||||
np_height_select = settings->getNoiseParams("mgv6_np_height_select");
|
||||
np_trees = settings->getNoiseParams("mgv6_np_trees");
|
||||
np_mud = settings->getNoiseParams("mgv6_np_mud");
|
||||
np_beach = settings->getNoiseParams("mgv6_np_beach");
|
||||
np_biome = settings->getNoiseParams("mgv6_np_biome");
|
||||
np_cave = settings->getNoiseParams("mgv6_np_cave");
|
||||
np_humidity = settings->getNoiseParams("mgv6_np_humidity");
|
||||
np_trees = settings->getNoiseParams("mgv6_np_trees");
|
||||
np_apple_trees = settings->getNoiseParams("mgv6_np_apple_trees");
|
||||
|
||||
bool success =
|
||||
np_terrain_base && np_terrain_higher && np_steepness &&
|
||||
np_height_select && np_trees && np_mud &&
|
||||
np_beach && np_biome && np_cave;
|
||||
np_beach && np_biome && np_cave &&
|
||||
np_humidity && np_apple_trees;
|
||||
return success;
|
||||
}
|
||||
|
||||
|
@ -130,11 +234,13 @@ void MapgenV6Params::writeParams(Settings *settings) {
|
|||
settings->setNoiseParams("mgv6_np_terrain_higher", np_terrain_higher);
|
||||
settings->setNoiseParams("mgv6_np_steepness", np_steepness);
|
||||
settings->setNoiseParams("mgv6_np_height_select", np_height_select);
|
||||
settings->setNoiseParams("mgv6_np_trees", np_trees);
|
||||
settings->setNoiseParams("mgv6_np_mud", np_mud);
|
||||
settings->setNoiseParams("mgv6_np_beach", np_beach);
|
||||
settings->setNoiseParams("mgv6_np_biome", np_biome);
|
||||
settings->setNoiseParams("mgv6_np_cave", np_cave);
|
||||
settings->setNoiseParams("mgv6_np_humidity", np_humidity);
|
||||
settings->setNoiseParams("mgv6_np_trees", np_trees);
|
||||
settings->setNoiseParams("mgv6_np_apple_trees", np_apple_trees);
|
||||
}
|
||||
|
||||
|
||||
|
|
|
@ -32,7 +32,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
|
|||
#define MG_TREES 0x01
|
||||
#define MG_CAVES 0x02
|
||||
#define MG_DUNGEONS 0x04
|
||||
#define MGV6_FORESTS 0x08
|
||||
#define MGV6_JUNGLES 0x08
|
||||
#define MGV6_BIOME_BLEND 0x10
|
||||
#define MG_FLAT 0x20
|
||||
|
||||
|
@ -46,6 +46,7 @@ class ManualMapVoxelManipulator;
|
|||
class VoxelManipulator;
|
||||
class INodeDefManager;
|
||||
class BlockMakeData;
|
||||
class VoxelArea;
|
||||
|
||||
struct MapgenParams {
|
||||
std::string mg_name;
|
||||
|
@ -76,7 +77,10 @@ public:
|
|||
INodeDefManager *ndef;
|
||||
|
||||
void updateLiquid(UniqueQueue<v3s16> *trans_liquid, v3s16 nmin, v3s16 nmax);
|
||||
void setLighting(v3s16 nmin, v3s16 nmax, u8 light);
|
||||
void lightSpread(VoxelArea &a, v3s16 p, u8 light);
|
||||
void updateLighting(v3s16 nmin, v3s16 nmax);
|
||||
void updateLightingOld(v3s16 nmin, v3s16 nmax);
|
||||
|
||||
virtual void makeChunk(BlockMakeData *data) {};
|
||||
virtual int getGroundLevelAtPoint(v2s16 p) = 0;
|
||||
|
|
|
@ -0,0 +1,249 @@
|
|||
/*
|
||||
Minetest
|
||||
Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser General Public License as published by
|
||||
the Free Software Foundation; either version 2.1 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License along
|
||||
with this program; if not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
*/
|
||||
|
||||
#include "mapgen_indev.h"
|
||||
#include "constants.h"
|
||||
#include "log.h"
|
||||
|
||||
/////////////////// Mapgen Indev perlin noise default values
|
||||
|
||||
NoiseIndevParams nparams_indev_def_terrain_base
|
||||
(-AVERAGE_MUD_AMOUNT, 20.0, v3f(250.0, 250.0, 250.0), 82341, 5, 0.6, 1);
|
||||
NoiseIndevParams nparams_indev_def_terrain_higher
|
||||
(20.0, 16.0, v3f(500.0, 500.0, 500.0), 85039, 5, 0.6, 1);
|
||||
NoiseIndevParams nparams_indev_def_steepness
|
||||
(0.85, 0.5, v3f(125.0, 125.0, 125.0), -932, 5, 0.7, 1);
|
||||
NoiseIndevParams nparams_indev_def_mud
|
||||
(AVERAGE_MUD_AMOUNT, 2.0, v3f(200.0, 200.0, 200.0), 91013, 3, 0.55, 1);
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
void NoiseIndev::init(NoiseIndevParams *np, int seed, int sx, int sy, int sz) {
|
||||
Noise::init((NoiseParams*)np, seed, sx, sy, sz);
|
||||
this->npindev = np;
|
||||
}
|
||||
|
||||
|
||||
NoiseIndev::NoiseIndev(NoiseIndevParams *np, int seed, int sx, int sy) : Noise(np, seed, sx, sy) {
|
||||
init(np, seed, sx, sy, 1);
|
||||
}
|
||||
|
||||
|
||||
NoiseIndev::NoiseIndev(NoiseIndevParams *np, int seed, int sx, int sy, int sz) : Noise(np, seed, sx, sy, sz) {
|
||||
init(np, seed, sx, sy, sz);
|
||||
}
|
||||
|
||||
|
||||
float farscale(float scale, float x, float y, float z) {
|
||||
return ( 1 + ( 1 - (MAP_GENERATION_LIMIT * 3 - (fabs(x) + fabs(y) + fabs(z)) ) / (MAP_GENERATION_LIMIT * 3) ) * (scale - 1) );
|
||||
}
|
||||
|
||||
void NoiseIndev::transformNoiseMapFarScale(float xx, float yy, float zz) {
|
||||
// more correct use distantion from 0,0,0 via pow, but + is faster
|
||||
//float farscale = ( 1 + ( 1 - (MAP_GENERATION_LIMIT * 3 - (fabs(xx) + fabs(yy) + fabs(zz)) ) / (MAP_GENERATION_LIMIT * 3) ) * ((npindev)->farscale - 1) );
|
||||
// dstream << "TNM rs=" << farscale << " from=" << (npindev)->farscale << " x=" << xx << " y=" << yy <<" z=" << zz << std::endl;
|
||||
int i = 0;
|
||||
for (int z = 0; z != sz; z++) {
|
||||
for (int y = 0; y != sy; y++) {
|
||||
for (int x = 0; x != sx; x++) {
|
||||
//result[i] = result[i] * npindev->scale * farscale + npindev->offset;
|
||||
result[i] = result[i] * npindev->scale * farscale(npindev->farscale,xx,yy,zz) + npindev->offset;
|
||||
i++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
MapgenIndev::MapgenIndev(int mapgenid, MapgenIndevParams *params) : MapgenV6(mapgenid, params) {
|
||||
noiseindev_terrain_base = new NoiseIndev(params->npindev_terrain_base, seed, csize.X, csize.Y);
|
||||
noiseindev_terrain_higher = new NoiseIndev(params->npindev_terrain_higher, seed, csize.X, csize.Y);
|
||||
noiseindev_steepness = new NoiseIndev(params->npindev_steepness, seed, csize.X, csize.Y);
|
||||
// noise_height_select = new Noise(params->np_height_select, seed, csize.X, csize.Y);
|
||||
// noise_trees = new Noise(params->np_trees, seed, csize.X, csize.Y);
|
||||
noiseindev_mud = new NoiseIndev(params->npindev_mud, seed, csize.X, csize.Y);
|
||||
// noise_beach = new Noise(params->np_beach, seed, csize.X, csize.Y);
|
||||
// noise_biome = new Noise(params->np_biome, seed, csize.X, csize.Y);
|
||||
}
|
||||
|
||||
MapgenIndev::~MapgenIndev() {
|
||||
delete noiseindev_terrain_base;
|
||||
delete noiseindev_terrain_higher;
|
||||
delete noiseindev_steepness;
|
||||
//delete noise_height_select;
|
||||
//delete noise_trees;
|
||||
delete noiseindev_mud;
|
||||
//delete noise_beach;
|
||||
//delete noise_biome;
|
||||
}
|
||||
|
||||
|
||||
void MapgenIndev::calculateNoise() {
|
||||
int x = node_min.X;
|
||||
int y = node_min.Y;
|
||||
int z = node_min.Z;
|
||||
// Need to adjust for the original implementation's +.5 offset...
|
||||
if (!(flags & MG_FLAT)) {
|
||||
noiseindev_terrain_base->perlinMap2D(
|
||||
x + 0.5 * noiseindev_terrain_base->npindev->spread.X,
|
||||
z + 0.5 * noiseindev_terrain_base->npindev->spread.Z);
|
||||
noiseindev_terrain_base->transformNoiseMapFarScale(x, y, z);
|
||||
//noise_terrain_base->transformNoiseMap();
|
||||
|
||||
noiseindev_terrain_higher->perlinMap2D(
|
||||
x + 0.5 * noiseindev_terrain_higher->npindev->spread.X,
|
||||
z + 0.5 * noiseindev_terrain_higher->npindev->spread.Z);
|
||||
noiseindev_terrain_higher->transformNoiseMapFarScale(x, y, z);
|
||||
//noise_terrain_higher->transformNoiseMap();
|
||||
|
||||
noiseindev_steepness->perlinMap2D(
|
||||
x + 0.5 * noiseindev_steepness->npindev->spread.X,
|
||||
z + 0.5 * noiseindev_steepness->npindev->spread.Z);
|
||||
noiseindev_steepness->transformNoiseMapFarScale(x, y, z);
|
||||
|
||||
noise_height_select->perlinMap2D(
|
||||
x + 0.5 * noise_height_select->np->spread.X,
|
||||
z + 0.5 * noise_height_select->np->spread.Z);
|
||||
}
|
||||
|
||||
if (!(flags & MG_FLAT)) {
|
||||
noiseindev_mud->perlinMap2D(
|
||||
x + 0.5 * noiseindev_mud->npindev->spread.X,
|
||||
z + 0.5 * noiseindev_mud->npindev->spread.Z);
|
||||
noiseindev_mud->transformNoiseMapFarScale(x, y, z);
|
||||
}
|
||||
noise_beach->perlinMap2D(
|
||||
x + 0.2 * noise_beach->np->spread.X,
|
||||
z + 0.7 * noise_beach->np->spread.Z);
|
||||
|
||||
noise_biome->perlinMap2D(
|
||||
x + 0.6 * noise_biome->np->spread.X,
|
||||
z + 0.2 * noise_biome->np->spread.Z);
|
||||
}
|
||||
|
||||
bool MapgenIndevParams::readParams(Settings *settings) {
|
||||
freq_desert = settings->getFloat("mgv6_freq_desert");
|
||||
freq_beach = settings->getFloat("mgv6_freq_beach");
|
||||
|
||||
npindev_terrain_base = settings->getNoiseIndevParams("mgindev_np_terrain_base");
|
||||
npindev_terrain_higher = settings->getNoiseIndevParams("mgindev_np_terrain_higher");
|
||||
npindev_steepness = settings->getNoiseIndevParams("mgindev_np_steepness");
|
||||
np_height_select = settings->getNoiseParams("mgv6_np_height_select");
|
||||
np_trees = settings->getNoiseParams("mgv6_np_trees");
|
||||
npindev_mud = settings->getNoiseIndevParams("mgindev_np_mud");
|
||||
np_beach = settings->getNoiseParams("mgv6_np_beach");
|
||||
np_biome = settings->getNoiseParams("mgv6_np_biome");
|
||||
np_cave = settings->getNoiseParams("mgv6_np_cave");
|
||||
|
||||
bool success =
|
||||
npindev_terrain_base && npindev_terrain_higher && npindev_steepness &&
|
||||
np_height_select && np_trees && npindev_mud &&
|
||||
np_beach && np_biome && np_cave;
|
||||
return success;
|
||||
}
|
||||
|
||||
|
||||
void MapgenIndevParams::writeParams(Settings *settings) {
|
||||
settings->setFloat("mgv6_freq_desert", freq_desert);
|
||||
settings->setFloat("mgv6_freq_beach", freq_beach);
|
||||
|
||||
settings->setNoiseIndevParams("mgindev_np_terrain_base", npindev_terrain_base);
|
||||
settings->setNoiseIndevParams("mgindev_np_terrain_higher", npindev_terrain_higher);
|
||||
settings->setNoiseIndevParams("mgindev_np_steepness", npindev_steepness);
|
||||
settings->setNoiseParams("mgv6_np_height_select", np_height_select);
|
||||
settings->setNoiseParams("mgv6_np_trees", np_trees);
|
||||
settings->setNoiseIndevParams("mgindev_np_mud", npindev_mud);
|
||||
settings->setNoiseParams("mgv6_np_beach", np_beach);
|
||||
settings->setNoiseParams("mgv6_np_biome", np_biome);
|
||||
settings->setNoiseParams("mgv6_np_cave", np_cave);
|
||||
}
|
||||
|
||||
|
||||
float MapgenIndev::baseTerrainLevelFromNoise(v2s16 p) {
|
||||
if (flags & MG_FLAT)
|
||||
return water_level;
|
||||
|
||||
float terrain_base = NoisePerlin2DPosOffset(noiseindev_terrain_base->npindev,
|
||||
p.X, 0.5, p.Y, 0.5, seed);
|
||||
float terrain_higher = NoisePerlin2DPosOffset(noiseindev_terrain_higher->npindev,
|
||||
p.X, 0.5, p.Y, 0.5, seed);
|
||||
float steepness = NoisePerlin2DPosOffset(noiseindev_steepness->npindev,
|
||||
p.X, 0.5, p.Y, 0.5, seed);
|
||||
float height_select = NoisePerlin2DNoTxfmPosOffset(noise_height_select->np,
|
||||
p.X, 0.5, p.Y, 0.5, seed);
|
||||
|
||||
return baseTerrainLevel(terrain_base, terrain_higher,
|
||||
steepness, height_select);
|
||||
}
|
||||
|
||||
|
||||
float MapgenIndev::baseTerrainLevelFromMap(int index) {
|
||||
if (flags & MG_FLAT)
|
||||
return water_level;
|
||||
|
||||
float terrain_base = noiseindev_terrain_base->result[index];
|
||||
float terrain_higher = noiseindev_terrain_higher->result[index];
|
||||
float steepness = noiseindev_steepness->result[index];
|
||||
float height_select = noise_height_select->result[index];
|
||||
|
||||
return baseTerrainLevel(terrain_base, terrain_higher,
|
||||
steepness, height_select);
|
||||
}
|
||||
|
||||
|
||||
float MapgenIndev::getMudAmount(int index)
|
||||
{
|
||||
if (flags & MG_FLAT)
|
||||
return AVERAGE_MUD_AMOUNT;
|
||||
|
||||
/*return ((float)AVERAGE_MUD_AMOUNT + 2.0 * noise2d_perlin(
|
||||
0.5+(float)p.X/200, 0.5+(float)p.Y/200,
|
||||
seed+91013, 3, 0.55));*/
|
||||
|
||||
return noiseindev_mud->result[index];
|
||||
}
|
||||
|
||||
|
||||
void MapgenIndev::defineCave(Cave & cave, PseudoRandom ps, v3s16 node_min, bool large_cave) {
|
||||
cave.min_tunnel_diameter = 2;
|
||||
cave.max_tunnel_diameter = ps.range(2,6);
|
||||
cave.dswitchint = ps.range(1,14);
|
||||
//cave.tunnel_routepoints = 0;
|
||||
//cave.part_max_length_rs = 0;
|
||||
cave.flooded = large_cave && ps.range(0,4);
|
||||
if(large_cave){
|
||||
cave.part_max_length_rs = ps.range(2,4);
|
||||
//dstream<<"try:"<<farscale(0.2, node_min.X,node_min.Y,node_min.Z)*30<<std::endl;
|
||||
if (node_min.Y < -500 && !ps.range(0, farscale(0.2, node_min.X,node_min.Y,node_min.Z)*30)) { //huge
|
||||
cave.flooded = ps.range(0, 1);
|
||||
//dstream<<"HUGE:"<<cave.flooded<<std::endl;
|
||||
cave.tunnel_routepoints = ps.range(5, 1522);
|
||||
cave.min_tunnel_diameter = 30;
|
||||
cave.max_tunnel_diameter = ps.range(30, ps.range(80,120));
|
||||
} else {
|
||||
//dstream<<"large:"<<cave.flooded<<std::endl;
|
||||
cave.tunnel_routepoints = ps.range(5, ps.range(15,30));
|
||||
cave.min_tunnel_diameter = 5;
|
||||
cave.max_tunnel_diameter = ps.range(7, ps.range(8,24));
|
||||
}
|
||||
} else {
|
||||
cave.part_max_length_rs = ps.range(2,9);
|
||||
cave.tunnel_routepoints = ps.range(10, ps.range(15,30));
|
||||
}
|
||||
cave.large_cave_is_flat = (ps.range(0,1) == 0);
|
||||
}
|
|
@ -0,0 +1,135 @@
|
|||
/*
|
||||
Minetest
|
||||
Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser General Public License as published by
|
||||
the Free Software Foundation; either version 2.1 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License along
|
||||
with this program; if not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
*/
|
||||
|
||||
#ifndef MAPGENINDEV_HEADER
|
||||
#define MAPGENINDEV_HEADER
|
||||
|
||||
#include "mapgen.h"
|
||||
#include "mapgen_v6.h"
|
||||
|
||||
float farscale(float scale, float x, float y, float z);
|
||||
|
||||
struct NoiseIndevParams : public NoiseParams {
|
||||
float farscale;
|
||||
|
||||
NoiseIndevParams(){}
|
||||
NoiseIndevParams(float offset_, float scale_, v3f spread_, int seed_, int octaves_, float persist_, float farscale_)
|
||||
//:NoiseParams(offset_, scale_, spread_, seed_, octaves_, persist_)
|
||||
{
|
||||
//NoiseParams(float offset_, float scale_, v3f spread_, int seed_, int octaves_, float persist_) {
|
||||
offset = offset_;
|
||||
scale = scale_;
|
||||
spread = spread_;
|
||||
seed = seed_;
|
||||
octaves = octaves_;
|
||||
persist = persist_;
|
||||
//}
|
||||
farscale = farscale_;
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
#define getNoiseIndevParams(x) getStruct<NoiseIndevParams>((x), "f,f,v3,s32,s32,f,f")
|
||||
#define setNoiseIndevParams(x, y) setStruct((x), "f,f,v3,s32,s32,f,f", (y))
|
||||
|
||||
class NoiseIndev : public Noise {
|
||||
public:
|
||||
NoiseIndevParams *npindev;
|
||||
|
||||
//NoiseIndev() {};
|
||||
NoiseIndev(NoiseIndevParams *np, int seed, int sx, int sy);
|
||||
NoiseIndev(NoiseIndevParams *np, int seed, int sx, int sy, int sz);
|
||||
void init(NoiseIndevParams *np, int seed, int sx, int sy, int sz);
|
||||
void transformNoiseMapFarScale(float xx = 0, float yy = 0, float zz = 0);
|
||||
};
|
||||
|
||||
extern NoiseIndevParams nparams_indev_def_terrain_base;
|
||||
extern NoiseIndevParams nparams_indev_def_terrain_higher;
|
||||
extern NoiseIndevParams nparams_indev_def_steepness;
|
||||
//extern NoiseIndevParams nparams_indev_def_height_select;
|
||||
//extern NoiseIndevParams nparams_indev_def_trees;
|
||||
extern NoiseIndevParams nparams_indev_def_mud;
|
||||
//extern NoiseIndevParams nparams_indev_def_beach;
|
||||
//extern NoiseIndevParams nparams_indev_def_biome;
|
||||
//extern NoiseIndevParams nparams_indev_def_cave;
|
||||
|
||||
|
||||
struct MapgenIndevParams : public MapgenV6Params {
|
||||
NoiseIndevParams *npindev_terrain_base;
|
||||
NoiseIndevParams *npindev_terrain_higher;
|
||||
NoiseIndevParams *npindev_steepness;
|
||||
//NoiseParams *np_height_select;
|
||||
//NoiseParams *np_trees;
|
||||
NoiseIndevParams *npindev_mud;
|
||||
//NoiseParams *np_beach;
|
||||
//NoiseParams *np_biome;
|
||||
//NoiseParams *np_cave;
|
||||
|
||||
MapgenIndevParams() {
|
||||
//freq_desert = 0.45;
|
||||
//freq_beach = 0.15;
|
||||
npindev_terrain_base = &nparams_indev_def_terrain_base;
|
||||
npindev_terrain_higher = &nparams_indev_def_terrain_higher;
|
||||
npindev_steepness = &nparams_indev_def_steepness;
|
||||
//np_height_select = &nparams_v6_def_height_select;
|
||||
//np_trees = &nparams_v6_def_trees;
|
||||
npindev_mud = &nparams_indev_def_mud;
|
||||
//np_beach = &nparams_v6_def_beach;
|
||||
//np_biome = &nparams_v6_def_biome;
|
||||
//np_cave = &nparams_v6_def_cave;
|
||||
}
|
||||
|
||||
bool readParams(Settings *settings);
|
||||
void writeParams(Settings *settings);
|
||||
};
|
||||
|
||||
class MapgenIndev : public MapgenV6 {
|
||||
public:
|
||||
NoiseIndev *noiseindev_terrain_base;
|
||||
NoiseIndev *noiseindev_terrain_higher;
|
||||
NoiseIndev *noiseindev_steepness;
|
||||
//NoiseIndev *noise_height_select;
|
||||
//NoiseIndev *noise_trees;
|
||||
NoiseIndev *noiseindev_mud;
|
||||
//NoiseIndev *noise_beach;
|
||||
//NoiseIndev *noise_biome;
|
||||
//NoiseIndevParams *np_cave;
|
||||
|
||||
MapgenIndev(int mapgenid, MapgenIndevParams *params);
|
||||
~MapgenIndev();
|
||||
void calculateNoise();
|
||||
|
||||
float baseTerrainLevelFromNoise(v2s16 p);
|
||||
float baseTerrainLevelFromMap(int index);
|
||||
float getMudAmount(int index);
|
||||
void defineCave(Cave & cave, PseudoRandom ps, v3s16 node_min, bool large_cave);
|
||||
};
|
||||
|
||||
struct MapgenFactoryIndev : public MapgenFactoryV6 {
|
||||
Mapgen *createMapgen(int mgid, MapgenParams *params, EmergeManager *emerge) {
|
||||
return new MapgenIndev(mgid, (MapgenIndevParams *)params);
|
||||
};
|
||||
|
||||
MapgenParams *createMapgenParams() {
|
||||
return new MapgenIndevParams();
|
||||
};
|
||||
};
|
||||
|
||||
|
||||
#endif
|
|
@ -45,8 +45,6 @@ NoiseParams nparams_v6_def_steepness =
|
|||
{0.85, 0.5, v3f(125.0, 125.0, 125.0), -932, 5, 0.7};
|
||||
NoiseParams nparams_v6_def_height_select =
|
||||
{0.5, 1.0, v3f(250.0, 250.0, 250.0), 4213, 5, 0.69};
|
||||
NoiseParams nparams_v6_def_trees =
|
||||
{0.0, 1.0, v3f(125.0, 125.0, 125.0), 2, 4, 0.66};
|
||||
NoiseParams nparams_v6_def_mud =
|
||||
{AVERAGE_MUD_AMOUNT, 2.0, v3f(200.0, 200.0, 200.0), 91013, 3, 0.55};
|
||||
NoiseParams nparams_v6_def_beach =
|
||||
|
@ -55,6 +53,12 @@ NoiseParams nparams_v6_def_biome =
|
|||
{0.0, 1.0, v3f(250.0, 250.0, 250.0), 9130, 3, 0.50};
|
||||
NoiseParams nparams_v6_def_cave =
|
||||
{6.0, 6.0, v3f(250.0, 250.0, 250.0), 34329, 3, 0.50};
|
||||
NoiseParams nparams_v6_def_humidity =
|
||||
{0.5, 0.5, v3f(500.0, 500.0, 500.0), 72384, 4, 0.66};
|
||||
NoiseParams nparams_v6_def_trees =
|
||||
{0.0, 1.0, v3f(125.0, 125.0, 125.0), 2, 4, 0.66};
|
||||
NoiseParams nparams_v6_def_apple_trees =
|
||||
{0.0, 1.0, v3f(100.0, 100.0, 100.0), 342902, 3, 0.45};
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
@ -74,13 +78,15 @@ MapgenV6::MapgenV6(int mapgenid, MapgenV6Params *params) {
|
|||
|
||||
this->ystride = csize.X; //////fix this
|
||||
|
||||
np_cave = params->np_cave;
|
||||
np_cave = params->np_cave;
|
||||
np_humidity = params->np_humidity;
|
||||
np_trees = params->np_trees;
|
||||
np_apple_trees = params->np_apple_trees;
|
||||
|
||||
noise_terrain_base = new Noise(params->np_terrain_base, seed, csize.X, csize.Y);
|
||||
noise_terrain_higher = new Noise(params->np_terrain_higher, seed, csize.X, csize.Y);
|
||||
noise_steepness = new Noise(params->np_steepness, seed, csize.X, csize.Y);
|
||||
noise_height_select = new Noise(params->np_height_select, seed, csize.X, csize.Y);
|
||||
noise_trees = new Noise(params->np_trees, seed, csize.X, csize.Y);
|
||||
noise_mud = new Noise(params->np_mud, seed, csize.X, csize.Y);
|
||||
noise_beach = new Noise(params->np_beach, seed, csize.X, csize.Y);
|
||||
noise_biome = new Noise(params->np_biome, seed, csize.X, csize.Y);
|
||||
|
@ -92,7 +98,6 @@ MapgenV6::~MapgenV6() {
|
|||
delete noise_terrain_higher;
|
||||
delete noise_steepness;
|
||||
delete noise_height_select;
|
||||
delete noise_trees;
|
||||
delete noise_mud;
|
||||
delete noise_beach;
|
||||
delete noise_biome;
|
||||
|
@ -234,12 +239,6 @@ int MapgenV6::getGroundLevelAtPoint(v2s16 p) {
|
|||
|
||||
//////////////////////// Noise functions
|
||||
|
||||
float MapgenV6::getTreeAmount(v2s16 p) {
|
||||
int index = (p.Y - node_min.Z) * ystride + (p.X - node_min.X);
|
||||
return getTreeAmount(index);
|
||||
}
|
||||
|
||||
|
||||
float MapgenV6::getMudAmount(v2s16 p) {
|
||||
int index = (p.Y - node_min.Z) * ystride + (p.X - node_min.X);
|
||||
return getMudAmount(index);
|
||||
|
@ -258,13 +257,30 @@ BiomeType MapgenV6::getBiome(v2s16 p) {
|
|||
}
|
||||
|
||||
|
||||
float MapgenV6::getTreeAmount(int index)
|
||||
float MapgenV6::getHumidity(v2s16 p)
|
||||
{
|
||||
/*double noise = noise2d_perlin(
|
||||
0.5+(float)p.X/500, 0.5+(float)p.Y/500,
|
||||
seed+72384, 4, 0.66);
|
||||
noise = (noise + 1.0)/2.0;*/
|
||||
|
||||
float noise = NoisePerlin2D(np_humidity, p.X, p.Y, seed);
|
||||
|
||||
if (noise < 0.0)
|
||||
noise = 0.0;
|
||||
if (noise > 1.0)
|
||||
noise = 1.0;
|
||||
return noise;
|
||||
}
|
||||
|
||||
|
||||
float MapgenV6::getTreeAmount(v2s16 p)
|
||||
{
|
||||
/*double noise = noise2d_perlin(
|
||||
0.5+(float)p.X/125, 0.5+(float)p.Y/125,
|
||||
seed+2, 4, 0.66);*/
|
||||
|
||||
float noise = noise_trees->result[index];
|
||||
float noise = NoisePerlin2D(np_trees, p.X, p.Y, seed);
|
||||
float zeroval = -0.39;
|
||||
if (noise < zeroval)
|
||||
return 0;
|
||||
|
@ -273,6 +289,18 @@ float MapgenV6::getTreeAmount(int index)
|
|||
}
|
||||
|
||||
|
||||
bool MapgenV6::getHaveAppleTree(v2s16 p)
|
||||
{
|
||||
/*is_apple_tree = noise2d_perlin(
|
||||
0.5+(float)p.X/100, 0.5+(float)p.Z/100,
|
||||
data->seed+342902, 3, 0.45) > 0.2;*/
|
||||
|
||||
float noise = NoisePerlin2D(np_apple_trees, p.X, p.Y, seed);
|
||||
|
||||
return noise > 0.2;
|
||||
}
|
||||
|
||||
|
||||
float MapgenV6::getMudAmount(int index)
|
||||
{
|
||||
if (flags & MG_FLAT)
|
||||
|
@ -465,12 +493,6 @@ void MapgenV6::calculateNoise() {
|
|||
x + 0.5 * noise_height_select->np->spread.X,
|
||||
z + 0.5 * noise_height_select->np->spread.Z);
|
||||
}
|
||||
|
||||
if (flags & MG_TREES) {
|
||||
noise_trees->perlinMap2D(
|
||||
x + 0.5 * noise_trees->np->spread.X,
|
||||
z + 0.5 * noise_trees->np->spread.Z);
|
||||
}
|
||||
|
||||
if (!(flags & MG_FLAT)) {
|
||||
noise_mud->perlinMap2D(
|
||||
|
@ -762,6 +784,8 @@ void MapgenV6::addDirtGravelBlobs() {
|
|||
|
||||
|
||||
void MapgenV6::placeTrees() {
|
||||
//TimeTaker t("placeTrees");
|
||||
|
||||
// Divide area into parts
|
||||
s16 div = 8;
|
||||
s16 sidelen = central_area_size.X / div;
|
||||
|
@ -784,8 +808,13 @@ void MapgenV6::placeTrees() {
|
|||
node_min.X + sidelen + sidelen * x0 - 1,
|
||||
node_min.Z + sidelen + sidelen * z0 - 1
|
||||
);
|
||||
// Amount of trees
|
||||
u32 tree_count = area * getTreeAmount(p2d_center); /////////////optimize this!
|
||||
|
||||
// Amount of trees, jungle area
|
||||
u32 tree_count = area * getTreeAmount(p2d_center);
|
||||
bool is_jungle = (flags & MGV6_JUNGLES) && (getHumidity(p2d_center) > 0.75);
|
||||
if (is_jungle)
|
||||
tree_count *= 4;
|
||||
|
||||
// Put trees in random places on part of division
|
||||
for (u32 i = 0; i < tree_count; i++) {
|
||||
s16 x = myrand_range(p2d_min.X, p2d_max.X);
|
||||
|
@ -806,10 +835,18 @@ void MapgenV6::placeTrees() {
|
|||
continue;
|
||||
}
|
||||
p.Y++;
|
||||
|
||||
// Make a tree
|
||||
treegen::make_tree(*vm, p, false, ndef, myrand());
|
||||
if (is_jungle) {
|
||||
treegen::make_jungletree(*vm, p, ndef, myrand());
|
||||
} else {
|
||||
bool is_apple_tree = (myrand_range(0, 3) == 0) &&
|
||||
getHaveAppleTree(v2s16(x, z));
|
||||
treegen::make_tree(*vm, p, is_apple_tree, ndef, myrand());
|
||||
}
|
||||
}
|
||||
}
|
||||
//printf("placeTrees: %dms\n", t.stop());
|
||||
}
|
||||
|
||||
|
||||
|
@ -841,6 +878,24 @@ void MapgenV6::growGrass() {
|
|||
}
|
||||
}
|
||||
|
||||
void MapgenV6::defineCave(Cave &cave, PseudoRandom ps,
|
||||
v3s16 node_min, bool large_cave) {
|
||||
cave.min_tunnel_diameter = 2;
|
||||
cave.max_tunnel_diameter = ps.range(2,6);
|
||||
cave.dswitchint = ps.range(1,14);
|
||||
cave.flooded = true; //large_cave && ps.range(0,4);
|
||||
if(large_cave){
|
||||
cave.part_max_length_rs = ps.range(2,4);
|
||||
cave.tunnel_routepoints = ps.range(5, ps.range(15,30));
|
||||
cave.min_tunnel_diameter = 5;
|
||||
cave.max_tunnel_diameter = ps.range(7, ps.range(8,24));
|
||||
} else {
|
||||
cave.part_max_length_rs = ps.range(2,9);
|
||||
cave.tunnel_routepoints = ps.range(10, ps.range(15,30));
|
||||
}
|
||||
cave.large_cave_is_flat = (ps.range(0,1) == 0);
|
||||
}
|
||||
|
||||
|
||||
void MapgenV6::generateCaves(int max_stone_y) {
|
||||
// 24ms @cs=8
|
||||
|
@ -874,21 +929,9 @@ void MapgenV6::generateCaves(int max_stone_y) {
|
|||
break;*/
|
||||
|
||||
bool large_cave = (jj >= caves_count);
|
||||
s16 min_tunnel_diameter = 2;
|
||||
s16 max_tunnel_diameter = ps.range(2,6);
|
||||
int dswitchint = ps.range(1,14);
|
||||
u16 tunnel_routepoints = 0;
|
||||
int part_max_length_rs = 0;
|
||||
if(large_cave){
|
||||
part_max_length_rs = ps.range(2,4);
|
||||
tunnel_routepoints = ps.range(5, ps.range(15,30));
|
||||
min_tunnel_diameter = 5;
|
||||
max_tunnel_diameter = ps.range(7, ps.range(8,24));
|
||||
} else {
|
||||
part_max_length_rs = ps.range(2,9);
|
||||
tunnel_routepoints = ps.range(10, ps.range(15,30));
|
||||
}
|
||||
bool large_cave_is_flat = (ps.range(0,1) == 0);
|
||||
|
||||
Cave cave;
|
||||
defineCave(cave, ps, node_min, large_cave);
|
||||
|
||||
v3f main_direction(0,0,0);
|
||||
|
||||
|
@ -901,13 +944,13 @@ void MapgenV6::generateCaves(int max_stone_y) {
|
|||
// Allow a bit more
|
||||
//(this should be more than the maximum radius of the tunnel)
|
||||
s16 insure = 10;
|
||||
s16 more = max_spread_amount - max_tunnel_diameter / 2 - insure;
|
||||
s16 more = max_spread_amount - cave.max_tunnel_diameter / 2 - insure;
|
||||
ar += v3s16(1,0,1) * more * 2;
|
||||
of -= v3s16(1,0,1) * more;
|
||||
|
||||
s16 route_y_min = 0;
|
||||
// Allow half a diameter + 7 over stone surface
|
||||
s16 route_y_max = -of.Y + max_stone_y + max_tunnel_diameter/2 + 7;
|
||||
s16 route_y_max = -of.Y + max_stone_y + cave.max_tunnel_diameter/2 + 7;
|
||||
|
||||
// Limit maximum to area
|
||||
route_y_max = rangelim(route_y_max, 0, ar.Y-1);
|
||||
|
@ -917,10 +960,10 @@ void MapgenV6::generateCaves(int max_stone_y) {
|
|||
s16 min = 0;
|
||||
if(node_min.Y < water_level && node_max.Y > water_level)
|
||||
{
|
||||
min = water_level - max_tunnel_diameter/3 - of.Y;
|
||||
route_y_max = water_level + max_tunnel_diameter/3 - of.Y;
|
||||
min = water_level - cave.max_tunnel_diameter/3 - of.Y;
|
||||
route_y_max = water_level + cave.max_tunnel_diameter/3 - of.Y;
|
||||
}
|
||||
route_y_min = ps.range(min, min + max_tunnel_diameter);
|
||||
route_y_min = ps.range(min, min + cave.max_tunnel_diameter);
|
||||
route_y_min = rangelim(route_y_min, 0, route_y_max);
|
||||
}
|
||||
|
||||
|
@ -948,9 +991,9 @@ void MapgenV6::generateCaves(int max_stone_y) {
|
|||
Generate some tunnel starting from orp
|
||||
*/
|
||||
|
||||
for(u16 j=0; j<tunnel_routepoints; j++)
|
||||
for(u16 j=0; j<cave.tunnel_routepoints; j++)
|
||||
{
|
||||
if(j%dswitchint==0 && large_cave == false)
|
||||
if(j%cave.dswitchint==0 && large_cave == false)
|
||||
{
|
||||
main_direction = v3f(
|
||||
((float)(ps.next()%20)-(float)10)/10,
|
||||
|
@ -961,8 +1004,8 @@ void MapgenV6::generateCaves(int max_stone_y) {
|
|||
}
|
||||
|
||||
// Randomize size
|
||||
s16 min_d = min_tunnel_diameter;
|
||||
s16 max_d = max_tunnel_diameter;
|
||||
s16 min_d = cave.min_tunnel_diameter;
|
||||
s16 max_d = cave.max_tunnel_diameter;
|
||||
s16 rs = ps.range(min_d, max_d);
|
||||
|
||||
// Every second section is rough
|
||||
|
@ -972,17 +1015,17 @@ void MapgenV6::generateCaves(int max_stone_y) {
|
|||
if(large_cave)
|
||||
{
|
||||
maxlen = v3s16(
|
||||
rs*part_max_length_rs,
|
||||
rs*part_max_length_rs/2,
|
||||
rs*part_max_length_rs
|
||||
rs*cave.part_max_length_rs,
|
||||
rs*cave.part_max_length_rs/2,
|
||||
rs*cave.part_max_length_rs
|
||||
);
|
||||
}
|
||||
else
|
||||
{
|
||||
maxlen = v3s16(
|
||||
rs*part_max_length_rs,
|
||||
ps.range(1, rs*part_max_length_rs),
|
||||
rs*part_max_length_rs
|
||||
rs*cave.part_max_length_rs,
|
||||
ps.range(1, rs*cave.part_max_length_rs),
|
||||
rs*cave.part_max_length_rs
|
||||
);
|
||||
}
|
||||
|
||||
|
@ -1054,7 +1097,7 @@ void MapgenV6::generateCaves(int max_stone_y) {
|
|||
/*// Make better floors in small caves
|
||||
if(y0 <= -rs/2 && rs<=7)
|
||||
continue;*/
|
||||
if (large_cave_is_flat) {
|
||||
if (cave.large_cave_is_flat) {
|
||||
// Make large caves not so tall
|
||||
if (rs > 7 && abs(y0) >= rs/3)
|
||||
continue;
|
||||
|
@ -1072,13 +1115,13 @@ void MapgenV6::generateCaves(int max_stone_y) {
|
|||
u32 i = vm->m_area.index(p);
|
||||
|
||||
if(large_cave) {
|
||||
if (full_node_min.Y < water_level &&
|
||||
if (cave.flooded && full_node_min.Y < water_level &&
|
||||
full_node_max.Y > water_level) {
|
||||
if (p.Y <= water_level)
|
||||
vm->m_data[i] = waternode;
|
||||
else
|
||||
vm->m_data[i] = airnode;
|
||||
} else if (full_node_max.Y < water_level) {
|
||||
} else if (cave.flooded && full_node_max.Y < water_level) {
|
||||
if (p.Y < startp.Y - 2)
|
||||
vm->m_data[i] = lavanode;
|
||||
else
|
||||
|
|
|
@ -35,11 +35,23 @@ extern NoiseParams nparams_v6_def_terrain_base;
|
|||
extern NoiseParams nparams_v6_def_terrain_higher;
|
||||
extern NoiseParams nparams_v6_def_steepness;
|
||||
extern NoiseParams nparams_v6_def_height_select;
|
||||
extern NoiseParams nparams_v6_def_trees;
|
||||
extern NoiseParams nparams_v6_def_mud;
|
||||
extern NoiseParams nparams_v6_def_beach;
|
||||
extern NoiseParams nparams_v6_def_biome;
|
||||
extern NoiseParams nparams_v6_def_cave;
|
||||
extern NoiseParams nparams_v6_def_humidity;
|
||||
extern NoiseParams nparams_v6_def_trees;
|
||||
extern NoiseParams nparams_v6_def_apple_trees;
|
||||
|
||||
struct Cave {
|
||||
s16 min_tunnel_diameter;
|
||||
s16 max_tunnel_diameter;
|
||||
int dswitchint;
|
||||
u16 tunnel_routepoints;
|
||||
int part_max_length_rs;
|
||||
bool large_cave_is_flat;
|
||||
bool flooded;
|
||||
};
|
||||
|
||||
struct MapgenV6Params : public MapgenParams {
|
||||
float freq_desert;
|
||||
|
@ -48,12 +60,14 @@ struct MapgenV6Params : public MapgenParams {
|
|||
NoiseParams *np_terrain_higher;
|
||||
NoiseParams *np_steepness;
|
||||
NoiseParams *np_height_select;
|
||||
NoiseParams *np_trees;
|
||||
NoiseParams *np_mud;
|
||||
NoiseParams *np_beach;
|
||||
NoiseParams *np_biome;
|
||||
NoiseParams *np_cave;
|
||||
|
||||
NoiseParams *np_humidity;
|
||||
NoiseParams *np_trees;
|
||||
NoiseParams *np_apple_trees;
|
||||
|
||||
MapgenV6Params() {
|
||||
freq_desert = 0.45;
|
||||
freq_beach = 0.15;
|
||||
|
@ -61,11 +75,14 @@ struct MapgenV6Params : public MapgenParams {
|
|||
np_terrain_higher = &nparams_v6_def_terrain_higher;
|
||||
np_steepness = &nparams_v6_def_steepness;
|
||||
np_height_select = &nparams_v6_def_height_select;
|
||||
np_trees = &nparams_v6_def_trees;
|
||||
np_mud = &nparams_v6_def_mud;
|
||||
np_beach = &nparams_v6_def_beach;
|
||||
np_biome = &nparams_v6_def_biome;
|
||||
np_cave = &nparams_v6_def_cave;
|
||||
np_humidity = &nparams_v6_def_humidity;
|
||||
np_trees = &nparams_v6_def_trees;
|
||||
np_apple_trees = &nparams_v6_def_apple_trees;
|
||||
|
||||
}
|
||||
|
||||
bool readParams(Settings *settings);
|
||||
|
@ -90,11 +107,13 @@ public:
|
|||
Noise *noise_terrain_higher;
|
||||
Noise *noise_steepness;
|
||||
Noise *noise_height_select;
|
||||
Noise *noise_trees;
|
||||
Noise *noise_mud;
|
||||
Noise *noise_beach;
|
||||
Noise *noise_biome;
|
||||
NoiseParams *np_cave;
|
||||
NoiseParams *np_humidity;
|
||||
NoiseParams *np_trees;
|
||||
NoiseParams *np_apple_trees;
|
||||
float freq_desert;
|
||||
float freq_beach;
|
||||
|
||||
|
@ -117,19 +136,20 @@ public:
|
|||
|
||||
float baseTerrainLevel(float terrain_base, float terrain_higher,
|
||||
float steepness, float height_select);
|
||||
float baseTerrainLevelFromNoise(v2s16 p);
|
||||
float baseTerrainLevelFromMap(v2s16 p);
|
||||
float baseTerrainLevelFromMap(int index);
|
||||
virtual float baseTerrainLevelFromNoise(v2s16 p);
|
||||
virtual float baseTerrainLevelFromMap(v2s16 p);
|
||||
virtual float baseTerrainLevelFromMap(int index);
|
||||
|
||||
s16 find_ground_level(v2s16 p2d);
|
||||
s16 find_stone_level(v2s16 p2d);
|
||||
bool block_is_underground(u64 seed, v3s16 blockpos);
|
||||
s16 find_ground_level_from_noise(u64 seed, v2s16 p2d, s16 precision);
|
||||
|
||||
float getHumidity(v2s16 p);
|
||||
float getTreeAmount(v2s16 p);
|
||||
float getTreeAmount(int index);
|
||||
bool getHaveAppleTree(v2s16 p);
|
||||
float getMudAmount(v2s16 p);
|
||||
float getMudAmount(int index);
|
||||
virtual float getMudAmount(int index);
|
||||
bool getHaveBeach(v2s16 p);
|
||||
bool getHaveBeach(int index);
|
||||
BiomeType getBiome(v2s16 p);
|
||||
|
@ -137,14 +157,15 @@ public:
|
|||
|
||||
u32 get_blockseed(u64 seed, v3s16 p);
|
||||
|
||||
|
||||
void calculateNoise();
|
||||
virtual void calculateNoise();
|
||||
int generateGround();
|
||||
void addMud();
|
||||
void flowMud(s16 &mudflow_minpos, s16 &mudflow_maxpos);
|
||||
void addDirtGravelBlobs();
|
||||
void growGrass();
|
||||
void placeTrees();
|
||||
virtual void defineCave(Cave &cave, PseudoRandom ps,
|
||||
v3s16 node_min, bool large_cave);
|
||||
void generateCaves(int max_stone_y);
|
||||
};
|
||||
|
||||
|
|
|
@ -89,7 +89,7 @@ public:
|
|||
Noise(NoiseParams *np, int seed, int sx, int sy, int sz);
|
||||
~Noise();
|
||||
|
||||
void init(NoiseParams *np, int seed, int sx, int sy, int sz);
|
||||
virtual void init(NoiseParams *np, int seed, int sx, int sy, int sz);
|
||||
void setSize(int sx, int sy);
|
||||
void setSize(int sx, int sy, int sz);
|
||||
void setSpreadFactor(v3f spread);
|
||||
|
|
|
@ -27,7 +27,6 @@ with this program; if not, write to the Free Software Foundation, Inc.,
|
|||
#include "scriptapi_entity.h"
|
||||
#include "scriptapi_common.h"
|
||||
|
||||
|
||||
/*
|
||||
ObjectRef
|
||||
*/
|
||||
|
@ -582,6 +581,30 @@ int ObjectRef::l_get_look_yaw(lua_State *L)
|
|||
return 1;
|
||||
}
|
||||
|
||||
// set_look_pitch(self, radians)
|
||||
int ObjectRef::l_set_look_pitch(lua_State *L)
|
||||
{
|
||||
ObjectRef *ref = checkobject(L, 1);
|
||||
PlayerSAO* co = getplayersao(ref);
|
||||
if(co == NULL) return 0;
|
||||
float pitch = luaL_checknumber(L, 2) * core::RADTODEG;
|
||||
// Do it
|
||||
co->setPitch(pitch);
|
||||
return 1;
|
||||
}
|
||||
|
||||
// set_look_yaw(self, radians)
|
||||
int ObjectRef::l_set_look_yaw(lua_State *L)
|
||||
{
|
||||
ObjectRef *ref = checkobject(L, 1);
|
||||
PlayerSAO* co = getplayersao(ref);
|
||||
if(co == NULL) return 0;
|
||||
float yaw = luaL_checknumber(L, 2) * core::RADTODEG;
|
||||
// Do it
|
||||
co->setYaw(yaw);
|
||||
return 1;
|
||||
}
|
||||
|
||||
// set_inventory_formspec(self, formspec)
|
||||
int ObjectRef::l_set_inventory_formspec(lua_State *L)
|
||||
{
|
||||
|
@ -755,6 +778,8 @@ const luaL_reg ObjectRef::methods[] = {
|
|||
luamethod(ObjectRef, get_look_dir),
|
||||
luamethod(ObjectRef, get_look_pitch),
|
||||
luamethod(ObjectRef, get_look_yaw),
|
||||
luamethod(ObjectRef, set_look_yaw),
|
||||
luamethod(ObjectRef, set_look_pitch),
|
||||
luamethod(ObjectRef, set_inventory_formspec),
|
||||
luamethod(ObjectRef, get_inventory_formspec),
|
||||
luamethod(ObjectRef, get_player_control),
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
Minetest-c55
|
||||
Minetest
|
||||
Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
|
@ -169,6 +169,12 @@ private:
|
|||
// get_look_yaw(self)
|
||||
static int l_get_look_yaw(lua_State *L);
|
||||
|
||||
// set_look_pitch(self, radians)
|
||||
static int l_set_look_pitch(lua_State *L);
|
||||
|
||||
// set_look_yaw(self, radians)
|
||||
static int l_set_look_yaw(lua_State *L);
|
||||
|
||||
// set_inventory_formspec(self, formspec)
|
||||
static int l_set_inventory_formspec(lua_State *L);
|
||||
|
||||
|
|
|
@ -460,7 +460,7 @@ public:
|
|||
n = m_defaults.find(name);
|
||||
if(n == m_defaults.end())
|
||||
{
|
||||
throw SettingNotFoundException("Setting not found");
|
||||
throw SettingNotFoundException(("Setting [" + name + "] not found ").c_str());
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -510,8 +510,15 @@ v3f transposeMatrix(irr::core::matrix4 M, v3f v)
|
|||
void make_jungletree(VoxelManipulator &vmanip, v3s16 p0,
|
||||
INodeDefManager *ndef, int seed)
|
||||
{
|
||||
MapNode treenode(ndef->getId("mapgen_jungletree"));
|
||||
MapNode leavesnode(ndef->getId("mapgen_leaves"));
|
||||
content_t c_tree = ndef->getId("mapgen_jungletree");
|
||||
content_t c_leaves = ndef->getId("mapgen_jungleleaves");
|
||||
if (c_tree == CONTENT_IGNORE)
|
||||
c_tree = ndef->getId("mapgen_tree");
|
||||
if (c_leaves == CONTENT_IGNORE)
|
||||
c_leaves = ndef->getId("mapgen_leaves");
|
||||
|
||||
MapNode treenode(c_tree);
|
||||
MapNode leavesnode(c_leaves);
|
||||
|
||||
PseudoRandom pr(seed);
|
||||
for(s16 x=-1; x<=1; x++)
|
||||
|
@ -521,19 +528,27 @@ void make_jungletree(VoxelManipulator &vmanip, v3s16 p0,
|
|||
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;
|
||||
u32 vi1 = vmanip.m_area.index(p1);
|
||||
u32 vi2 = vmanip.m_area.index(p2);
|
||||
|
||||
if (vmanip.m_area.contains(p2) &&
|
||||
vmanip.m_data[vi2].getContent() == CONTENT_AIR)
|
||||
vmanip.m_data[vi2] = treenode;
|
||||
else if (vmanip.m_area.contains(p1) &&
|
||||
vmanip.m_data[vi1].getContent() == CONTENT_AIR)
|
||||
vmanip.m_data[vi1] = treenode;
|
||||
}
|
||||
vmanip.m_data[vmanip.m_area.index(p0)] = treenode;
|
||||
|
||||
s16 trunk_h = pr.range(8, 12);
|
||||
v3s16 p1 = p0;
|
||||
for(s16 ii=0; ii<trunk_h; ii++)
|
||||
for (s16 ii=0; ii<trunk_h; ii++)
|
||||
{
|
||||
if(vmanip.m_area.contains(p1))
|
||||
vmanip.m_data[vmanip.m_area.index(p1)] = treenode;
|
||||
if (vmanip.m_area.contains(p1)) {
|
||||
u32 vi = vmanip.m_area.index(p1);
|
||||
if (vmanip.m_data[vi].getContent() == CONTENT_AIR)
|
||||
vmanip.m_data[vi] = treenode;
|
||||
}
|
||||
p1.Y++;
|
||||
}
|
||||
|
||||
|
@ -586,8 +601,8 @@ void make_jungletree(VoxelManipulator &vmanip, v3s16 p0,
|
|||
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)
|
||||
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)
|
||||
|
|
Loading…
Reference in New Issue