mods/elidragon_plotmg/init.lua

   1 local plot, schems = elidragon.plot, elidragon.schems
   2
   3 local plotmg = {}
   4
   5 minetest.register_on_generated(function(minp, maxp)
   6         local config = assert(plot.config)
   7         local mgconfig = assert(plotmg.config)
   8
   9         local min_y, max_y = mgconfig.min_y, mgconfig.max_y
  10
  11         if maxp.y < min_y or minp.y > max_y then
  12                 return
  13         end
  14
  15         local vm, emin, emax = minetest.get_mapgen_object("voxelmanip")
  16         local data = vm:get_data()
  17         local area = VoxelArea:new({MinEdge = emin, MaxEdge = emax})
  18
  19         local void_layer = mgconfig.void_layer
  20
  21         if void_layer then
  22                 for idx in area:iter(minp.x, math.max(minp.y, void_layer.min_y), minp.z, maxp.x, math.min(maxp.y, void_layer.max_y), mapx.z) do
  23                         data[idx] = void_layer.c_void
  24                 end
  25         end
  26
  27         local function do_multiples(low, high, base, add, func)
  28                 for p = math.ceil(low / base), math.floor(high / base) do
  29                         func(p * base + add)
  30                 end
  31         end
  32
  33         local function do_borders(low, high, base, road, func)
  34                 do_multiples(low - road, high - road, base,  road, func)
  35                 do_multiples(low + road, high + road, base, -road, func)
  36         end
  37
  38         min_y, max_y = math.max(minp.y, min_y), math.min(maxp.y, max_y)
  39
  40         local gap, road_width = config.gap, config.road_width
  41         local road_width_half = road_width / 2
  42
  43         do_borders(minp.x, maxp.x, gap, road_width_half, function(x)
  44                 do_multiples(minp.z - gap + road_width_half, maxp.z - road_width_half, gap, road_width_half, function(start_z)
  45                         for idx in area:iter(x, min_y, math.max(minp.z, start_z), x, max_y, math.min(maxp.z, start_z + gap - road_width)) do
  46                                 data[idx] = mgconfig.c_border
  47                         end
  48                 end)
  49         end)
  50
  51         do_borders(minp.z, maxp.z, gap, road_width_half, function(z)
  52                 do_multiples(minp.x - gap + road_width_half, maxp.x - road_width_half, gap, road_width_half, function(start_x)
  53                         for idx in area:iter(math.max(minp.x, start_x), min_y, z, math.min(maxp.x, start_x + gap - road_width), max_y, z) do
  54                                 data[idx] = mgconfig.c_border
  55                         end
  56                 end)
  57         end)
  58
  59         vm:set_data(data)
  60         vm:calc_lighting()
  61         vm:update_liquids()
  62         vm:write_to_map()
  63
  64         local road_schem = mgconfig.road_schem
  65
  66         if road_schem and min_y == mgconfig.min_y then
  67                 do_multiples(minp.x, maxp.x, gap, 0, function(x)
  68                         do_multiples(minp.z, maxp.z, gap, 0, function(z)
  69                                 schems.add(vector.new(x + road_width_half, min_y + mgconfig.road_schem_offset, z - road_width_half + 1), road_schem)
  70                                 schems.add(vector.new(x - road_width_half + 1, min_y + mgconfig.road_schem_offset, z + road_width_half), road_schem .. "_flipped")
  71                         end)
  72                 end)
  73         end
  74 end)
  75
  76 elidragon.plotmg = plotmg