minetest-mod-squaresville/init.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)