288 lines
12 KiB
Lua
288 lines
12 KiB
Lua
-- Squaresville init.lua
|
|
-- Copyright Duane Robertson (duane@duanerobertson.com), 2017
|
|
-- Distributed under the LGPLv2.1 (https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html)
|
|
|
|
|
|
squaresville = {}
|
|
squaresville.version = '1.0'
|
|
squaresville.path = minetest.get_modpath(minetest.get_current_modname())
|
|
squaresville.world = minetest.get_worldpath()
|
|
|
|
squaresville.baseline = 8100 -- the altitude of the squaresville "dimension"
|
|
squaresville.baseline_ruin = 10000 -- how far up to the ruin "dimension"
|
|
squaresville.extent_bottom = -500 -- how far down to make the squaresville
|
|
squaresville.extent_bottom_ruin = -500 -- how far down to make the squaresville
|
|
squaresville.extent_top = 500 -- how far up to make it
|
|
squaresville.extent_top_ruin = 500 -- how far up to make it
|
|
|
|
squaresville.attenuation = 50 -- distance to blend terrain with cities: 50
|
|
squaresville.block_size = 60 -- size of a city block: 60
|
|
squaresville.city_blocks = 2 -- radius of city blocks per city: 2
|
|
squaresville.civ_base = 8
|
|
squaresville.lake_depth = 3 -- rough depth of upland water: 3
|
|
squaresville.max_height = 31000 -- maximum extent of the world
|
|
squaresville.river_base = 1
|
|
squaresville.river_cutoff = 3 -- 3
|
|
squaresville.river_scale = 15
|
|
squaresville.road_size = 7 -- width of roads (should be odd): 7
|
|
squaresville.suburb_blocks = 2 -- radius of suburb blocks per city: 2
|
|
squaresville.suburb_humidity = 60 -- amount of watering city dwellers do: 60
|
|
squaresville.terrain_scale = 50 -- typical maximum altitude of terrain: 50
|
|
squaresville.terrain_scale_2 = 50
|
|
squaresville.town_tree_thinning = 5
|
|
squaresville.tree_spacing = 5 -- typical distance between trees: 5
|
|
squaresville.water_level_base_mod = 1 -- height of water table: 1
|
|
squaresville.wild_size = 8 -- distance between cities: 8
|
|
|
|
|
|
squaresville.noise = {}
|
|
|
|
squaresville.noise['ground_1'] = { def = {offset = squaresville.water_level_base_mod, scale = squaresville.terrain_scale, seed = 4382, spread = {x = 1033, y = 1033, z = 1033}, octaves = 5, persist = 0.6, lacunarity = 2.0} }
|
|
squaresville.noise['ground_2'] = { def = {offset = 0, scale = squaresville.terrain_scale_2, seed = 1005, spread = {x = 251, y = 251, z = 251}, octaves = 5, persist = 0.6, lacunarity = 2.0} }
|
|
squaresville.noise['heat_1'] = { def = {offset = 50, scale = 50, seed = 5349, spread = {x = 1000, y = 1000, z = 1000}, octaves = 3, persist = 0.5, lacunarity = 2} }
|
|
squaresville.noise['heat_2'] = { def = {offset = 0, scale = 1.5, seed = 13, spread = {x = 8, y = 8, z = 8}, octaves = 2, persist = 1.0, lacunarity = 2} }
|
|
squaresville.noise['humidity_1'] = { def = {offset = 50, scale = 50, seed = 842, spread = {x = 1000, y = 1000, z = 1000}, octaves = 3, persist = 0.5, lacunarity = 2} }
|
|
squaresville.noise['humidity_2'] = { def = {offset = 0, scale = 1.5, seed = 90003, spread = {x = 8, y = 8, z = 8}, octaves = 2, persist = 1.0, lacunarity = 2} }
|
|
squaresville.noise['river'] = { def = {offset = 0, scale = squaresville.river_scale, seed = -6819, spread = {x = 451, y = 451, z = 451}, octaves = 3, persist = 1, lacunarity = 2.0} }
|
|
squaresville.noise['ruin'] = { def = {offset = 25, scale = 15, seed = 4877, spread = {x = 240, y = 240, z = 240}, octaves = 4, persist = 1, lacunarity = 2.0} }
|
|
--squaresville.cave_1_p = {offset = 0, scale = 1, seed = 4382, spread = {x = 41, y = 41, z = 41}, octaves = 3, persist = 1.0, lacunarity = 2.0}
|
|
--squaresville.cave_2_p = {offset = 0, scale = 1, seed = -6119, spread = {x = 41, y = 41, z = 41}, octaves = 3, persist = 1.0, lacunarity = 2.0}
|
|
|
|
|
|
squaresville.block_plus_road_size = squaresville.road_size + squaresville.block_size
|
|
squaresville.city_limits = squaresville.block_plus_road_size * squaresville.city_blocks
|
|
squaresville.city_limits_plus_road_size = squaresville.city_limits + squaresville.road_size
|
|
squaresville.half_road_size = math.floor(squaresville.road_size / 2)
|
|
squaresville.half_terrain_scale_neg = squaresville.terrain_scale / -2
|
|
squaresville.half_terrain_scale = squaresville.terrain_scale / 2
|
|
squaresville.house_schematics = {}
|
|
squaresville.river_scale_less_one = squaresville.river_scale - 0.99
|
|
squaresville.river_zone = squaresville.river_scale + squaresville.river_cutoff - 1
|
|
squaresville.suburb_limits = squaresville.city_limits + squaresville.block_plus_road_size * squaresville.suburb_blocks
|
|
squaresville.suburb_limits_plus_road_size = squaresville.suburb_limits + squaresville.road_size
|
|
squaresville.wild_limits = squaresville.suburb_limits * squaresville.wild_size
|
|
squaresville.center_add = squaresville.max_height + squaresville.half_road_size + squaresville.wild_limits / 2
|
|
|
|
squaresville.time_buildings = 0
|
|
squaresville.time_caves = 0
|
|
squaresville.time_env_noise = 0
|
|
squaresville.time_moria = 0
|
|
squaresville.time_overhead = 0
|
|
squaresville.time_schem = 0
|
|
squaresville.time_terrain = 0
|
|
squaresville.time_trees = 0
|
|
squaresville.time_y_loop = 0
|
|
squaresville.time_zigg = 0
|
|
|
|
|
|
squaresville.vacancies = tonumber(minetest.setting_get('squaresville_vacancies')) or 8
|
|
if squaresville.vacancies < 0 or squaresville.vacancies > 10 then
|
|
squaresville.vacancies = 0
|
|
end
|
|
|
|
squaresville.desolation = tonumber(minetest.setting_get('squaresville_desolation')) or 0
|
|
if squaresville.desolation < 0 or squaresville.desolation > 10 then
|
|
squaresville.desolation = 0
|
|
end
|
|
|
|
squaresville.light_panels = minetest.setting_getbool('squaresville_light_panels')
|
|
if squaresville.light_panels == nil then
|
|
squaresville.light_panels = true
|
|
end
|
|
|
|
squaresville.single_node = minetest.setting_getbool('squaresville_single_node')
|
|
if squaresville.single_node == nil then
|
|
squaresville.single_node = false
|
|
end
|
|
|
|
squaresville.single_node_ruin = minetest.setting_getbool('squaresville_single_node_ruin')
|
|
if squaresville.single_node_ruin == nil then
|
|
squaresville.single_node_ruin = false
|
|
end
|
|
|
|
squaresville.no_buildings = minetest.setting_getbool('squaresville_no_buildings')
|
|
if squaresville.no_buildings == nil then
|
|
squaresville.no_buildings = false
|
|
end
|
|
|
|
squaresville.dangerous_terrain = true
|
|
|
|
|
|
if squaresville.single_node_ruin then
|
|
-- Set mapgen parameters to singlenode
|
|
squaresville.baseline_ruin = 0
|
|
squaresville.extent_bottom_ruin = -31000
|
|
minetest.register_on_mapgen_init(function(mgparams)
|
|
minetest.set_mapgen_params({mgname="singlenode", flags="nolight"})
|
|
end)
|
|
elseif squaresville.single_node then
|
|
-- Set mapgen parameters to singlenode
|
|
squaresville.baseline_ruin = 8000
|
|
squaresville.baseline = 0
|
|
squaresville.extent_bottom = -31000
|
|
minetest.register_on_mapgen_init(function(mgparams)
|
|
minetest.set_mapgen_params({mgname="singlenode", flags="nolight"})
|
|
end)
|
|
end
|
|
|
|
|
|
-- Modify a node to add a group
|
|
function minetest.add_group(node_name, groups)
|
|
local def = minetest.registered_items[node_name]
|
|
if not (node_name and def and groups and type(groups) == 'table') then
|
|
return false
|
|
end
|
|
local def_groups = def.groups or {}
|
|
for group, value in pairs(groups) do
|
|
if value ~= 0 then
|
|
def_groups[group] = value
|
|
else
|
|
def_groups[group] = nil
|
|
end
|
|
end
|
|
minetest.override_item(node_name, {groups = def_groups})
|
|
return true
|
|
end
|
|
|
|
|
|
if minetest.get_modpath('booty') then
|
|
squaresville.clone_node = booty.clone_node
|
|
squaresville.node = booty.node
|
|
else
|
|
function squaresville.clone_node(name)
|
|
if not (name and type(name) == 'string') then
|
|
return
|
|
end
|
|
|
|
local node = minetest.registered_nodes[name]
|
|
local node2 = table.copy(node)
|
|
return node2
|
|
end
|
|
|
|
-- This tables looks up nodes that aren't already stored.
|
|
squaresville.node = setmetatable({}, {
|
|
__index = function(t, k)
|
|
if not (t and k and type(t) == 'table' and type(k) == 'string') then
|
|
return
|
|
end
|
|
|
|
t[k] = minetest.get_content_id(k)
|
|
return t[k]
|
|
end
|
|
})
|
|
end
|
|
local node = squaresville.node
|
|
|
|
|
|
squaresville.surround = function(node, data, area, ivm)
|
|
if not (node and data and area and ivm and type(data) == 'table' and type(ivm) == 'number') then
|
|
return
|
|
end
|
|
|
|
-- Check to make sure that a plant root is fully surrounded.
|
|
-- This is due to the kludgy way you have to make water plants
|
|
-- in minetest, to avoid bubbles.
|
|
for x1 = -1,1,2 do
|
|
local n = data[ivm+x1]
|
|
if n == node['default:river_water_source'] or n == node['default:water_source'] or n == node['air'] then
|
|
return false
|
|
end
|
|
end
|
|
for z1 = -area.zstride,area.zstride,2*area.zstride do
|
|
local n = data[ivm+z1]
|
|
if n == node['default:river_water_source'] or n == node['default:water_source'] or n == node['air'] then
|
|
return false
|
|
end
|
|
end
|
|
|
|
return true
|
|
end
|
|
|
|
|
|
-- These nodes will have their on_construct method called
|
|
-- when placed by the mapgen (to start timers).
|
|
squaresville.construct_nodes = {}
|
|
function squaresville.add_construct(node_name)
|
|
squaresville.construct_nodes[node[node_name]] = true
|
|
end
|
|
|
|
|
|
function squaresville.get_desolation(baseline, danger)
|
|
local desolation = 0
|
|
if baseline == squaresville.baseline then
|
|
if squaresville.dangerous_terrain then
|
|
if squaresville.pr then
|
|
desolation = danger * 2 - squaresville.pr:next(1, 5)
|
|
else
|
|
desolation = danger * 2 - 3
|
|
end
|
|
desolation = math.max(0, desolation)
|
|
else
|
|
return 0
|
|
end
|
|
elseif squaresville.desolation == 0 then
|
|
return 1
|
|
end
|
|
|
|
return desolation
|
|
end
|
|
|
|
|
|
dofile(squaresville.path .. '/nodes.lua')
|
|
|
|
|
|
local ground_nodes = {}
|
|
ground_nodes[node['default:dirt']] = true
|
|
ground_nodes[node['default:stone']] = true
|
|
ground_nodes[node['default:dirt_with_grass']] = true
|
|
ground_nodes[node['default:dirt_with_snow']] = true
|
|
ground_nodes[node['squaresville:polluted_dirt']] = true
|
|
ground_nodes[node['squaresville:cracked_stone']] = true
|
|
ground_nodes[node['squaresville:granite']] = true
|
|
ground_nodes[node['squaresville:basalt']] = true
|
|
ground_nodes[node['squaresville:dirt_with_odd_grass']] = true
|
|
squaresville.ground_nodes = ground_nodes
|
|
|
|
|
|
if minetest.get_modpath('booty') then
|
|
booty.add_ground_node('squaresville:concrete')
|
|
booty.add_ground_node('squaresville:concrete_broken')
|
|
booty.add_ground_node('squaresville:sidewalk')
|
|
booty.add_ground_node('squaresville:sidewalk_broken')
|
|
booty.add_ground_node('squaresville:floor_ceiling')
|
|
booty.add_ground_node('squaresville:floor_ceiling_broken')
|
|
for i = 2, 5 do
|
|
booty.add_ground_node('squaresville:concrete'..i)
|
|
booty.add_ground_node('squaresville:concrete'..i..'_broken')
|
|
end
|
|
end
|
|
|
|
|
|
dofile(squaresville.path .. '/desolate.lua')
|
|
dofile(squaresville.path .. '/deco.lua')
|
|
dofile(squaresville.path .. '/schematics.lua')
|
|
dofile(squaresville.path .. '/mapgen.lua')
|
|
dofile(squaresville.path .. '/trans.lua')
|
|
dofile(squaresville.path .. "/chat.lua")
|
|
|
|
|
|
if squaresville.spawnplayer and squaresville.single_node then
|
|
minetest.register_on_newplayer(squaresville.spawnplayer)
|
|
minetest.register_on_respawnplayer(squaresville.spawnplayer)
|
|
end
|
|
|
|
|
|
minetest.register_on_shutdown(function()
|
|
print('time buildings: '..math.floor(1000 * squaresville.time_buildings / squaresville.chunks))
|
|
print('time caves: '..math.floor(1000 * squaresville.time_caves / squaresville.chunks))
|
|
print('time environ noise: '..math.floor(1000 * squaresville.time_env_noise / squaresville.chunks))
|
|
print('time moria: '..math.floor(1000 * squaresville.time_moria / squaresville.chunks))
|
|
print('time overhead: '..math.floor(1000 * squaresville.time_overhead / squaresville.chunks))
|
|
print('time schematics: '..math.floor(1000 * squaresville.time_schem / squaresville.chunks))
|
|
print('time terrain: '..math.floor(1000 * squaresville.time_terrain / squaresville.chunks))
|
|
print('time big trees: '..math.floor(1000 * squaresville.time_trees / squaresville.chunks))
|
|
print('time y loop: '..math.floor(1000 * squaresville.time_y_loop / squaresville.chunks))
|
|
print('time ziggurats: '..math.floor(1000 * squaresville.time_zigg / squaresville.chunks))
|
|
print('chunks: '..squaresville.chunks)
|
|
end)
|