X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=builtin%2Fgame%2Fmisc.lua;h=d7164812aaa4c5046bcb1c0fa6f23b8e2171aab0;hb=0b0075e6ad0b3110cabdfc92cedb0a24d2b5ec42;hp=a71d5d02a7a3157eb70ff149b336c4e0410c9cff;hpb=75622c30beb390b7ed578010a00390aa971b3951;p=dragonfireclient.git diff --git a/builtin/game/misc.lua b/builtin/game/misc.lua index a71d5d02a..d7164812a 100644 --- a/builtin/game/misc.lua +++ b/builtin/game/misc.lua @@ -4,68 +4,133 @@ -- Misc. API functions -- -core.timers_to_add = {} -core.timers = {} +local jobs = {} +local time = 0.0 +local last = core.get_us_time() / 1000000 + core.register_globalstep(function(dtime) - for _, timer in ipairs(core.timers_to_add) do - table.insert(core.timers, timer) - end - core.timers_to_add = {} - local index = 1 - while index <= #core.timers do - local timer = core.timers[index] - timer.time = timer.time - dtime - if timer.time <= 0 then - timer.func(unpack(timer.args or {})) - table.remove(core.timers,index) - else - index = index + 1 + local new = core.get_us_time() / 1000000 + if new > last then + time = time + (new - last) + else + -- Overflow, we may lose a little bit of time here but + -- only 1 tick max, potentially running timers slightly + -- too early. + time = time + new + end + last = new + + if #jobs < 1 then + return + end + + -- Iterate backwards so that we miss any new timers added by + -- a timer callback, and so that we don't skip the next timer + -- in the list if we remove one. + for i = #jobs, 1, -1 do + local job = jobs[i] + if time >= job.expire then + core.set_last_run_mod(job.mod_origin) + job.func(unpack(job.arg)) + table.remove(jobs, i) end end end) -function core.after(time, func, ...) +function core.after(after, func, ...) assert(tonumber(time) and type(func) == "function", "Invalid core.after invocation") - table.insert(core.timers_to_add, {time=time, func=func, args={...}}) + jobs[#jobs + 1] = { + func = func, + expire = time + after, + arg = {...}, + mod_origin = core.get_last_run_mod() + } end -function core.check_player_privs(name, privs) +function core.check_player_privs(name, ...) + local arg_type = type(name) + if (arg_type == "userdata" or arg_type == "table") and + name.get_player_name then -- If it quacks like a Player... + name = name:get_player_name() + elseif arg_type ~= "string" then + error("Invalid core.check_player_privs argument type: " .. arg_type, 2) + end + + local requested_privs = {...} local player_privs = core.get_player_privs(name) local missing_privileges = {} - for priv, val in pairs(privs) do - if val then + + if type(requested_privs[1]) == "table" then + -- We were provided with a table like { privA = true, privB = true }. + for priv, value in pairs(requested_privs[1]) do + if value and not player_privs[priv] then + missing_privileges[#missing_privileges + 1] = priv + end + end + else + -- Only a list, we can process it directly. + for key, priv in pairs(requested_privs) do if not player_privs[priv] then - table.insert(missing_privileges, priv) + missing_privileges[#missing_privileges + 1] = priv end end end + if #missing_privileges > 0 then return false, missing_privileges end + return true, "" end local player_list = {} core.register_on_joinplayer(function(player) - player_list[player:get_player_name()] = player + local player_name = player:get_player_name() + player_list[player_name] = player + core.chat_send_all("*** " .. player_name .. " joined the game.") end) -core.register_on_leaveplayer(function(player) - player_list[player:get_player_name()] = nil +core.register_on_leaveplayer(function(player, timed_out) + local player_name = player:get_player_name() + player_list[player_name] = nil + local announcement = "*** " .. player_name .. " left the game." + if timed_out then + announcement = announcement .. " (timed out)" + end + core.chat_send_all(announcement) end) function core.get_connected_players() local temp_table = {} for index, value in pairs(player_list) do if value:is_player_connected() then - table.insert(temp_table, value) + temp_table[#temp_table + 1] = value end end return temp_table end +-- Returns two position vectors representing a box of `radius` in each +-- direction centered around the player corresponding to `player_name` +function core.get_player_radius_area(player_name, radius) + local player = core.get_player_by_name(player_name) + if player == nil then + return nil + end + + local p1 = player:getpos() + local p2 = p1 + + if radius then + p1 = vector.subtract(p1, radius) + p2 = vector.add(p2, radius) + end + + return p1, p2 +end + function core.hash_node_position(pos) return (pos.z+32768)*65536*65536 + (pos.y+32768)*65536 + pos.x+32768 end @@ -123,3 +188,54 @@ function core.raillike_group(name) end return id end + +-- HTTP callback interface +function core.http_add_fetch(httpenv) + httpenv.fetch = function(req, callback) + local handle = httpenv.fetch_async(req) + + local function update_http_status() + local res = httpenv.fetch_async_get(handle) + if res.completed then + callback(res) + else + core.after(0, update_http_status) + end + end + core.after(0, update_http_status) + end + + return httpenv +end + +if minetest.setting_getbool("disable_escape_sequences") then + + function core.get_color_escape_sequence(color) + return "" + end + + function core.get_background_escape_sequence(color) + return "" + end + + function core.colorize(color, message) + return message + end + +else + + local ESCAPE_CHAR = string.char(0x1b) + function core.get_color_escape_sequence(color) + return ESCAPE_CHAR .. "(c@" .. color .. ")" + end + + function core.get_background_escape_sequence(color) + return ESCAPE_CHAR .. "(b@" .. color .. ")" + end + + function core.colorize(color, message) + return core.get_color_escape_sequence(color) .. message .. core.get_color_escape_sequence("#ffffff") + end + +end +