skyblock.lua

   1 elidragon.skyblock = {}
   2
   3 --helper functions
   4
   5 -- http://rosettacode.org/wiki/Spiral_matrix#Lua
   6 av, sn = math.abs, function(s) return s~=0 and s/av(s) or 0 end
   7 local function sindex(y, x)
   8         if y == -x and y >= x then return (2*y+1)^2 end
   9         local l = math.max(av(y), av(x))
  10         return (2*l-1)^2+4*l+2*l*sn(x+y)+sn(y^2-x^2)*(l-(av(y)==l and sn(y)*x or sn(x)*y))
  11 end
  12 local function spiralt(side)
  13         local ret, id, start, stop = {}, 0, math.floor((-side+1)/2), math.floor((side-1)/2)
  14         for i = 1, side do
  15                 for j = 1, side do
  16                         local id = side^2 - sindex(stop - i + 1,start + j - 1)
  17                         ret[id] = {x=i,z=j}
  18                 end
  19         end
  20         return ret
  21 end
  22
  23 local function ripairs(t)
  24         local function ripairs_it(t,i)
  25                 i=i-1
  26                 local v=t[i]
  27                 if v==nil then return v end
  28                 return i,v
  29         end
  30         return ripairs_it, t, #t+1
  31 end
  32
  33 -- start positions
  34
  35 function elidragon.skyblock.load_legacy_start_positions()
  36         local file = io.open(minetest.get_worldpath() .. "/skyblock.start_positions", "r")
  37         if file then
  38                 local start_positions = {}
  39                 while true do
  40                         local x = file:read("*n")
  41                         if x == nil then
  42                                 break
  43                         end
  44                         local y = file:read("*n")
  45                         local z = file:read("*n")
  46                         table.insert(start_positions, {x = x, y = y, z = z})
  47                 end
  48                 file:close()
  49                 return start_positions
  50         end
  51 end
  52
  53 function elidragon.skyblock.generate_start_positions()
  54         local start_positions = {}
  55         for _, v in ripairs(spiralt(1000)) do
  56                 local pos = {x = v.x * 32, y = math.random(4 - 8, 4 + 8), z = v.z * 32}
  57                 table.insert(start_positions, pos)
  58         end
  59         return start_positions
  60 end
  61
  62 elidragon.start_positions = elidragon.skyblock.load_legacy_start_positions() or elidragon.skyblock.generate_start_positions()
  63
  64 function elidragon.skyblock.load_legacy_last_start_id()
  65         local file = io.open(minetest.get_worldpath() .. "/skyblock.last_start_id", "r")
  66         if file then
  67                 local last_start_id = tonumber(file:read())
  68                 file:close()
  69                 return last_start_id
  70         end
  71 end
  72
  73 elidragon.savedata.last_start_id = elidragon.savedata.last_start_id or elidragon.skyblock.load_legacy_last_start_id() or 0
  74
  75 -- spawns
  76
  77 function elidragon.skyblock.get_spawn(name)
  78         return elidragon.savedata.spawns[name]
  79 end
  80
  81 function elidragon.skyblock.set_spawn(name, pos)
  82         elidragon.savedata.spawns[name] = pos
  83 end
  84
  85 function elidragon.skyblock.spawn_player(player)
  86         local name = player:get_player_name()
  87         local spawn = elidragon.skyblock.get_spawn(name) or elidragon.skyblock.new_spawn(name)
  88         player:set_pos({x = spawn.x + 2, y = spawn.y + 2, z = spawn.z + 2})
  89 end
  90
  91 function elidragon.skyblock.new_spawn(name)
  92         elidragon.savedata.last_start_id = elidragon.savedata.last_start_id + 1
  93         local spawn = elidragon.start_positions[elidragon.savedata.last_start_id]
  94         elidragon.skyblock.set_spawn(name, spawn)
  95         local file = io.open(minetest.get_modpath("elidragon") .. "/schems/island.we", "r")
  96         local schem = file:read()
  97         file:close()
  98         worldedit.deserialize(vector.add(spawn, {x = -3, y = -4, z = -3}), schem)
  99         return spawn
 100 end
 101
 102 function elidragon.skyblock.load_legacy_spawns()
 103     local file = io.open(minetest.get_worldpath() .. "/skyblock.spawn", "r")
 104     if file then
 105                 local spawns = {}
 106         while true do
 107             local x = file:read("*n")
 108             if x == nil then
 109                 break
 110             end
 111             local y = file:read("*n")
 112             local z = file:read("*n")
 113             local name = file:read("*l")
 114             spawns[name:sub(2)] = {x = x, y = y, z = z}
 115         end
 116         file:close()
 117         return spawns
 118         end
 119 end
 120
 121 elidragon.savedata.spawns = elidragon.savedata.spawns or elidragon.skyblock.load_legacy_spawns() or {}
 122
 123
 124 -- level
 125 --[[
 126 minetest.register_chatcommand("level", {
 127         description = "Get/set the current level of a player",
 128         params = "<player> [<level>]",
 129         func = function(name, param)
 130                 local target = param:split(" ")[1]
 131                 local level = tonumber(param:split(" ")[2])
 132                 if not level then
 133                         minetest.chat_send_player(name, target .. " is on level " .. elidragon.skyblock.get_level(target))
 134                 elseif minetest.check_player_privs(name, {server = true}) and elidragon.skyblock.set_level(target, level) then
 135                         minetest.chat_send_player(name, target .. " has been set to level " .. level)
 136                 else
 137                         minetest.chat_send_player(name, "Cannot change " .. target .. " to level " .. level)
 138                 end
 139         end,
 140 })
 141 ]]--
 142
 143 -- node
 144
 145 minetest.register_node("elidragon:skyblock", {
 146         description = "Skyblock",
 147         tiles = {"elidragon_quest.png"},
 148         paramtype = "light",
 149         light_source = 14,
 150         groups = {crumbly=2,cracky=2},
 151 })
 152
 153 minetest.register_alias("skyblock:quest", "elidragon:skyblock")
 154
 155 -- mapgen
 156
 157 minetest.register_on_mapgen_init(function(mgparams)
 158         minetest.set_mapgen_params({mgname = "singlenode", water_level = -32000})
 159 end)
 160
 161 -- respawn
 162
 163 minetest.register_on_respawnplayer(function(player)
 164         elidragon.skyblock.spawn_player(player)
 165         return true
 166 end)
 167
 168 -- remove legacy cloud layer
 169
 170 minetest.register_abm({
 171         name = "Remove Cloud Layer",
 172         nodenames = {"default:cloud"},
 173         interval = 1,
 174         chance = 1,
 175         action = function(pos)
 176                 if pos.y == -10 then
 177                         minetest.set_node(pos, { name = "air"})
 178                 end
 179         end
 180 })
 181
 182 -- ores
 183
 184 minetest.after(0, function()
 185         default.cool_lava = function(pos, oldnode)
 186                 local node
 187                 if oldnode.name == "default:lava_source" then
 188                         node = "default:obsidian"
 189                 elseif math.random() < 0.001 then
 190                         node = "moreores:mineral_mithril"
 191                 elseif math.random() < 0.003 then
 192                         node = "default:stone_with_diamond"
 193                 elseif math.random() < 0.005 then
 194                         node = "default:stone_with_mese"
 195                 elseif math.random() < 0.01 then
 196                         node = "default:stone_with_gold"
 197                 elseif math.random() < 0.015 then
 198                         node = "default:stone_with_tin"
 199                 elseif math.random() < 0.02 then
 200                         node = "default:stone_with_copper"
 201                 elseif math.random() < 0.033 then
 202                         node = "default:stone_with_iron"
 203                 elseif math.random() < 0.04 then
 204                         node = "moreores:mineral_silver"
 205                 elseif math.random() < 0.05 then
 206                         node = "default:stone_with_coal"
 207                 else
 208                         node = "default:stone"
 209                 end
 210                 minetest.set_node(pos, {name = node})
 211                 minetest.sound_play("default_cool_lava", {pos = pos, max_hear_distance = 16, gain = 0.25}, true)
 212         end
 213 end)
 214
 215 -- saplings
 216
 217 minetest.after(0, function()
 218         minetest.register_alias("default:pine_leaves", "default:pine_needles")
 219         minetest.register_alias("default:pine_bush_leaves", "default:pine_bush_needles")
 220         local trees = {"default:", "default:jungle", "default:pine_", "default:acacia_", "default:aspen_", "default:bush_", "default:blueberry_bush_", "default:acacia_bush_", "default:pine_bush_",}
 221         for _, tree in pairs(trees) do
 222                 local items = {}
 223                 items[#items + 1] = {
 224                         items = {tree .. "sapling"},
 225                         rarity = 20,
 226                 }
 227                 for _, stree in pairs(trees) do
 228                         if stree ~= tree then
 229                                 items[#items + 1] = {
 230                                         items = {stree .. "sapling"},
 231                                         rarity = 250,
 232                                 }
 233                         end
 234                 end
 235                 items[#items + 1] = {
 236                         items = {tree .. "leaves"},
 237                 }
 238                 minetest.registered_nodes[tree .. "leaves"].drop = {max_items = 1, items = items}
 239         end
 240 end)
 241
 242 -- flowers
 243
 244 minetest.register_abm({
 245         nodenames = {"default:dirt_with_grass"},
 246         interval = 300,
 247         chance = 100,
 248         action = function(pos, node)
 249                 pos.y = pos.y + 1
 250                 local light = minetest.get_node_light(pos) or 0
 251                 if minetest.get_node(pos).name == "air" and light > 12 and not minetest.find_node_near(pos, 2, {"group:flora"}) then
 252                         local flowers = {"default:junglegrass", "default:grass_1", "flowers:dandelion_white", "flowers:dandelion_yellow", "flowers:geranium", "flowers:rose", "flowers:tulip", "flowers:tulip_black", "flowers:viola", "flowers:chrysanthemum_green"}
 253                         minetest.set_node(pos, {name = flowers[math.random(#flowers)]})
 254                 end
 255         end
 256 })
 257
 258 -- recipes
 259
 260 minetest.register_craft({
 261         output = "default:desert_sand",
 262         recipe = {
 263                 {"default:sand"},
 264                 {"default:gravel"},
 265         }
 266 })
 267
 268 minetest.register_craft({
 269         output = "default:desert_stone",
 270         recipe = {
 271                 {"default:desert_sand", "default:desert_sand"},
 272                 {"default:desert_sand", "default:desert_sand"},
 273         }
 274 })
 275
 276 minetest.register_craft({
 277         output = "default:sand 4",
 278         recipe = {
 279                 {"default:obsidian_shard"},
 280         }
 281 })
 282
 283 minetest.register_craft({
 284         output = "default:gravel 2",
 285         recipe = {
 286                 {"default:cobble"},
 287         }
 288 })
 289
 290 minetest.register_craft({
 291         output = "default:dirt 2",
 292         recipe = {
 293                 {"default:gravel"},
 294         }
 295 })
 296
 297 minetest.register_craft({
 298         output = "default:clay_lump 4",
 299         recipe = {
 300                 {"default:dirt"},
 301         }
 302 })
 303
 304 minetest.register_craft({
 305         output = "default:ice",
 306         recipe = {
 307                 {"bucket:bucket_water"},
 308         }
 309 })
 310
 311 minetest.register_craft({
 312         output = "default:snowblock 4",
 313         recipe = {
 314                 {"default:ice"},
 315         }
 316 })
 317
 318 minetest.register_craft({
 319         type = "cooking",
 320         output = "default:lava_source",
 321         recipe = "default:stone",
 322 })
 323
 324 minetest.register_craft({
 325         output = "default:silver_sand 9",
 326         recipe = {
 327                 {"default:sand", "default:sand", "default:sand"},
 328                 {"default:sand", "moreores:silver_lump", "default:sand"},
 329                 {"default:sand", "default:sand", "default:sand"},
 330         }
 331 })
 332
 333 -- commands
 334
 335 minetest.register_chatcommand("set_skyblock_spawn", {
 336     param = "<player> <x> <y> <z>",
 337     desc = "Change the skyblocks spawn of a player",
 338     privs = {server = true},
 339     func = function(admin, param)
 340         local name = param:split(" ")[1]
 341         local x = tonumber(param:split(" ")[2])
 342         local y = tonumber(param:split(" ")[3])
 343         local z = tonumber(param:split(" ")[4])
 344         if name and x and y and z then
 345             elidragon.skyblock.set_spawn(name, {x = x, y = y, z = z})
 346         else
 347             minetest.chat_send_player(admin, "Invalid usage.")
 348         end
 349     end
 350 })
 351
 352 minetest.register_chatcommand("island", {
 353         params = "",
 354         description = "Teleport to your Island",
 355         func = function(name, param)
 356                 elidragon.skyblock.spawn_player(minetest.get_player_by_name(name))
 357         end,
 358 })