2014-08-04 16:24:11 -07:00
mg_villages.wseed = 0 ;
2014-08-05 08:34:50 -07:00
minetest.register_on_mapgen_init ( function ( mgparams )
mg_villages.wseed = math.floor ( mgparams.seed / 10000000000 )
end )
2014-08-04 16:24:11 -07:00
function mg_villages . get_bseed ( minp )
return mg_villages.wseed + math.floor ( 5 * minp.x / 47 ) + math.floor ( 873 * minp.z / 91 )
end
function mg_villages . get_bseed2 ( minp )
return mg_villages.wseed + math.floor ( 87 * minp.x / 47 ) + math.floor ( 73 * minp.z / 91 ) + math.floor ( 31 * minp.y / 12 )
end
mg_villages.inside_village = function ( x , z , village , vnoise )
return mg_villages.get_vn ( x , z , vnoise : get2d ( { x = x , y = z } ) , village ) <= 40
end
mg_villages.get_vn = function ( x , z , noise , village )
local vx , vz , vs = village.vx , village.vz , village.vs
return ( noise - 2 ) * 20 +
( 40 / ( vs * vs ) ) * ( ( x - vx ) * ( x - vx ) + ( z - vz ) * ( z - vz ) )
end
mg_villages.villages_in_mapchunk = function ( minp )
local noise1raw = minetest.get_perlin ( 12345 , 6 , 0.5 , 256 )
local vcr = VILLAGE_CHECK_RADIUS
local villages = { }
local generate_new_villages = true ;
for xi = - vcr , vcr do
for zi = - vcr , vcr do
for _ , village in ipairs ( mg_villages.villages_at_point ( { x = minp.x + xi * 80 , z = minp.z + zi * 80 } , noise1raw ) ) do
village.to_grow = { }
villages [ # villages + 1 ] = village
end
-- check if the village exists already
local v_nr = 1 ;
for v_nr , village in ipairs ( villages ) do
local village_id = tostring ( village.vx ) .. ' : ' .. tostring ( village.vz ) ;
if ( mg_villages.all_villages and mg_villages.all_villages [ village_id ] ) then
villages [ v_nr ] = mg_villages.all_villages [ village_id ] ;
generate_new_villages = false ;
end
end
end
end
return villages ;
end
2014-08-04 18:20:07 -07:00
-- adjust the terrain level to the respective height of the village
mg_villages.flatten_village_area = function ( villages , village_noise , minp , maxp , vm , data , param2_data , a )
local c_air = minetest.get_content_id ( ' air ' ) ;
local c_ignore = minetest.get_content_id ( ' ignore ' ) ;
local c_stone = minetest.get_content_id ( ' default:stone ' ) ;
local c_dirt = minetest.get_content_id ( ' default:dirt ' ) ;
local c_dirt_with_grass = minetest.get_content_id ( ' default:dirt_with_grass ' ) ;
for z = minp.z , maxp.z do
for x = minp.x , maxp.x do
for _ , village in ipairs ( villages ) do
if ( mg_villages.inside_village ( x , z , village , village_noise ) ) then
local buffer = { } ;
local buffer_param2 = { } ;
local buffer_index = 0 ;
y = maxp.y ;
while ( y > minp.y ) do
local ci = data [ a : index ( x , y , z ) ] ;
if ( ci ~= c_air and ci ~= c_ignore and buffer_index == 0 ) then
-- only nodes on which walking is possible may be counted as ground
local node_name = minetest.get_name_from_content_id ( ci ) ;
local def = minetest.registered_nodes [ node_name ] ;
if ( def and def.walkable == true and def.is_ground_content == true ) then
-- from now on, save the nodes below
buffer_index = 1 ;
end
end
-- save found nodes for later use
if ( buffer_index > 0 ) then
buffer [ buffer_index ] = ci ;
buffer_param2 [ buffer_index ] = param2_data [ a : index ( x , y , z ) ] ;
buffer_index = buffer_index + 1 ;
end
-- make sure there is air for the village
if ( y > village.vh and ci ~= c_ignore and ci ~= c_air ) then
data [ a : index ( x , y , z ) ] = c_air ;
end
y = y - 1 ;
end
-- apply the data found in the buffer
for i , v in ipairs ( buffer ) do
if ( village.vh - i + 1 >= minp.y ) then
if ( i == 1 and buffer [ i ] == c_dirt ) then
buffer [ i ] = c_dirt_with_grass ;
end
data [ a : index ( x , village.vh - i + 1 , z ) ] = buffer [ i ] ;
param2_data [ a : index ( x , village.vh - i + 1 , z ) ] = buffer_param2 [ i ] ;
end
end
end
end
end
end
end
2014-08-04 16:24:11 -07:00
mg_villages.place_villages_via_voxelmanip = function ( villages , minp , maxp , vm , data , param2_data , a , top )
local village_noise = minetest.get_perlin ( 7635 , 3 , 0.5 , 16 ) ;
-- if no voxelmanip data was passed on, read the data here
if ( not ( vm ) or not ( a ) or not ( data ) or not ( param2_data ) ) then
vm , emin , emax = minetest.get_mapgen_object ( " voxelmanip " )
if ( not ( vm ) ) then
return ;
end
a = VoxelArea : new {
MinEdge = { x = emin.x , y = emin.y , z = emin.z } ,
MaxEdge = { x = emax.x , y = emax.y , z = emax.z } ,
}
data = vm : get_data ( )
param2_data = vm : get_param2_data ( )
end
2014-08-04 18:20:07 -07:00
mg_villages.flatten_village_area ( villages , village_noise , minp , maxp , vm , data , param2_data , a ) ;
2014-08-04 16:24:11 -07:00
local top_node = ' default:dirt_with_grass ' ;
-- replace dirt_with_grass with whatever is common in that biome
if ( top == c_sand ) then top_node = ' default:sand ' ;
elseif ( top == c_dsert_sand ) then top_node = ' default:desert_sand ' ;
elseif ( top == c_dry_grass ) then top_node = ' mg:dirt_with_dry_grass ' ;
elseif ( top == c_dirt_snow ) then top_node = ' default:dirt_with_snow ' ;
else top_node = ' default:dirt_with_grass ' ;
end
for _ , village in ipairs ( villages ) do
village.to_add_data = mg_villages.generate_village ( village , minp , maxp , data , param2_data , a , village_noise , top_node )
end
vm : set_data ( data )
vm : set_param2_data ( param2_data )
vm : calc_lighting (
{ x = minp.x - 16 , y = minp.y , z = minp.z - 16 } ,
{ x = maxp.x + 16 , y = maxp.y , z = maxp.z + 16 }
)
vm : write_to_map ( data )
-- initialize the pseudo random generator so that the chests will be filled in a reproducable pattern
local pr = PseudoRandom ( mg_villages.get_bseed ( minp ) ) ;
local meta
for _ , village in ipairs ( villages ) do
for _ , n in pairs ( village.to_add_data . extranodes ) do
minetest.set_node ( n.pos , n.node )
if n.meta ~= nil then
meta = minetest.get_meta ( n.pos )
meta : from_table ( n.meta )
if n.node . name == " default:chest " then
local inv = meta : get_inventory ( )
local items = inv : get_list ( " main " )
for i = 1 , inv : get_size ( " main " ) do
inv : set_stack ( " main " , i , ItemStack ( " " ) )
end
local numitems = pr : next ( 3 , 20 )
for i = 1 , numitems do
local ii = pr : next ( 1 , # items )
local prob = items [ ii ] : get_count ( ) % 2 ^ 8
local stacksz = math.floor ( items [ ii ] : get_count ( ) / 2 ^ 8 )
if pr : next ( 0 , prob ) == 0 and stacksz > 0 then
stk = ItemStack ( { name = items [ ii ] : get_name ( ) , count = pr : next ( 1 , stacksz ) , wear = items [ ii ] : get_wear ( ) , metadata = items [ ii ] : get_metadata ( ) } )
local ind = pr : next ( 1 , inv : get_size ( " main " ) )
while not inv : get_stack ( " main " , ind ) : is_empty ( ) do
ind = pr : next ( 1 , inv : get_size ( " main " ) )
end
inv : set_stack ( " main " , ind , stk )
end
end
end
end
end
-- now add those buildings which are .mts files and need to be placed by minetest.place_schematic(...)
mg_villages.place_schematics ( village.to_add_data . bpos , village.to_add_data . replacements , a , pr ) ;
if ( not ( mg_villages.all_villages ) ) then
mg_villages.all_villages = { } ;
end
-- unique id - there can only be one village at a given pair of x,z coordinates
local village_id = tostring ( village.vx ) .. ' : ' .. tostring ( village.vz ) ;
-- the village data is saved only once per village - and not whenever part of the village is generated
if ( not ( mg_villages.all_villages [ village_id ] ) ) then
-- count how many villages we already have and assign each village a uniq number
local count = 1 ;
for _ , v in pairs ( mg_villages.all_villages ) do
count = count + 1 ;
end
village.nr = count ;
mg_villages.anz_villages = count ;
mg_villages.all_villages [ village_id ] = minetest.deserialize ( minetest.serialize ( village ) ) ;
print ( " Village No. " .. tostring ( count ) .. " of type \' " .. tostring ( village.village_type ) .. " \' of size " .. tostring ( village.vs ) .. " spawned at: x = " .. village.vx .. " , z = " .. village.vz )
save_restore.save_data ( ' mg_all_villages.data ' , mg_villages.all_villages ) ;
end
end
end
local function spawnplayer ( player )
local noise1 = minetest.get_perlin ( 12345 , 6 , 0.5 , 256 )
local min_dist = math.huge
local min_pos = { x = 0 , y = 3 , z = 0 }
for bx = - 20 , 20 do
for bz = - 20 , 20 do
local minp = { x = - 32 + 80 * bx , y = - 32 , z = - 32 + 80 * bz }
for _ , village in ipairs ( mg_villages.villages_at_point ( minp , noise1 ) ) do
if math.abs ( village.vx ) + math.abs ( village.vz ) < min_dist then
min_pos = { x = village.vx , y = village.vh + 2 , z = village.vz }
min_dist = math.abs ( village.vx ) + math.abs ( village.vz )
end
end
end
end
player : setpos ( min_pos )
end
minetest.register_on_newplayer ( function ( player )
spawnplayer ( player )
end )
minetest.register_on_respawnplayer ( function ( player )
spawnplayer ( player )
return true
end )