moremesecons = {} function moremesecons.setting(modname, settingname, default, min) local setting = "moremesecons_" .. modname .. "." .. settingname if type(default) == "boolean" then local ret = minetest.settings:get_bool(setting) if ret == nil then ret = default end return ret elseif type(default) == "string" then return minetest.settings:get(setting) or default elseif type(default) == "number" then local ret = tonumber(minetest.settings:get(setting)) or default if not ret then minetest.log("warning", "[moremesecons_"..modname.."]: setting '"..setting.."' must be a number. Set to default value ("..tostring(default)..").") ret = default elseif ret ~= ret then -- NaN minetest.log("warning", "[moremesecons_"..modname.."]: setting '"..setting.."' is NaN. Set to default value ("..tostring(default)..").") ret = default end if min and ret < min then minetest.log("warning", "[moremesecons_"..modname.."]: setting '"..setting.."' is under minimum value "..tostring(min)..". Set to minimum value ("..tostring(min)..").") ret = min end return ret end end -- Storage helpers function moremesecons.get_storage_data(storage, name) return { tab = minetest.deserialize(storage:get_string(name)) or {}, name = name, storage = storage } end function moremesecons.set_data_to_pos(sto, pos, data) sto.tab[minetest.hash_node_position(pos)] = data sto.storage:set_string(sto.name, minetest.serialize(sto.tab)) end function moremesecons.get_data_from_pos(sto, pos) return sto.tab[minetest.hash_node_position(pos)] end function moremesecons.remove_data_from_pos(sto, pos) sto.tab[minetest.hash_node_position(pos)] = nil sto.storage:set_string(sto.name, minetest.serialize(sto.tab)) end -- Some additional vector helpers -- The same as minetest.hash_node_position; I copied it to ensure backwards -- compatibility and used hexadecimal number notation local function node_position_key(pos) return (pos.z + 0x8000) * 0x10000 * 0x10000 + (pos.y + 0x8000) * 0x10000 + pos.x + 0x8000 end local MapDataStorage = {} setmetatable(MapDataStorage, {__call = function() local obj = {} setmetatable(obj, MapDataStorage) return obj end}) MapDataStorage.__index = { getAt = function(self, pos) return self[node_position_key(pos)] end, setAt = function(self, pos, data) -- If x, y or z is omitted, the key corresponds to a position outside -- of the map (hopefully), so it can be used to skip lines and planes local vi_z = (pos.z + 0x8000) * 0x10000 * 0x10000 local vi_zy = vi_z + (pos.y + 0x8000) * 0x10000 local vi = vi_zy + pos.x + 0x8000 local is_new = self[vi] == nil self[vi] = data if is_new then self[vi_z] = (self[vi_z] or 0) + 1 self[vi_zy] = (self[vi_zy] or 0) + 1 end end, setAtI = function(self, vi, data) local vi_zy = vi - vi % 0x10000 local vi_z = vi - vi % (0x10000 * 0x10000) local is_new = self[vi] == nil self[vi] = data if is_new then self[vi_z] = (self[vi_z] or 0) + 1 self[vi_zy] = (self[vi_zy] or 0) + 1 end end, removeAt = function(self, pos) local vi_z = (pos.z + 0x8000) * 0x10000 * 0x10000 local vi_zy = vi_z + (pos.y + 0x8000) * 0x10000 local vi = vi_zy + pos.x + 0x8000 if self[vi] == nil then -- Nothing to remove return end self[vi] = nil -- Update existence information for the xy plane and x line self[vi_z] = self[vi_z] - 1 if self[vi_z] == 0 then self[vi_z] = nil self[vi_zy] = nil return end self[vi_zy] = self[vi_zy] - 1 if self[vi_zy] == 0 then self[vi_zy] = nil end end, iter = function(self, pos1, pos2) local ystride = 0x10000 local zstride = 0x10000 * 0x10000 -- Skip z values where no data can be found pos1 = vector.new(pos1) local vi_z = (pos1.z + 0x8000) * 0x10000 * 0x10000 while not self[vi_z] do pos1.z = pos1.z + 1 vi_z = vi_z + zstride if pos1.z > pos2.z then -- There are no values to iterate through return function() return end end end -- Skipping y values is not yet implemented and may require much code local xrange = pos2.x - pos1.x + 1 local yrange = pos2.y - pos1.y + 1 local zrange = pos2.z - pos1.z + 1 -- x-only and y-only parts of the vector index of pos1 local vi_y = (pos1.y + 0x8000) * 0x10000 local vi_x = pos1.x + 0x8000 local y = 0 local z = 0 local vi = node_position_key(pos1) local pos = vector.new(pos1) local nextaction = vi + xrange pos.x = pos.x - 1 vi = vi - 1 local function iterfunc() -- continue along x until it needs to jump vi = vi + 1 pos.x = pos.x + 1 if vi ~= nextaction then local v = self[vi] if v == nil then -- No data here return iterfunc() end -- The returned position must not be changed return pos, v end -- Reset x position vi = vi - xrange -- Go along y until pos2.y is exceeded while true do y = y + 1 pos.y = pos.y + 1 -- Set vi to index(pos1.x, pos1.y + y, pos1.z + z) vi = vi + ystride if y == yrange then break end if self[vi - vi_x] then nextaction = vi + xrange vi = vi - 1 pos.x = pos1.x - 1 return iterfunc() end -- Nothing along this x line, so increase y again end -- Go back along y vi = vi - yrange * ystride y = 0 pos.y = pos1.y -- Go along z until pos2.z is exceeded while true do z = z + 1 pos.z = pos.z + 1 vi = vi + zstride if z == zrange then -- Cuboid finished, return nil return end if self[vi - vi_x - vi_y] then y = 0 nextaction = vi + xrange vi = vi - 1 pos.x = pos1.x - 1 return iterfunc() end -- Nothing in this xy plane, so increase z again end end return iterfunc end, iterAll = function(self) local previous_vi = nil local function iterfunc() local vi, v = next(self, previous_vi) previous_vi = vi if not vi then return end local z = math.floor(vi / (0x10000 * 0x10000)) vi = vi - z * 0x10000 * 0x10000 local y = math.floor(vi / 0x10000) if y == 0 or z == 0 then -- The index does not refer to a position inside the map return iterfunc() end local x = vi - y * 0x10000 - 0x8000 y = y - 0x8000 z = z - 0x8000 return {x=x, y=y, z=z}, v end return iterfunc end, serialize = function(self) local indices = {} local values = {} local i = 1 for pos, v in self:iterAll() do local vi = node_position_key(pos) -- Convert the double reversible to a string; -- minetest.serialize does not (yet) do this indices[i] = ("%.17g"):format(vi) values[i] = v end return minetest.serialize({ version = "MapDataStorage_v1", indices = "return {" .. table.concat(indices, ",") .. "}", values = minetest.serialize(values), }) end, } MapDataStorage.deserialize = function(txtdata) local data = minetest.deserialize(txtdata) if data.version ~= "MapDataStorage_v1" then minetest.log("error", "Unknown MapDataStorage version: " .. data.version) end -- I assume that minetest.deserialize correctly deserializes the indices, -- which are in the %a format local indices = minetest.deserialize(data.indices) local values = minetest.deserialize(data.values) if not indices or not values then return MapDataStorage() end data = MapDataStorage() for i = 1,#indices do local vi = indices[i] local v = values[i] data:setAtI(vi, v) end return data end moremesecons.MapDataStorage = MapDataStorage -- Legacy -- vector_extras there: https://github.com/HybridDog/vector_extras -- Creates a MapDataStorage object from old vector_extras generated table function moremesecons.load_old_data_from_pos(t) local data = MapDataStorage() for z, yxv in pairs(t) do for y, xv in pairs(yxv) do for x, v in pairs(xv) do data:setAt({x=x, y=y, z=z}, v) end end end return data end function moremesecons.load_old_dfp_storage(modstorage, name) local data = minetest.deserialize(modstorage:get_string(name)) if not data then return end return moremesecons.load_old_data_from_pos(data) end function moremesecons.load_MapDataStorage_legacy(modstorage, name, oldname) local t_old = moremesecons.load_old_dfp_storage(modstorage, oldname) local t if t_old and t_old ~= "" then t = t_old modstorage:set_string(name, t:serialize()) modstorage:set_string(oldname, nil) return t end t = modstorage:get_string(name) if t and t ~= "" then return MapDataStorage.deserialize(t) end return MapDataStorage() end --[[ -- This testing code shows an example usage of the MapDataStorage code local function do_test() print("Test if iter returns correct positions when a lot is set") local data = MapDataStorage() local k = 0 for x = -5, 3 do for y = -5, 3 do for z = -5, 3 do k = k + 1 data:setAt({x=x, y=y, z=z}, k) end end end local expected_positions = {} for z = -4, 2 do for y = -4, 2 do for x = -4, 2 do expected_positions[#expected_positions+1] = {x=x, y=y, z=z} end end end local i = 0 for pos in data:iter({x=-4, y=-4, z=-4}, {x=2, y=2, z=2}) do i = i + 1 assert(vector.equals(pos, expected_positions[i])) end print("Test if iter works correctly on a corner") local found = false for pos in data:iter({x=-8, y=-7, z=-80}, {x=-5, y=-5, z=-5}) do assert(not found) found = true assert(vector.equals(pos, {x=-5, y=-5, z=-5})) end assert(found) print("Test if iter finds all corners") local expected_positions = {} local k = 1 for _, z in ipairs({-9, -6}) do for _, y in ipairs({-9, -6}) do for _, x in ipairs({-8, -6}) do local pos = {x=x, y=y, z=z} expected_positions[#expected_positions+1] = pos data:setAt(pos, k) k = k + 1 end end end local i = 1 for pos, v in data:iter({x=-8, y=-9, z=-9}, {x=-6, y=-6, z=-6}) do assert(v == i) assert(vector.equals(pos, expected_positions[i])) i = i + 1 --~ print("found " .. minetest.pos_to_string(pos)) end assert(i == 8 + 1, "Not enough or too many corners found") --~ data:iterAll() end do_test() --]]