mirror of
https://github.com/appgurueu/modlib.git
synced 2024-09-12 00:06:49 +02:00
197 lines
6.2 KiB
Lua
197 lines
6.2 KiB
Lua
|
max_wear = 2 ^ 16 - 1
|
||
|
function override(function_name, function_builder)
|
||
|
local func = minetest[function_name]
|
||
|
minetest["original_" .. function_name] = func
|
||
|
minetest[function_name] = function_builder(func)
|
||
|
end
|
||
|
|
||
|
-- TODO fix modlib.minetest.get_gametime() messing up responsible "mod" determined by engine on crash
|
||
|
get_gametime = minetest.get_gametime
|
||
|
local get_gametime_initialized
|
||
|
local function get_gametime_init(dtime)
|
||
|
if get_gametime_initialized then
|
||
|
-- if the profiler is being used, the globalstep can't be unregistered
|
||
|
return
|
||
|
end
|
||
|
get_gametime_initialized = true
|
||
|
assert(dtime == 0)
|
||
|
local gametime = minetest.get_gametime()
|
||
|
assert(gametime)
|
||
|
function modlib.minetest.get_gametime()
|
||
|
local imprecise_gametime = minetest.get_gametime()
|
||
|
if imprecise_gametime > gametime then
|
||
|
minetest.log("warning", "modlib.minetest.get_gametime(): Called after increment and before first globalstep")
|
||
|
return imprecise_gametime
|
||
|
end
|
||
|
return gametime
|
||
|
end
|
||
|
for index, globalstep in pairs(minetest.registered_globalsteps) do
|
||
|
if globalstep == get_gametime_init then
|
||
|
table.remove(minetest.registered_globalsteps, index)
|
||
|
break
|
||
|
end
|
||
|
end
|
||
|
-- globalsteps of mods which depend on modlib will execute after this
|
||
|
minetest.register_globalstep(function(dtime)
|
||
|
gametime = gametime + dtime
|
||
|
end)
|
||
|
end
|
||
|
minetest.register_globalstep(get_gametime_init)
|
||
|
|
||
|
delta_times={}
|
||
|
delays={}
|
||
|
callbacks={}
|
||
|
function register_globalstep(interval, callback)
|
||
|
if type(callback) ~= "function" then
|
||
|
return
|
||
|
end
|
||
|
table.insert(delta_times, 0)
|
||
|
table.insert(delays, interval)
|
||
|
table.insert(callbacks, callback)
|
||
|
end
|
||
|
function texture_modifier_inventorycube(face_1, face_2, face_3)
|
||
|
return "[inventorycube{" .. string.gsub(face_1, "%^", "&")
|
||
|
.. "{" .. string.gsub(face_2, "%^", "&")
|
||
|
.. "{" .. string.gsub(face_3, "%^", "&")
|
||
|
end
|
||
|
function get_node_inventory_image(nodename)
|
||
|
local n = minetest.registered_nodes[nodename]
|
||
|
if not n then
|
||
|
return
|
||
|
end
|
||
|
local tiles = {}
|
||
|
for l, tile in pairs(n.tiles or {}) do
|
||
|
tiles[l] = (type(tile) == "string" and tile) or tile.name
|
||
|
end
|
||
|
local chosen_tiles = { tiles[1], tiles[3], tiles[5] }
|
||
|
if #chosen_tiles == 0 then
|
||
|
return false
|
||
|
end
|
||
|
if not chosen_tiles[2] then
|
||
|
chosen_tiles[2] = chosen_tiles[1]
|
||
|
end
|
||
|
if not chosen_tiles[3] then
|
||
|
chosen_tiles[3] = chosen_tiles[2]
|
||
|
end
|
||
|
local img = minetest.registered_items[nodename].inventory_image
|
||
|
if string.len(img) == 0 then
|
||
|
img = nil
|
||
|
end
|
||
|
return img or texture_modifier_inventorycube(chosen_tiles[1], chosen_tiles[2], chosen_tiles[3])
|
||
|
end
|
||
|
function get_color_int(color)
|
||
|
return color.b + (color.g*256) + (color.r*256*256)
|
||
|
end
|
||
|
function check_player_privs(playername, privtable)
|
||
|
local privs=minetest.get_player_privs(playername)
|
||
|
local missing_privs={}
|
||
|
local to_lose_privs={}
|
||
|
for priv, expected_value in pairs(privtable) do
|
||
|
local actual_value=privs[priv]
|
||
|
if expected_value then
|
||
|
if not actual_value then
|
||
|
table.insert(missing_privs, priv)
|
||
|
end
|
||
|
else
|
||
|
if actual_value then
|
||
|
table.insert(to_lose_privs, priv)
|
||
|
end
|
||
|
end
|
||
|
end
|
||
|
return missing_privs, to_lose_privs
|
||
|
end
|
||
|
|
||
|
minetest.register_globalstep(function(dtime)
|
||
|
for k, v in pairs(delta_times) do
|
||
|
local v=dtime+v
|
||
|
if v > delays[k] then
|
||
|
callbacks[k](v)
|
||
|
v=0
|
||
|
end
|
||
|
delta_times[k]=v
|
||
|
end
|
||
|
end)
|
||
|
|
||
|
form_listeners = {}
|
||
|
function register_form_listener(formname, func)
|
||
|
local current_listeners = form_listeners[formname] or {}
|
||
|
table.insert(current_listeners, func)
|
||
|
form_listeners[formname] = current_listeners
|
||
|
end
|
||
|
|
||
|
minetest.register_on_player_receive_fields(function(player, formname, fields)
|
||
|
local handlers = form_listeners[formname]
|
||
|
if handlers then
|
||
|
for _, handler in pairs(handlers) do
|
||
|
handler(player, fields)
|
||
|
end
|
||
|
end
|
||
|
end)
|
||
|
|
||
|
--+ Improved base64 decode removing valid padding
|
||
|
function decode_base64(base64)
|
||
|
local len = base64:len()
|
||
|
local padding_char = base64:sub(len, len) == "="
|
||
|
if padding_char then
|
||
|
if len % 4 ~= 0 then
|
||
|
return
|
||
|
end
|
||
|
if base64:sub(len-1, len-1) == "=" then
|
||
|
base64 = base64:sub(1, len-2)
|
||
|
else
|
||
|
base64 = base64:sub(1, len-1)
|
||
|
end
|
||
|
end
|
||
|
return minetest.decode_base64(base64)
|
||
|
end
|
||
|
|
||
|
local object_refs = minetest.object_refs
|
||
|
--+ Objects inside radius iterator. Uses a linear search.
|
||
|
function objects_inside_radius(pos, radius)
|
||
|
radius = radius^2
|
||
|
local id, object, object_pos
|
||
|
return function()
|
||
|
repeat
|
||
|
id, object = next(object_refs, id)
|
||
|
object_pos = object:get_pos()
|
||
|
until (not object) or ((pos.x-object_pos.x)^2 + (pos.y-object_pos.y)^2 + (pos.z-object_pos.z)^2) <= radius
|
||
|
return object
|
||
|
end
|
||
|
end
|
||
|
|
||
|
--+ Objects inside area iterator. Uses a linear search.
|
||
|
function objects_inside_area(min, max)
|
||
|
local id, object, object_pos
|
||
|
return function()
|
||
|
repeat
|
||
|
id, object = next(object_refs, id)
|
||
|
object_pos = object:get_pos()
|
||
|
until (not object) or (
|
||
|
(min.x <= object_pos.x and min.y <= object_pos.y and min.z <= object_pos.z)
|
||
|
and
|
||
|
(max.y >= object_pos.x and max.y >= object_pos.y and max.z >= object_pos.z)
|
||
|
)
|
||
|
return object
|
||
|
end
|
||
|
end
|
||
|
|
||
|
--: node_or_groupname "modname:nodename", "group:groupname[,groupname]"
|
||
|
--> function(nodename) -> whether node matches
|
||
|
function nodename_matcher(node_or_groupname)
|
||
|
if modlib.text.starts_with(node_or_groupname, "group:") then
|
||
|
-- TODO consider using modlib.text.split instead of Minetest's string.split
|
||
|
local groups = node_or_groupname:sub(("group:"):len() + 1):split(",")
|
||
|
return function(nodename)
|
||
|
for _, groupname in pairs(groups) do
|
||
|
if minetest.get_item_group(nodename, groupname) == 0 then
|
||
|
return false
|
||
|
end
|
||
|
end
|
||
|
return true
|
||
|
end
|
||
|
else
|
||
|
return function(nodename)
|
||
|
return nodename == node_or_groupname
|
||
|
end
|
||
|
end
|
||
|
end
|