nodecore-skyblock/nc_sky_isgen/init.lua

--nothing--
local grass = "nc_terrain:dirt_with_grass"
local dirt = "nc_terrain:dirt"
local tree = "nc_tree:eggcorn_planted"
local stone = "nc_terrain:stone"
local queue = {}

local function maxval(octaves,persistence,scale)
  local m = scale
  local poc = scale
  if octaves > 1 then
    for n=2,octaves do
      poc = poc*persistence
      m=m+poc
    end
  end
  return m
end

local function island(pos,r)
  local x,y,z = pos.x,pos.y,pos.z
  minetest.emerge_area({x=x-r,y=y-r,z=z-r},{x=x+r,y=y+r,z=z+r},function(bp,act,crem)
    if crem > 0 then
      return
    end
    local n = 0
    local c = 0
    local cm = (r*2+1)^3
    local function geto(x,y,z)
      local dist = (x*x+y*y+z*z)^0.5
      local uvdist = (y+r)/(r*2)
      local hdist = (x*x+z*z)^0.5
      local uhdist = (math.max(0,r-hdist)/r)^((1-uvdist)^3*5)
      local udist = math.max(0,r-dist)/r
      local m = ((math.max(r-(hdist),0)/r)^0.1*(uhdist^2))-uhdist*uvdist^3
      return m
    end
    local grasses = {}
    for x=-r,r do
      for z=-r,r do
        for y=-r,r do
          local xx,yy,zz = pos.x+x,pos.y+y,pos.z+z
          local o,o2 = geto(x,y,z),geto(x,y+1,z)
          local oc = (o > 0.4)
          local oc2 = o2 > 0.4
          local og = (o > 0.6)
          if oc then
            n=n+1
            local nam = dirt
            if not og and not oc2 then
              nam = grass
              table.insert(grasses,{x=xx,y=yy,z=zz})
            end
            if og then
              nam = stone
            end
            minetest.set_node({x=xx,y=yy,z=zz},{name=nam})
          else
            n=n+0.01
          end
          if n > 1000 then
            n=0
            --coroutine.yield()
          end
        end
      end
    end
    for n=1,4 do
      if #grasses > 1 then
        local n = math.random(1,#grasses)
        local v = table.remove(grasses,n)
        minetest.set_node(v,{name=tree})
        local meta = minetest.get_meta(v)
        meta:set_float("growth",5000)
      end
    end
  end)
end
local f,abs = math.floor, math.abs
local function spawn_island(name,pos)
  local ref = minetest.get_player_by_name(name)
  pos = {x=f(pos.x),y=f(pos.y),z=f(pos.z)}
  island(pos,16,name)
  ref:set_pos({x=pos.x,y=pos.y+256,z=pos.z})
end
local store = minetest.get_mod_storage()
local players = minetest.deserialize(store:get_string("players")) or {}
local cells = minetest.deserialize(store:get_string("cells")) or {}
local function save() 
  store:set_string("players",minetest.serialize(players))
  store:set_string("cells",minetest.serialize(cells))
end
local function pid(x,z)
  return "i"..x.."_"..z
end
local function checkpos(x,z)
  local cell = cells[pid(x,z)]
  local v = true
  if cell then
    v = cell.valid
  else
    v = store:get_string(pid(x,z)) == ""
  end
  return v
end
minetest.override_item("ignore",{
  drawtype = "normal",
  tiles={"nc_terrain_lava.png","nc_terrain_lava.png","nc_terrain_lava.png","nc_terrain_lava.png","nc_terrain_lava.png","nc_terrain_lava.png"},
  walkable=true,
  pointable=true
})
local function gen_island_pos(name)
  local x,z = 0,0
  local ok = checkpos(x,z)
  while not ok do
    x,z = x+math.random(-1,1),z+math.random(-1,1)
    ok = checkpos(x,z)
  end
  local range,ip
  local ocell = cells[pid(x,z)]
  if ocell and ocell.valid then
    range = ocell.islandrange
    ip = ocell.islandpos
    if players[ocell.name] and players[ocell.name].island == pid(x,z) then
      players[ocell.name] = nil
    end
    local ref = minetest.get_player_by_name(name)
    local pos = ip
    pos = {x=f(pos.x),y=f(pos.y),z=f(pos.z)}
    ref:set_pos({x=pos.x,y=pos.y+256,z=pos.z})
  else
    range = {min={x=x*128-64,y=256-64,z=z*128-64},max={x=x*128+64,y=256+64,z=z*128+64}}
    ip = {x=x*128+math.random(-32,32),y=256+math.random(-32,32),z=z*128+math.random(-32,32)}
    spawn_island(name,ip)
  end
  local pl = {
    island = pid(x,z),
    islandpos = ip,
    islandrange = range,
    name = name
  }
  players[name] = pl
  cells[pid(x,z)] = pl
  save()
end
local updrate = 0.5
local to_upd = updrate
minetest.register_globalstep(function(dt)
  for f,_ in pairs(queue) do
    local ok,err = coroutine.resume(f)
    if not ok then
      print(err)
      queue[f]=nil
    end
  end
  to_upd = to_upd-dt
  if to_upd <= 0 then
    to_upd = to_upd+updrate
    for k,ref in pairs(minetest.get_connected_players()) do
      local p = ref:get_pos()
      if p.y < 0 then
        ref:set_hp(ref:get_hp()-2,{reason="set_hp"})
        if p.y < -128 then
          local meta = ref:get_meta()
          local pos = minetest.string_to_pos(meta:get_string("islandpos"))
          if pos then
            pos.y=pos.y+256
            ref:set_pos(pos)
          end
        end
      end
    end
  end
end)

local function get_standing_island(name)
  local ref = minetest.get_player_by_name(name)
  local pos = ref:get_pos()
  local x = math.floor(pos.x/128+.5)
  local z = math.floor(pos.z/128+.5)
  return pid(x,z)
end

minetest.register_chatcommand("assign", {
  description = "Reassign this island",
  privs = {server = true},
  func = function(name,param)
    local is = get_standing_island(name)
    if not minetest.get_player_by_name(param) then
      minetest.chat_send_player(name,"No player "..param)
      return
    end
    players[param] = nil
    if not cells[is] then
      minetest.chat_send_player(name,"No island here")
      return
    end
    if not cells[is] then
      range = {min={x=x*128-64,y=256-64,z=z*128-64},max={x=x*128+64,y=256+64,z=z*128+64}}
      ip = {x=x*128+math.random(-32,32),y=256+math.random(-32,32),z=z*128+math.random(-32,32)}
      spawn_island(param,ip)
    else
      cells[is].name = param
    end
    minetest.chat_send_player(name,"OK")
    save()
  end
})

minetest.register_chatcommand("unassign", {
  description = "Unassign this island",
  privs = {server = true},
  func = function(name,param)
    local is = get_standing_island(name)
    if not cells[is] then
      minetest.chat_send_player(name,"This cell is not assigned")
      return
    end
    local nam = cells[is].name
    players[nam] = nil
    cells[is].name = ""
    store:set_string(is,"")
    minetest.chat_send_player(name,"OK")
    save()
  end
})

minetest.register_chatcommand("validate", {
  description = "Make this island avaible for newcomers",
  privs = {server = true},
  func = function(name,param)
    local is = get_standing_island(name)
    if cells[is] then
      cells[is].valid = true
      minetest.chat_send_player(name,"OK")
    else
      minetest.chat_send_player(name,"No island here")
      return
    end
    save()
  end
})

minetest.register_chatcommand("invalidate", {
  description = "Make this island unavaible for newcomers",
  privs = {server = true},
  func = function(name,param)
    local is = get_standing_island(name)
    if cells[is] then
      cells[is].valid = false
    else
      minetest.chat_send_player(name,"No island here")
      return
    end
    save()
  end
})

minetest.register_chatcommand("query", {
  description = "Query information about this island",
  func = function(name,param)
    local is = get_standing_island(name)
    if cells[is] then
      minetest.chat_send_player(name,is..": [")
      minetest.chat_send_player(name,"  owner: "..((cells[is].name == "" and "(none)" or cells[is].name) or "(none)"))
      minetest.chat_send_player(name,"  takeable: "..tostring(cells[is].valid))
      minetest.chat_send_player(name,"  pos: "..minetest.pos_to_string(cells[is].islandpos))
      minetest.chat_send_player(name,"  range: "..minetest.serialize(cells[is].islandrange))
      minetest.chat_send_player(name,"]")
    else
      minetest.chat_send_player(name,is..": No island here")
    end
    save()
  end
})

minetest.register_chatcommand("reset",{
  description = "Get a new island",
  privs = {interact = true},
  func = function(name)
    local pl = players[name]
    if pl then
      store:set_string(pl.island,"")
      pl.name = nil
      pl.valid = false
    end
    gen_island_pos(name)
  end
})

minetest.register_on_joinplayer(function(ref)
  local meta = ref:get_meta()
  local name = ref:get_player_name()
  if meta:get_string("island") ~= "" then
    if not cells[meta:get_string("island")] then
      local pl = {
        island = meta:get_string("island"),
        islandpos = minetest.string_to_pos(meta:get_string("islandpos")),
        islandrange = minetest.deserialize(meta:get_string("islandrange")),
        name = name
      }
      players[name] = pl
      cells[meta:get_string("island")] = pl
    else
      gen_island_pos(name)
    end
    save()
    meta:set_string("island","")
    meta:set_string("islandpos","")
    meta:set_string("islandrange","")
  else
    if not players[name] then
      gen_island_pos(name)
    else
      local p = players[name]
      local c = cells[p.island]
      if c.name ~= p.name then
        gen_island_pos(name)
      end
    end
  end
end)