builtin/common/misc_helpers.lua

   1 -- Minetest: builtin/misc_helpers.lua
   2
   3 --------------------------------------------------------------------------------
   4 -- Localize functions to avoid table lookups (better performance).
   5 local string_sub, string_find = string.sub, string.find
   6
   7 --------------------------------------------------------------------------------
   8 local function basic_dump(o)
   9         local tp = type(o)
  10         if tp == "number" then
  11                 return tostring(o)
  12         elseif tp == "string" then
  13                 return string.format("%q", o)
  14         elseif tp == "boolean" then
  15                 return tostring(o)
  16         elseif tp == "nil" then
  17                 return "nil"
  18         -- Uncomment for full function dumping support.
  19         -- Not currently enabled because bytecode isn't very human-readable and
  20         -- dump's output is intended for humans.
  21         --elseif tp == "function" then
  22         --      return string.format("loadstring(%q)", string.dump(o))
  23         elseif tp == "userdata" then
  24                 return tostring(o)
  25         else
  26                 return string.format("<%s>", tp)
  27         end
  28 end
  29
  30 local keywords = {
  31         ["and"] = true,
  32         ["break"] = true,
  33         ["do"] = true,
  34         ["else"] = true,
  35         ["elseif"] = true,
  36         ["end"] = true,
  37         ["false"] = true,
  38         ["for"] = true,
  39         ["function"] = true,
  40         ["goto"] = true,  -- Lua 5.2
  41         ["if"] = true,
  42         ["in"] = true,
  43         ["local"] = true,
  44         ["nil"] = true,
  45         ["not"] = true,
  46         ["or"] = true,
  47         ["repeat"] = true,
  48         ["return"] = true,
  49         ["then"] = true,
  50         ["true"] = true,
  51         ["until"] = true,
  52         ["while"] = true,
  53 }
  54 local function is_valid_identifier(str)
  55         if not str:find("^[a-zA-Z_][a-zA-Z0-9_]*$") or keywords[str] then
  56                 return false
  57         end
  58         return true
  59 end
  60
  61 --------------------------------------------------------------------------------
  62 -- Dumps values in a line-per-value format.
  63 -- For example, {test = {"Testing..."}} becomes:
  64 --   _["test"] = {}
  65 --   _["test"][1] = "Testing..."
  66 -- This handles tables as keys and circular references properly.
  67 -- It also handles multiple references well, writing the table only once.
  68 -- The dumped argument is internal-only.
  69
  70 function dump2(o, name, dumped)
  71         name = name or "_"
  72         -- "dumped" is used to keep track of serialized tables to handle
  73         -- multiple references and circular tables properly.
  74         -- It only contains tables as keys.  The value is the name that
  75         -- the table has in the dump, eg:
  76         -- {x = {"y"}} -> dumped[{"y"}] = '_["x"]'
  77         dumped = dumped or {}
  78         if type(o) ~= "table" then
  79                 return string.format("%s = %s\n", name, basic_dump(o))
  80         end
  81         if dumped[o] then
  82                 return string.format("%s = %s\n", name, dumped[o])
  83         end
  84         dumped[o] = name
  85         -- This contains a list of strings to be concatenated later (because
  86         -- Lua is slow at individual concatenation).
  87         local t = {}
  88         for k, v in pairs(o) do
  89                 local keyStr
  90                 if type(k) == "table" then
  91                         if dumped[k] then
  92                                 keyStr = dumped[k]
  93                         else
  94                                 -- Key tables don't have a name, so use one of
  95                                 -- the form _G["table: 0xFFFFFFF"]
  96                                 keyStr = string.format("_G[%q]", tostring(k))
  97                                 -- Dump key table
  98                                 t[#t + 1] = dump2(k, keyStr, dumped)
  99                         end
 100                 else
 101                         keyStr = basic_dump(k)
 102                 end
 103                 local vname = string.format("%s[%s]", name, keyStr)
 104                 t[#t + 1] = dump2(v, vname, dumped)
 105         end
 106         return string.format("%s = {}\n%s", name, table.concat(t))
 107 end
 108
 109 --------------------------------------------------------------------------------
 110 -- This dumps values in a one-statement format.
 111 -- For example, {test = {"Testing..."}} becomes:
 112 -- [[{
 113 --      test = {
 114 --              "Testing..."
 115 --      }
 116 -- }]]
 117 -- This supports tables as keys, but not circular references.
 118 -- It performs poorly with multiple references as it writes out the full
 119 -- table each time.
 120 -- The indent field specifies a indentation string, it defaults to a tab.
 121 -- Use the empty string to disable indentation.
 122 -- The dumped and level arguments are internal-only.
 123
 124 function dump(o, indent, nested, level)
 125         local t = type(o)
 126         if not level and t == "userdata" then
 127                 -- when userdata (e.g. player) is passed directly, print its metatable:
 128                 return "userdata metatable: " .. dump(getmetatable(o))
 129         end
 130         if t ~= "table" then
 131                 return basic_dump(o)
 132         end
 133
 134         -- Contains table -> true/nil of currently nested tables
 135         nested = nested or {}
 136         if nested[o] then
 137                 return "<circular reference>"
 138         end
 139         nested[o] = true
 140         indent = indent or "\t"
 141         level = level or 1
 142
 143         local ret = {}
 144         local dumped_indexes = {}
 145         for i, v in ipairs(o) do
 146                 ret[#ret + 1] = dump(v, indent, nested, level + 1)
 147                 dumped_indexes[i] = true
 148         end
 149         for k, v in pairs(o) do
 150                 if not dumped_indexes[k] then
 151                         if type(k) ~= "string" or not is_valid_identifier(k) then
 152                                 k = "["..dump(k, indent, nested, level + 1).."]"
 153                         end
 154                         v = dump(v, indent, nested, level + 1)
 155                         ret[#ret + 1] = k.." = "..v
 156                 end
 157         end
 158         nested[o] = nil
 159         if indent ~= "" then
 160                 local indent_str = "\n"..string.rep(indent, level)
 161                 local end_indent_str = "\n"..string.rep(indent, level - 1)
 162                 return string.format("{%s%s%s}",
 163                                 indent_str,
 164                                 table.concat(ret, ","..indent_str),
 165                                 end_indent_str)
 166         end
 167         return "{"..table.concat(ret, ", ").."}"
 168 end
 169
 170 --------------------------------------------------------------------------------
 171 function string.split(str, delim, include_empty, max_splits, sep_is_pattern)
 172         delim = delim or ","
 173         max_splits = max_splits or -2
 174         local items = {}
 175         local pos, len = 1, #str
 176         local plain = not sep_is_pattern
 177         max_splits = max_splits + 1
 178         repeat
 179                 local np, npe = string_find(str, delim, pos, plain)
 180                 np, npe = (np or (len+1)), (npe or (len+1))
 181                 if (not np) or (max_splits == 1) then
 182                         np = len + 1
 183                         npe = np
 184                 end
 185                 local s = string_sub(str, pos, np - 1)
 186                 if include_empty or (s ~= "") then
 187                         max_splits = max_splits - 1
 188                         items[#items + 1] = s
 189                 end
 190                 pos = npe + 1
 191         until (max_splits == 0) or (pos > (len + 1))
 192         return items
 193 end
 194
 195 --------------------------------------------------------------------------------
 196 function table.indexof(list, val)
 197         for i, v in ipairs(list) do
 198                 if v == val then
 199                         return i
 200                 end
 201         end
 202         return -1
 203 end
 204
 205 --------------------------------------------------------------------------------
 206 function string:trim()
 207         return self:match("^%s*(.-)%s*$")
 208 end
 209
 210 --------------------------------------------------------------------------------
 211 function math.hypot(x, y)
 212         return math.sqrt(x * x + y * y)
 213 end
 214
 215 --------------------------------------------------------------------------------
 216 function math.sign(x, tolerance)
 217         tolerance = tolerance or 0
 218         if x > tolerance then
 219                 return 1
 220         elseif x < -tolerance then
 221                 return -1
 222         end
 223         return 0
 224 end
 225
 226 --------------------------------------------------------------------------------
 227 function math.factorial(x)
 228         assert(x % 1 == 0 and x >= 0, "factorial expects a non-negative integer")
 229         if x >= 171 then
 230                 -- 171! is greater than the biggest double, no need to calculate
 231                 return math.huge
 232         end
 233         local v = 1
 234         for k = 2, x do
 235                 v = v * k
 236         end
 237         return v
 238 end
 239
 240
 241 function math.round(x)
 242         if x >= 0 then
 243                 return math.floor(x + 0.5)
 244         end
 245         return math.ceil(x - 0.5)
 246 end
 247
 248 local formspec_escapes = {
 249         ["\\"] = "\\\\",
 250         ["["] = "\\[",
 251         ["]"] = "\\]",
 252         [";"] = "\\;",
 253         [","] = "\\,"
 254 }
 255 function core.formspec_escape(text)
 256         -- Use explicit character set instead of dot here because it doubles the performance
 257         return text and string.gsub(text, "[\\%[%];,]", formspec_escapes)
 258 end
 259
 260
 261 function core.wrap_text(text, max_length, as_table)
 262         local result = {}
 263         local line = {}
 264         if #text <= max_length then
 265                 return as_table and {text} or text
 266         end
 267
 268         local line_length = 0
 269         for word in text:gmatch("%S+") do
 270                 if line_length > 0 and line_length + #word + 1 >= max_length then
 271                         -- word wouldn't fit on current line, move to next line
 272                         table.insert(result, table.concat(line, " "))
 273                         line = {word}
 274                         line_length = #word
 275                 else
 276                         table.insert(line, word)
 277                         line_length = line_length + 1 + #word
 278                 end
 279         end
 280
 281         table.insert(result, table.concat(line, " "))
 282         return as_table and result or table.concat(result, "\n")
 283 end
 284
 285 --------------------------------------------------------------------------------
 286
 287 if INIT == "game" then
 288         local dirs1 = {9, 18, 7, 12}
 289         local dirs2 = {20, 23, 22, 21}
 290
 291         function core.rotate_and_place(itemstack, placer, pointed_thing,
 292                         infinitestacks, orient_flags, prevent_after_place)
 293                 orient_flags = orient_flags or {}
 294
 295                 local unode = core.get_node_or_nil(pointed_thing.under)
 296                 if not unode then
 297                         return
 298                 end
 299                 local undef = core.registered_nodes[unode.name]
 300                 local sneaking = placer and placer:get_player_control().sneak
 301                 if undef and undef.on_rightclick and not sneaking then
 302                         return undef.on_rightclick(pointed_thing.under, unode, placer,
 303                                         itemstack, pointed_thing)
 304                 end
 305                 local fdir = placer and core.dir_to_facedir(placer:get_look_dir()) or 0
 306
 307                 local above = pointed_thing.above
 308                 local under = pointed_thing.under
 309                 local iswall = (above.y == under.y)
 310                 local isceiling = not iswall and (above.y < under.y)
 311
 312                 if undef and undef.buildable_to then
 313                         iswall = false
 314                 end
 315
 316                 if orient_flags.force_floor then
 317                         iswall = false
 318                         isceiling = false
 319                 elseif orient_flags.force_ceiling then
 320                         iswall = false
 321                         isceiling = true
 322                 elseif orient_flags.force_wall then
 323                         iswall = true
 324                         isceiling = false
 325                 elseif orient_flags.invert_wall then
 326                         iswall = not iswall
 327                 end
 328
 329                 local param2 = fdir
 330                 if iswall then
 331                         param2 = dirs1[fdir + 1]
 332                 elseif isceiling then
 333                         if orient_flags.force_facedir then
 334                                 param2 = 20
 335                         else
 336                                 param2 = dirs2[fdir + 1]
 337                         end
 338                 else -- place right side up
 339                         if orient_flags.force_facedir then
 340                                 param2 = 0
 341                         end
 342                 end
 343
 344                 local old_itemstack = ItemStack(itemstack)
 345                 local new_itemstack = core.item_place_node(itemstack, placer,
 346                                 pointed_thing, param2, prevent_after_place)
 347                 return infinitestacks and old_itemstack or new_itemstack
 348         end
 349
 350
 351 --------------------------------------------------------------------------------
 352 --Wrapper for rotate_and_place() to check for sneak and assume Creative mode
 353 --implies infinite stacks when performing a 6d rotation.
 354 --------------------------------------------------------------------------------
 355         core.rotate_node = function(itemstack, placer, pointed_thing)
 356                 local name = placer and placer:get_player_name() or ""
 357                 local invert_wall = placer and placer:get_player_control().sneak or false
 358                 return core.rotate_and_place(itemstack, placer, pointed_thing,
 359                         core.is_creative_enabled(name),
 360                         {invert_wall = invert_wall}, true)
 361         end
 362 end
 363
 364 --------------------------------------------------------------------------------
 365 function core.explode_table_event(evt)
 366         if evt ~= nil then
 367                 local parts = evt:split(":")
 368                 if #parts == 3 then
 369                         local t = parts[1]:trim()
 370                         local r = tonumber(parts[2]:trim())
 371                         local c = tonumber(parts[3]:trim())
 372                         if type(r) == "number" and type(c) == "number"
 373                                         and t ~= "INV" then
 374                                 return {type=t, row=r, column=c}
 375                         end
 376                 end
 377         end
 378         return {type="INV", row=0, column=0}
 379 end
 380
 381 --------------------------------------------------------------------------------
 382 function core.explode_textlist_event(evt)
 383         if evt ~= nil then
 384                 local parts = evt:split(":")
 385                 if #parts == 2 then
 386                         local t = parts[1]:trim()
 387                         local r = tonumber(parts[2]:trim())
 388                         if type(r) == "number" and t ~= "INV" then
 389                                 return {type=t, index=r}
 390                         end
 391                 end
 392         end
 393         return {type="INV", index=0}
 394 end
 395
 396 --------------------------------------------------------------------------------
 397 function core.explode_scrollbar_event(evt)
 398         local retval = core.explode_textlist_event(evt)
 399
 400         retval.value = retval.index
 401         retval.index = nil
 402
 403         return retval
 404 end
 405
 406 --------------------------------------------------------------------------------
 407 function core.rgba(r, g, b, a)
 408         return a and string.format("#%02X%02X%02X%02X", r, g, b, a) or
 409                         string.format("#%02X%02X%02X", r, g, b)
 410 end
 411
 412 --------------------------------------------------------------------------------
 413 function core.pos_to_string(pos, decimal_places)
 414         local x = pos.x
 415         local y = pos.y
 416         local z = pos.z
 417         if decimal_places ~= nil then
 418                 x = string.format("%." .. decimal_places .. "f", x)
 419                 y = string.format("%." .. decimal_places .. "f", y)
 420                 z = string.format("%." .. decimal_places .. "f", z)
 421         end
 422         return "(" .. x .. "," .. y .. "," .. z .. ")"
 423 end
 424
 425 --------------------------------------------------------------------------------
 426 function core.string_to_pos(value)
 427         if value == nil then
 428                 return nil
 429         end
 430
 431         value = value:match("^%((.-)%)$") or value -- strip parentheses
 432
 433         local x, y, z = value:trim():match("^([%d.-]+)[,%s]%s*([%d.-]+)[,%s]%s*([%d.-]+)$")
 434         if x and y and z then
 435                 x = tonumber(x)
 436                 y = tonumber(y)
 437                 z = tonumber(z)
 438                 return vector.new(x, y, z)
 439         end
 440
 441         return nil
 442 end
 443
 444
 445 --------------------------------------------------------------------------------
 446
 447 do
 448         local rel_num_cap = "(~?-?%d*%.?%d*)" -- may be overly permissive as this will be tonumber'ed anyways
 449         local num_delim = "[,%s]%s*"
 450         local pattern = "^" .. table.concat({rel_num_cap, rel_num_cap, rel_num_cap}, num_delim) .. "$"
 451
 452         local function parse_area_string(pos, relative_to)
 453                 local pp = {}
 454                 pp.x, pp.y, pp.z = pos:trim():match(pattern)
 455                 return core.parse_coordinates(pp.x, pp.y, pp.z, relative_to)
 456         end
 457
 458         function core.string_to_area(value, relative_to)
 459                 local p1, p2 = value:match("^%((.-)%)%s*%((.-)%)$")
 460                 if not p1 then
 461                         return
 462                 end
 463
 464                 p1 = parse_area_string(p1, relative_to)
 465                 p2 = parse_area_string(p2, relative_to)
 466
 467                 if p1 == nil or p2 == nil then
 468                         return
 469                 end
 470
 471                 return p1, p2
 472         end
 473 end
 474
 475 --------------------------------------------------------------------------------
 476 function table.copy(t, seen)
 477         local n = {}
 478         seen = seen or {}
 479         seen[t] = n
 480         for k, v in pairs(t) do
 481                 n[(type(k) == "table" and (seen[k] or table.copy(k, seen))) or k] =
 482                         (type(v) == "table" and (seen[v] or table.copy(v, seen))) or v
 483         end
 484         return n
 485 end
 486
 487
 488 function table.insert_all(t, other)
 489         for i=1, #other do
 490                 t[#t + 1] = other[i]
 491         end
 492         return t
 493 end
 494
 495
 496 function table.key_value_swap(t)
 497         local ti = {}
 498         for k,v in pairs(t) do
 499                 ti[v] = k
 500         end
 501         return ti
 502 end
 503
 504
 505 function table.shuffle(t, from, to, random)
 506         from = from or 1
 507         to = to or #t
 508         random = random or math.random
 509         local n = to - from + 1
 510         while n > 1 do
 511                 local r = from + n-1
 512                 local l = from + random(0, n-1)
 513                 t[l], t[r] = t[r], t[l]
 514                 n = n-1
 515         end
 516 end
 517
 518
 519 --------------------------------------------------------------------------------
 520 -- mainmenu only functions
 521 --------------------------------------------------------------------------------
 522 if INIT == "mainmenu" then
 523         function core.get_game(index)
 524                 local games = core.get_games()
 525
 526                 if index > 0 and index <= #games then
 527                         return games[index]
 528                 end
 529
 530                 return nil
 531         end
 532 end
 533
 534 if core.gettext then -- for client and mainmenu
 535         function fgettext_ne(text, ...)
 536                 text = core.gettext(text)
 537                 local arg = {n=select('#', ...), ...}
 538                 if arg.n >= 1 then
 539                         -- Insert positional parameters ($1, $2, ...)
 540                         local result = ''
 541                         local pos = 1
 542                         while pos <= text:len() do
 543                                 local newpos = text:find('[$]', pos)
 544                                 if newpos == nil then
 545                                         result = result .. text:sub(pos)
 546                                         pos = text:len() + 1
 547                                 else
 548                                         local paramindex =
 549                                                 tonumber(text:sub(newpos+1, newpos+1))
 550                                         result = result .. text:sub(pos, newpos-1)
 551                                                 .. tostring(arg[paramindex])
 552                                         pos = newpos + 2
 553                                 end
 554                         end
 555                         text = result
 556                 end
 557                 return text
 558         end
 559
 560         function fgettext(text, ...)
 561                 return core.formspec_escape(fgettext_ne(text, ...))
 562         end
 563 end
 564
 565 local ESCAPE_CHAR = string.char(0x1b)
 566
 567 function core.get_color_escape_sequence(color)
 568         return ESCAPE_CHAR .. "(c@" .. color .. ")"
 569 end
 570
 571 function core.get_background_escape_sequence(color)
 572         return ESCAPE_CHAR .. "(b@" .. color .. ")"
 573 end
 574
 575 function core.colorize(color, message)
 576         local lines = tostring(message):split("\n", true)
 577         local color_code = core.get_color_escape_sequence(color)
 578
 579         for i, line in ipairs(lines) do
 580                 lines[i] = color_code .. line
 581         end
 582
 583         return table.concat(lines, "\n") .. core.get_color_escape_sequence("#ffffff")
 584 end
 585
 586
 587 function core.strip_foreground_colors(str)
 588         return (str:gsub(ESCAPE_CHAR .. "%(c@[^)]+%)", ""))
 589 end
 590
 591 function core.strip_background_colors(str)
 592         return (str:gsub(ESCAPE_CHAR .. "%(b@[^)]+%)", ""))
 593 end
 594
 595 function core.strip_colors(str)
 596         return (str:gsub(ESCAPE_CHAR .. "%([bc]@[^)]+%)", ""))
 597 end
 598
 599 function core.translate(textdomain, str, ...)
 600         local start_seq
 601         if textdomain == "" then
 602                 start_seq = ESCAPE_CHAR .. "T"
 603         else
 604                 start_seq = ESCAPE_CHAR .. "(T@" .. textdomain .. ")"
 605         end
 606         local arg = {n=select('#', ...), ...}
 607         local end_seq = ESCAPE_CHAR .. "E"
 608         local arg_index = 1
 609         local translated = str:gsub("@(.)", function(matched)
 610                 local c = string.byte(matched)
 611                 if string.byte("1") <= c and c <= string.byte("9") then
 612                         local a = c - string.byte("0")
 613                         if a ~= arg_index then
 614                                 error("Escape sequences in string given to core.translate " ..
 615                                         "are not in the correct order: got @" .. matched ..
 616                                         "but expected @" .. tostring(arg_index))
 617                         end
 618                         if a > arg.n then
 619                                 error("Not enough arguments provided to core.translate")
 620                         end
 621                         arg_index = arg_index + 1
 622                         return ESCAPE_CHAR .. "F" .. arg[a] .. ESCAPE_CHAR .. "E"
 623                 elseif matched == "n" then
 624                         return "\n"
 625                 else
 626                         return matched
 627                 end
 628         end)
 629         if arg_index < arg.n + 1 then
 630                 error("Too many arguments provided to core.translate")
 631         end
 632         return start_seq .. translated .. end_seq
 633 end
 634
 635 function core.get_translator(textdomain)
 636         return function(str, ...) return core.translate(textdomain or "", str, ...) end
 637 end
 638
 639 --------------------------------------------------------------------------------
 640 -- Returns the exact coordinate of a pointed surface
 641 --------------------------------------------------------------------------------
 642 function core.pointed_thing_to_face_pos(placer, pointed_thing)
 643         -- Avoid crash in some situations when player is inside a node, causing
 644         -- 'above' to equal 'under'.
 645         if vector.equals(pointed_thing.above, pointed_thing.under) then
 646                 return pointed_thing.under
 647         end
 648
 649         local eye_height = placer:get_properties().eye_height
 650         local eye_offset_first = placer:get_eye_offset()
 651         local node_pos = pointed_thing.under
 652         local camera_pos = placer:get_pos()
 653         local pos_off = vector.multiply(
 654                         vector.subtract(pointed_thing.above, node_pos), 0.5)
 655         local look_dir = placer:get_look_dir()
 656         local offset, nc
 657         local oc = {}
 658
 659         for c, v in pairs(pos_off) do
 660                 if nc or v == 0 then
 661                         oc[#oc + 1] = c
 662                 else
 663                         offset = v
 664                         nc = c
 665                 end
 666         end
 667
 668         local fine_pos = {[nc] = node_pos[nc] + offset}
 669         camera_pos.y = camera_pos.y + eye_height + eye_offset_first.y / 10
 670         local f = (node_pos[nc] + offset - camera_pos[nc]) / look_dir[nc]
 671
 672         for i = 1, #oc do
 673                 fine_pos[oc[i]] = camera_pos[oc[i]] + look_dir[oc[i]] * f
 674         end
 675         return fine_pos
 676 end
 677
 678 function core.string_to_privs(str, delim)
 679         assert(type(str) == "string")
 680         delim = delim or ','
 681         local privs = {}
 682         for _, priv in pairs(string.split(str, delim)) do
 683                 privs[priv:trim()] = true
 684         end
 685         return privs
 686 end
 687
 688 function core.privs_to_string(privs, delim)
 689         assert(type(privs) == "table")
 690         delim = delim or ','
 691         local list = {}
 692         for priv, bool in pairs(privs) do
 693                 if bool then
 694                         list[#list + 1] = priv
 695                 end
 696         end
 697         return table.concat(list, delim)
 698 end
 699
 700 function core.is_nan(number)
 701         return number ~= number
 702 end
 703
 704 --[[ Helper function for parsing an optionally relative number
 705 of a chat command parameter, using the chat command tilde notation.
 706
 707 Parameters:
 708 * arg: String snippet containing the number; possible values:
 709     * "<number>": return as number
 710     * "~<number>": return relative_to + <number>
 711     * "~": return relative_to
 712     * Anything else will return `nil`
 713 * relative_to: Number to which the `arg` number might be relative to
 714
 715 Returns:
 716 A number or `nil`, depending on `arg.
 717
 718 Examples:
 719 * `core.parse_relative_number("5", 10)` returns 5
 720 * `core.parse_relative_number("~5", 10)` returns 15
 721 * `core.parse_relative_number("~", 10)` returns 10
 722 ]]
 723 function core.parse_relative_number(arg, relative_to)
 724         if not arg then
 725                 return nil
 726         elseif arg == "~" then
 727                 return relative_to
 728         elseif string.sub(arg, 1, 1) == "~" then
 729                 local number = tonumber(string.sub(arg, 2))
 730                 if not number then
 731                         return nil
 732                 end
 733                 if core.is_nan(number) or number == math.huge or number == -math.huge then
 734                         return nil
 735                 end
 736                 return relative_to + number
 737         else
 738                 local number = tonumber(arg)
 739                 if core.is_nan(number) or number == math.huge or number == -math.huge then
 740                         return nil
 741                 end
 742                 return number
 743         end
 744 end
 745
 746 --[[ Helper function to parse coordinates that might be relative
 747 to another position; supports chat command tilde notation.
 748 Intended to be used in chat command parameter parsing.
 749
 750 Parameters:
 751 * x, y, z: Parsed x, y, and z coordinates as strings
 752 * relative_to: Position to which to compare the position
 753
 754 Syntax of x, y and z:
 755 * "<number>": return as number
 756 * "~<number>": return <number> + player position on this axis
 757 * "~": return player position on this axis
 758
 759 Returns: a vector or nil for invalid input or if player does not exist
 760 ]]
 761 function core.parse_coordinates(x, y, z, relative_to)
 762         if not relative_to then
 763                 x, y, z = tonumber(x), tonumber(y), tonumber(z)
 764                 return x and y and z and { x = x, y = y, z = z }
 765         end
 766         local rx = core.parse_relative_number(x, relative_to.x)
 767         local ry = core.parse_relative_number(y, relative_to.y)
 768         local rz = core.parse_relative_number(z, relative_to.z)
 769         return rx and ry and rz and { x = rx, y = ry, z = rz }
 770 end