X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;ds=inline;f=worldedit%2Fserialization.lua;h=ddc59cd388eb257f64b8aeac61093e359b577610;hb=324eb556f658b5c82c9043aeee37e7d41486bf23;hp=7b65b256e75957eda20e8c91327ede48f1a5b196;hpb=3c51ec8c4a347a6714472c423215243fc538f5f5;p=worldedit.git diff --git a/worldedit/serialization.lua b/worldedit/serialization.lua index 7b65b25..ddc59cd 100644 --- a/worldedit/serialization.lua +++ b/worldedit/serialization.lua @@ -1,48 +1,74 @@ -worldedit = worldedit or {} -local minetest = minetest --local copy of global - ---modifies positions `pos1` and `pos2` so that each component of `pos1` is less than or equal to its corresponding conent of `pos2`, returning two new positions -worldedit.sort_pos = function(pos1, pos2) - pos1 = {x=pos1.x, y=pos1.y, z=pos1.z} - pos2 = {x=pos2.x, y=pos2.y, z=pos2.z} - if pos1.x > pos2.x then - pos2.x, pos1.x = pos1.x, pos2.x - end - if pos1.y > pos2.y then - pos2.y, pos1.y = pos1.y, pos2.y +--- Schematic serialization and deserialiation. +-- @module worldedit.serialization + +worldedit.LATEST_SERIALIZATION_VERSION = 5 +local LATEST_SERIALIZATION_HEADER = worldedit.LATEST_SERIALIZATION_VERSION .. ":" + + +--[[ +Serialization version history: + 1: Original format. Serialized Lua table with a weird linked format... + 2: Position and node seperated into sub-tables in fields `1` and `2`. + 3: List of nodes, one per line, with fields seperated by spaces. + Format: + 4: Serialized Lua table containing a list of nodes with `x`, `y`, `z`, + `name`, `param1`, `param2`, and `meta` fields. + 5: Added header and made `param1`, `param2`, and `meta` fields optional. + Header format: ,,...: +--]] + + +--- Reads the header of serialized data. +-- @param value Serialized WorldEdit data. +-- @return The version as a positive natural number, or 0 for unknown versions. +-- @return Extra header fields as a list of strings, or nil if not supported. +-- @return Content (data after header). +function worldedit.read_header(value) + if value:find("^[0-9]+[%-:]") then + local header_end = value:find(":", 1, true) + local header = value:sub(1, header_end - 1):split(",") + local version = tonumber(header[1]) + table.remove(header, 1) + local content = value:sub(header_end + 1) + return version, header, content end - if pos1.z > pos2.z then - pos2.z, pos1.z = pos1.z, pos2.z - end - return pos1, pos2 -end - ---determines the version of serialized data `value`, returning the version as a positive integer or 0 for unknown versions -worldedit.valueversion = function(value) - if value:find("([+-]?%d+)%s+([+-]?%d+)%s+([+-]?%d+)") and not value:find("%{") then --previous list format - return 3 + -- Old versions that didn't include a header with a version number + if value:find("([+-]?%d+)%s+([+-]?%d+)%s+([+-]?%d+)") and not value:find("%{") then -- List format + return 3, nil, value elseif value:find("^[^\"']+%{%d+%}") then - if value:find("%[\"meta\"%]") then --previous meta flat table format - return 2 + if value:find("%[\"meta\"%]") then -- Meta flat table format + return 2, nil, value end - return 1 --original flat table format - elseif value:find("%{") then --current nested table format - return 4 + return 1, nil, value -- Flat table format + elseif value:find("%{") then -- Raw nested table format + return 4, nil, value end - return 0 --unknown format + return nil end ---converts the region defined by positions `pos1` and `pos2` into a single string, returning the serialized data and the number of nodes serialized -worldedit.serialize = function(pos1, pos2) - --make area stay loaded - local manip = minetest.get_voxel_manip() - manip:read_from_map(pos1, pos2) - local pos1, pos2 = worldedit.sort_pos(pos1, pos2) +--- Converts the region defined by positions `pos1` and `pos2` +-- into a single string. +-- @return The serialized data. +-- @return The number of nodes serialized. +function worldedit.serialize(pos1, pos2) + pos1, pos2 = worldedit.sort_pos(pos1, pos2) + + worldedit.keep_loaded(pos1, pos2) + + local get_node, get_meta, hash_node_position = + minetest.get_node, minetest.get_meta, minetest.hash_node_position + + -- Find the positions which have metadata + local has_meta = {} + local meta_positions = minetest.find_nodes_with_meta(pos1, pos2) + for i = 1, #meta_positions do + has_meta[hash_node_position(meta_positions[i])] = true + end + local pos = {x=pos1.x, y=0, z=0} local count = 0 local result = {} - local get_node, get_meta = minetest.get_node, minetest.get_meta while pos.x <= pos2.x do pos.y = pos1.y while pos.y <= pos2.y do @@ -51,12 +77,19 @@ worldedit.serialize = function(pos1, pos2) local node = get_node(pos) if node.name ~= "air" and node.name ~= "ignore" then count = count + 1 - local meta = get_meta(pos):to_table() - --convert metadata itemstacks to itemstrings - for name, inventory in pairs(meta.inventory) do - for index, stack in ipairs(inventory) do - inventory[index] = stack.to_string and stack:to_string() or stack + local meta + if has_meta[hash_node_position(pos)] then + meta = get_meta(pos):to_table() + + -- Convert metadata item stacks to item strings + for _, invlist in pairs(meta.inventory) do + for index = 1, #invlist do + local itemstack = invlist[index] + if itemstack.to_string then + invlist[index] = itemstack:to_string() + end + end end end @@ -65,8 +98,8 @@ worldedit.serialize = function(pos1, pos2) y = pos.y - pos1.y, z = pos.z - pos1.z, name = node.name, - param1 = node.param1, - param2 = node.param2, + param1 = node.param1 ~= 0 and node.param1 or nil, + param2 = node.param2 ~= 0 and node.param2 or nil, meta = meta, } end @@ -76,28 +109,24 @@ worldedit.serialize = function(pos1, pos2) end pos.x = pos.x + 1 end - result = minetest.serialize(result) --convert entries to a string - return result, count + -- Serialize entries + result = minetest.serialize(result) + return LATEST_SERIALIZATION_HEADER .. result, count end ---determines the volume the nodes represented by string `value` would occupy if deserialized at `originpos`, returning the two corner positions and the number of nodes ---contains code based on [table.save/table.load](http://lua-users.org/wiki/SaveTableToFile) by ChillCode, available under the MIT license (GPL compatible) -worldedit.allocate = function(originpos, value) - local huge = math.huge - local pos1x, pos1y, pos1z = huge, huge, huge - local pos2x, pos2y, pos2z = -huge, -huge, -huge - local originx, originy, originz = originpos.x, originpos.y, originpos.z - local count = 0 - local version = worldedit.valueversion(value) - if version == 1 or version == 2 then --flat table format - --obtain the node table - local get_tables = loadstring(value) - if get_tables then --error loading value - return originpos, originpos, count - end - local tables = get_tables() - --transform the node table into an array of nodes +--- Loads the schematic in `value` into a node list in the latest format. +-- Contains code based on [table.save/table.load](http://lua-users.org/wiki/SaveTableToFile) +-- by ChillCode, available under the MIT license. +-- @return A node list in the latest format, or nil on failure. +local function load_schematic(value) + local version, header, content = worldedit.read_header(value) + local nodes = {} + if version == 1 or version == 2 then -- Original flat table format + local tables = minetest.deserialize(content) + if not tables then return nil end + + -- Transform the node table into an array of nodes for i = 1, #tables do for j, v in pairs(tables[i]) do if type(v) == "table" then @@ -105,169 +134,115 @@ worldedit.allocate = function(originpos, value) end end end - local nodes = tables[1] + nodes = tables[1] - --check the node array - count = #nodes if version == 1 then --original flat table format - for index = 1, count do - local entry = nodes[index] + for i, entry in ipairs(nodes) do local pos = entry[1] - local x, y, z = originx - pos.x, originy - pos.y, originz - pos.z - if x < pos1x then pos1x = x end - if y < pos1y then pos1y = y end - if z < pos1z then pos1z = z end - if x > pos2x then pos2x = x end - if y > pos2y then pos2y = y end - if z > pos2z then pos2z = z end - end - else --previous meta flat table format - for index = 1, count do - local entry = nodes[index] - local x, y, z = originx - entry.x, originy - entry.y, originz - entry.z - if x < pos1x then pos1x = x end - if y < pos1y then pos1y = y end - if z < pos1z then pos1z = z end - if x > pos2x then pos2x = x end - if y > pos2y then pos2y = y end - if z > pos2z then pos2z = z end + entry.x, entry.y, entry.z = pos.x, pos.y, pos.z + entry[1] = nil + local node = entry[2] + entry.name, entry.param1, entry.param2 = node.name, node.param1, node.param2 + entry[2] = nil end end - elseif version == 3 then --previous list format - for x, y, z, name, param1, param2 in value:gmatch("([+-]?%d+)%s+([+-]?%d+)%s+([+-]?%d+)%s+([^%s]+)%s+(%d+)%s+(%d+)[^\r\n]*[\r\n]*") do --match node entries - x, y, z = originx + tonumber(x), originy + tonumber(y), originz + tonumber(z) - if x < pos1x then pos1x = x end - if y < pos1y then pos1y = y end - if z < pos1z then pos1z = z end - if x > pos2x then pos2x = x end - if y > pos2y then pos2y = y end - if z > pos2z then pos2z = z end - count = count + 1 + elseif version == 3 then -- List format + for x, y, z, name, param1, param2 in content:gmatch( + "([+-]?%d+)%s+([+-]?%d+)%s+([+-]?%d+)%s+" .. + "([^%s]+)%s+(%d+)%s+(%d+)[^\r\n]*[\r\n]*") do + param1, param2 = tonumber(param1), tonumber(param2) + table.insert(nodes, { + x = tonumber(x), + y = tonumber(y), + z = tonumber(z), + name = name, + param1 = param1 ~= 0 and param1 or nil, + param2 = param2 ~= 0 and param2 or nil, + }) end - elseif version == 4 then --current nested table format - --wip: this is a filthy hack that works surprisingly well - value = value:gsub("return%s*{", "", 1):gsub("}%s*$", "", 1) - local escaped = value:gsub("\\\\", "@@"):gsub("\\\"", "@@"):gsub("(\"[^\"]*\")", function(s) return string.rep("@", #s) end) - local startpos, startpos1, endpos = 1, 1 - local nodes = {} - while true do - startpos, endpos = escaped:find("},%s*{", startpos) - if not startpos then - break + elseif version == 4 or version == 5 then -- Nested table format + if not jit then + -- This is broken for larger tables in the current version of LuaJIT + nodes = minetest.deserialize(content) + else + -- XXX: This is a filthy hack that works surprisingly well - in LuaJIT, `minetest.deserialize` will fail due to the register limit + nodes = {} + content = content:gsub("return%s*{", "", 1):gsub("}%s*$", "", 1) -- remove the starting and ending values to leave only the node data + local escaped = content:gsub("\\\\", "@@"):gsub("\\\"", "@@"):gsub("(\"[^\"]*\")", function(s) return string.rep("@", #s) end) + local startpos, startpos1, endpos = 1, 1 + while true do -- go through each individual node entry (except the last) + startpos, endpos = escaped:find("},%s*{", startpos) + if not startpos then + break + end + local current = content:sub(startpos1, startpos) + local entry = minetest.deserialize("return " .. current) + table.insert(nodes, entry) + startpos, startpos1 = endpos, endpos end - local current = value:sub(startpos1, startpos) - table.insert(nodes, minetest.deserialize("return " .. current)) - startpos, startpos1 = endpos, endpos + local entry = minetest.deserialize("return " .. content:sub(startpos1)) -- process the last entry + table.insert(nodes, entry) end - table.insert(nodes, minetest.deserialize("return " .. value:sub(startpos1))) + else + return nil + end + return nodes +end - --local nodes = minetest.deserialize(value) --wip: this is broken for larger tables in the current version of LuaJIT +--- Determines the volume the nodes represented by string `value` would occupy +-- if deserialized at `origin_pos`. +-- @return Low corner position. +-- @return High corner position. +-- @return The number of nodes. +function worldedit.allocate(origin_pos, value) + local nodes = load_schematic(value) + if not nodes or #nodes == 0 then return nil end + return worldedit.allocate_with_nodes(origin_pos, nodes) +end - count = #nodes - for index = 1, count do - local entry = nodes[index] - x, y, z = originx + entry.x, originy + entry.y, originz + entry.z - if x < pos1x then pos1x = x end - if y < pos1y then pos1y = y end - if z < pos1z then pos1z = z end - if x > pos2x then pos2x = x end - if y > pos2y then pos2y = y end - if z > pos2z then pos2z = z end - end + +-- Internal +function worldedit.allocate_with_nodes(origin_pos, nodes) + local huge = math.huge + local pos1x, pos1y, pos1z = huge, huge, huge + local pos2x, pos2y, pos2z = -huge, -huge, -huge + local origin_x, origin_y, origin_z = origin_pos.x, origin_pos.y, origin_pos.z + for i, entry in ipairs(nodes) do + local x, y, z = origin_x + entry.x, origin_y + entry.y, origin_z + entry.z + if x < pos1x then pos1x = x end + if y < pos1y then pos1y = y end + if z < pos1z then pos1z = z end + if x > pos2x then pos2x = x end + if y > pos2y then pos2y = y end + if z > pos2z then pos2z = z end end local pos1 = {x=pos1x, y=pos1y, z=pos1z} local pos2 = {x=pos2x, y=pos2y, z=pos2z} - return pos1, pos2, count + return pos1, pos2, #nodes end ---loads the nodes represented by string `value` at position `originpos`, returning the number of nodes deserialized ---contains code based on [table.save/table.load](http://lua-users.org/wiki/SaveTableToFile) by ChillCode, available under the MIT license (GPL compatible) -worldedit.deserialize = function(originpos, value) - --make sure the area stays loaded --wip: not very performant - local pos1, pos2 = worldedit.allocate(originpos, value) - local manip = minetest.get_voxel_manip() - manip:read_from_map(pos1, pos2) - local originx, originy, originz = originpos.x, originpos.y, originpos.z - local count = 0 - local add_node, get_meta = minetest.add_node, minetest.get_meta - local version = worldedit.valueversion(value) - if version == 1 or version == 2 then --original flat table format - --obtain the node table - local get_tables = loadstring(value) - if not get_tables then --error loading value - return count - end - local tables = get_tables() +--- Loads the nodes represented by string `value` at position `origin_pos`. +-- @return The number of nodes deserialized. +function worldedit.deserialize(origin_pos, value) + local nodes = load_schematic(value) + if not nodes then return nil end + if #nodes == 0 then return #nodes end - --transform the node table into an array of nodes - for i = 1, #tables do - for j, v in pairs(tables[i]) do - if type(v) == "table" then - tables[i][j] = tables[v[1]] - end - end - end - local nodes = tables[1] + local pos1, pos2 = worldedit.allocate_with_nodes(origin_pos, nodes) + worldedit.keep_loaded(pos1, pos2) - --load the node array - count = #nodes - if version == 1 then --original flat table format - for index = 1, count do - local entry = nodes[index] - local pos = entry[1] - pos.x, pos.y, pos.z = originx - pos.x, originy - pos.y, originz - pos.z - add_node(pos, entry[2]) - end - else --previous meta flat table format - for index = 1, #nodes do - local entry = nodes[index] - entry.x, entry.y, entry.z = originx + entry.x, originy + entry.y, originz + entry.z - add_node(entry, entry) --entry acts both as position and as node - get_meta(entry):from_table(entry.meta) - end - end - elseif version == 3 then --previous list format - local pos = {x=0, y=0, z=0} - local node = {name="", param1=0, param2=0} - for x, y, z, name, param1, param2 in value:gmatch("([+-]?%d+)%s+([+-]?%d+)%s+([+-]?%d+)%s+([^%s]+)%s+(%d+)%s+(%d+)[^\r\n]*[\r\n]*") do --match node entries - pos.x, pos.y, pos.z = originx + tonumber(x), originy + tonumber(y), originz + tonumber(z) - node.name, node.param1, node.param2 = name, param1, param2 - add_node(pos, node) - count = count + 1 - end - elseif version == 4 then --current nested table format - --wip: this is a filthy hack that works surprisingly well - value = value:gsub("return%s*{", "", 1):gsub("}%s*$", "", 1) - local escaped = value:gsub("\\\\", "@@"):gsub("\\\"", "@@"):gsub("(\"[^\"]*\")", function(s) return string.rep("@", #s) end) - local startpos, startpos1, endpos = 1, 1 - local nodes = {} - while true do - startpos, endpos = escaped:find("},%s*{", startpos) - if not startpos then - break - end - local current = value:sub(startpos1, startpos) - table.insert(nodes, minetest.deserialize("return " .. current)) - startpos, startpos1 = endpos, endpos - end - table.insert(nodes, minetest.deserialize("return " .. value:sub(startpos1))) - - --local nodes = minetest.deserialize(value) --wip: this is broken for larger tables in the current version of LuaJIT - - --load the nodes - count = #nodes - for index = 1, count do - local entry = nodes[index] - entry.x, entry.y, entry.z = originx + entry.x, originy + entry.y, originz + entry.z - add_node(entry, entry) --entry acts both as position and as node - end - - --load the metadata - for index = 1, count do - local entry = nodes[index] + local origin_x, origin_y, origin_z = origin_pos.x, origin_pos.y, origin_pos.z + local count = 0 + local add_node, get_meta = minetest.add_node, minetest.get_meta + for i, entry in ipairs(nodes) do + entry.x, entry.y, entry.z = origin_x + entry.x, origin_y + entry.y, origin_z + entry.z + -- Entry acts as both position and node + add_node(entry, entry) + if entry.meta then get_meta(entry):from_table(entry.meta) end end - return count + return #nodes end +