worldedit/serialization.lua

   1 worldedit = worldedit or {}\r
   2 local minetest = minetest -- Local copy of global\r
   3 \r
   4 worldedit.LATEST_SERIALIZATION_VERSION = 5\r
   5 local LATEST_SERIALIZATION_HEADER = worldedit.LATEST_SERIALIZATION_VERSION .. ":"\r
   6 \r
   7 \r
   8 --[[\r
   9 Serialization version history:\r
  10   1: Original format.  Serialized Lua table with a weird linked format...\r
  11   2: Position and node seperated into sub-tables in fields `1` and `2`.\r
  12   3: List of nodes, one per line, with fields seperated by spaces.\r
  13       Format: <X> <Y> <Z> <Name> <Param1> <Param2>\r
  14   4: Serialized Lua table containing a list of nodes with `x`, `y`, `z`,\r
  15       `name`, `param1`, `param2`, and `meta` fields.\r
  16   5: Added header and made `param1`, `param2`, and `meta` fields optional.\r
  17       Header format: <Version>,<ExtraHeaderField1>,...:<Content>\r
  18 --]]\r
  19 \r
  20 \r
  21 --- Reads the header of serialized data.\r
  22 -- @param value Serialized WorldEdit data.\r
  23 -- @return The version as a positive natural number, or 0 for unknown versions.\r
  24 -- @return Extra header fields as a list of strings, or nil if not supported.\r
  25 -- @return Content (data after header).\r
  26 function worldedit.read_header(value)\r
  27         if value:find("^[0-9]+[%-:]") then\r
  28                 local header_end = value:find(":", 1, true)\r
  29                 local header = value:sub(1, header_end - 1):split(",")\r
  30                 local version = tonumber(header[1])\r
  31                 table.remove(header, 1)\r
  32                 local content = value:sub(header_end + 1)\r
  33                 return version, header, content\r
  34         end\r
  35         -- Old versions that didn't include a header with a version number\r
  36         if value:find("([+-]?%d+)%s+([+-]?%d+)%s+([+-]?%d+)") and not value:find("%{") then -- List format\r
  37                 return 3, nil, value\r
  38         elseif value:find("^[^\"']+%{%d+%}") then\r
  39                 if value:find("%[\"meta\"%]") then -- Meta flat table format\r
  40                         return 2, nil, value\r
  41                 end\r
  42                 return 1, nil, value -- Flat table format\r
  43         elseif value:find("%{") then -- Raw nested table format\r
  44                 return 4, nil, value\r
  45         end\r
  46         return nil\r
  47 end\r
  48 \r
  49 \r
  50 --- Converts the region defined by positions `pos1` and `pos2`\r
  51 -- into a single string.\r
  52 -- @return The serialized data.\r
  53 -- @return The number of nodes serialized.\r
  54 function worldedit.serialize(pos1, pos2)\r
  55         -- Keep area loaded\r
  56         local manip = minetest.get_voxel_manip()\r
  57         manip:read_from_map(pos1, pos2)\r
  58 \r
  59         local pos1, pos2 = worldedit.sort_pos(pos1, pos2)\r
  60         local pos = {x=pos1.x, y=0, z=0}\r
  61         local count = 0\r
  62         local result = {}\r
  63         local get_node, get_meta = minetest.get_node, minetest.get_meta\r
  64         while pos.x <= pos2.x do\r
  65                 pos.y = pos1.y\r
  66                 while pos.y <= pos2.y do\r
  67                         pos.z = pos1.z\r
  68                         while pos.z <= pos2.z do\r
  69                                 local node = get_node(pos)\r
  70                                 if node.name ~= "air" and node.name ~= "ignore" then\r
  71                                         count = count + 1\r
  72                                         local meta = get_meta(pos):to_table()\r
  73 \r
  74                                         local meta_empty = true\r
  75                                         -- Convert metadata item stacks to item strings\r
  76                                         for name, inventory in pairs(meta.inventory) do\r
  77                                                 for index, stack in ipairs(inventory) do\r
  78                                                         meta_empty = false\r
  79                                                         inventory[index] = stack.to_string and stack:to_string() or stack\r
  80                                                 end\r
  81                                         end\r
  82                                         for k in pairs(meta) do\r
  83                                                 if k ~= "inventory" then\r
  84                                                         meta_empty = false\r
  85                                                         break\r
  86                                                 end\r
  87                                         end\r
  88 \r
  89                                         result[count] = {\r
  90                                                 x = pos.x - pos1.x,\r
  91                                                 y = pos.y - pos1.y,\r
  92                                                 z = pos.z - pos1.z,\r
  93                                                 name = node.name,\r
  94                                                 param1 = node.param1 ~= 0 and node.param1 or nil,\r
  95                                                 param2 = node.param2 ~= 0 and node.param2 or nil,\r
  96                                                 meta = not meta_empty and meta or nil,\r
  97                                         }\r
  98                                 end\r
  99                                 pos.z = pos.z + 1\r
 100                         end\r
 101                         pos.y = pos.y + 1\r
 102                 end\r
 103                 pos.x = pos.x + 1\r
 104         end\r
 105         -- Serialize entries\r
 106         result = minetest.serialize(result)\r
 107         return LATEST_SERIALIZATION_HEADER .. result, count\r
 108 end\r
 109 \r
 110 \r
 111 --- Loads the schematic in `value` into a node list in the latest format.\r
 112 -- Contains code based on [table.save/table.load](http://lua-users.org/wiki/SaveTableToFile)\r
 113 -- by ChillCode, available under the MIT license.\r
 114 -- @return A node list in the latest format, or nil on failure.\r
 115 function worldedit.load_schematic(value)\r
 116         local version, header, content = worldedit.read_header(value)\r
 117         local nodes = {}\r
 118         if version == 1 or version == 2 then -- Original flat table format\r
 119                 local tables = minetest.deserialize(content)\r
 120                 if not tables then return nil end\r
 121 \r
 122                 -- Transform the node table into an array of nodes\r
 123                 for i = 1, #tables do\r
 124                         for j, v in pairs(tables[i]) do\r
 125                                 if type(v) == "table" then\r
 126                                         tables[i][j] = tables[v[1]]\r
 127                                 end\r
 128                         end\r
 129                 end\r
 130                 nodes = tables[1]\r
 131 \r
 132                 if version == 1 then --original flat table format\r
 133                         for i, entry in ipairs(nodes) do\r
 134                                 local pos = entry[1]\r
 135                                 entry.x, entry.y, entry.z = pos.x, pos.y, pos.z\r
 136                                 entry[1] = nil\r
 137                                 local node = entry[2]\r
 138                                 entry.name, entry.param1, entry.param2 = node.name, node.param1, node.param2\r
 139                                 entry[2] = nil\r
 140                         end\r
 141                 end\r
 142         elseif version == 3 then -- List format\r
 143                 for x, y, z, name, param1, param2 in content:gmatch(\r
 144                                 "([+-]?%d+)%s+([+-]?%d+)%s+([+-]?%d+)%s+" ..\r
 145                                 "([^%s]+)%s+(%d+)%s+(%d+)[^\r\n]*[\r\n]*") do\r
 146                         param1, param2 = tonumber(param1), tonumber(param2)\r
 147                         table.insert(nodes, {\r
 148                                 x = originx + tonumber(x),\r
 149                                 y = originy + tonumber(y),\r
 150                                 z = originz + tonumber(z),\r
 151                                 name = name,\r
 152                                 param1 = param1 ~= 0 and param1 or nil,\r
 153                                 param2 = param2 ~= 0 and param2 or nil,\r
 154                         })\r
 155                 end\r
 156         elseif version == 4 or version == 5 then -- Nested table format\r
 157                 if not jit then\r
 158                         -- This is broken for larger tables in the current version of LuaJIT\r
 159                         nodes = minetest.deserialize(content)\r
 160                 else\r
 161                         -- XXX: This is a filthy hack that works surprisingly well\r
 162                         nodes = {}\r
 163                         value = value:gsub("return%s*{", "", 1):gsub("}%s*$", "", 1)\r
 164                         local escaped = value:gsub("\\\\", "@@"):gsub("\\\"", "@@"):gsub("(\"[^\"]*\")", function(s) return string.rep("@", #s) end)\r
 165                         local startpos, startpos1, endpos = 1, 1\r
 166                         while true do\r
 167                                 startpos, endpos = escaped:find("},%s*{", startpos)\r
 168                                 if not startpos then\r
 169                                         break\r
 170                                 end\r
 171                                 local current = value:sub(startpos1, startpos)\r
 172                                 table.insert(nodes, minetest.deserialize("return " .. current))\r
 173                                 startpos, startpos1 = endpos, endpos\r
 174                         end\r
 175                         table.insert(nodes, minetest.deserialize("return " .. value:sub(startpos1)))\r
 176                 end\r
 177         else\r
 178                 return nil\r
 179         end\r
 180         return nodes\r
 181 end\r
 182 \r
 183 --- Determines the volume the nodes represented by string `value` would occupy\r
 184 -- if deserialized at `origin_pos`.\r
 185 -- @return Low corner position.\r
 186 -- @return High corner position.\r
 187 -- @return The number of nodes.\r
 188 worldedit.allocate = function(origin_pos, value)\r
 189         local nodes = worldedit.load_schematic(value)\r
 190         if not nodes then return nil end\r
 191         return worldedit.allocate_with_nodes(origin_pos, nodes)\r
 192 end\r
 193 \r
 194 \r
 195 -- Internal\r
 196 worldedit.allocate_with_nodes = function(origin_pos, nodes)\r
 197         local huge = math.huge\r
 198         local pos1x, pos1y, pos1z = huge, huge, huge\r
 199         local pos2x, pos2y, pos2z = -huge, -huge, -huge\r
 200         local origin_x, origin_y, origin_z = origin_pos.x, origin_pos.y, origin_pos.z\r
 201         for i, entry in ipairs(nodes) do\r
 202                 local x, y, z = origin_x + entry.x, origin_y + entry.y, origin_z + entry.z\r
 203                 if x < pos1x then pos1x = x end\r
 204                 if y < pos1y then pos1y = y end\r
 205                 if z < pos1z then pos1z = z end\r
 206                 if x > pos2x then pos2x = x end\r
 207                 if y > pos2y then pos2y = y end\r
 208                 if z > pos2z then pos2z = z end\r
 209         end\r
 210         local pos1 = {x=pos1x, y=pos1y, z=pos1z}\r
 211         local pos2 = {x=pos2x, y=pos2y, z=pos2z}\r
 212         return pos1, pos2, #nodes\r
 213 end\r
 214 \r
 215 \r
 216 --- Loads the nodes represented by string `value` at position `origin_pos`.\r
 217 -- @return The number of nodes deserialized.\r
 218 worldedit.deserialize = function(origin_pos, value)\r
 219         local nodes = worldedit.load_schematic(value)\r
 220         if not nodes then return nil end\r
 221 \r
 222         -- Make area stay loaded\r
 223         local pos1, pos2 = worldedit.allocate_with_nodes(origin_pos, nodes)\r
 224         local manip = minetest.get_voxel_manip()\r
 225         manip:read_from_map(pos1, pos2)\r
 226 \r
 227         local origin_x, origin_y, origin_z = origin_pos.x, origin_pos.y, origin_pos.z\r
 228         local count = 0\r
 229         local add_node, get_meta = minetest.add_node, minetest.get_meta\r
 230         for i, entry in ipairs(nodes) do\r
 231                 entry.x, entry.y, entry.z = origin_x + entry.x, origin_y + entry.y, origin_z + entry.z\r
 232                 -- Entry acts as both position and node\r
 233                 add_node(entry, entry)\r
 234                 if entry.meta then\r
 235                         get_meta(entry):from_table(entry.meta)\r
 236                 end\r
 237         end\r
 238         return #nodes\r
 239 end\r
 240 \r